@entake/particle 17.0.0

package/esm2022/app/modules/theming/services/theming.service.mjs

@@ -0,0 +1,507 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { Z_INDEX_LAYERS } from '../models/theme.model';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../shared/services/local-storage.service";
+import * as i2 from "./theme-change-detection.service";
+export class ThemingService {
+    localStorageService;
+    themeChangeDetectionService;
+    // PSA: ORDER MATTERS, DO NOT MOVE ITEMS AROUND
+    defaultZIndexes = [
+        Z_INDEX_LAYERS.BASE,
+        Z_INDEX_LAYERS.FRAME,
+        Z_INDEX_LAYERS.OVERLAY,
+        Z_INDEX_LAYERS.DIALOG,
+        Z_INDEX_LAYERS.NOTIFICATION
+    ];
+    /**
+     * Prefix used to build the key for local storage of the theme
+     */
+    THEME_KEY = 'theme';
+    /**
+     * A private BehaviorSubject to store the loaded themes
+     */
+    themes = new BehaviorSubject([]);
+    $selectedTheme = new BehaviorSubject(null);
+    get selectedTheme() {
+        return this.$selectedTheme.asObservable();
+    }
+    /**
+     * Key for the product this is deployed into
+     */
+    applicationName = null;
+    /**
+     * Constructor
+     *
+     * @param localStorageService
+     * @param themeChangeDetectionService
+     */
+    constructor(localStorageService, themeChangeDetectionService) {
+        this.localStorageService = localStorageService;
+        this.themeChangeDetectionService = themeChangeDetectionService;
+    }
+    /**
+     * Converts a JSON property name to snake case
+     *
+     * @param prop
+     */
+    toSnakeCase(prop) {
+        return prop.split(/(?=[A-Z])/).join('_').toLowerCase();
+    }
+    toKebabCase(prop) {
+        return prop.split(/(?=[A-Z])/).join('-').toLowerCase();
+    }
+    convertUnderscoreToDash(prop) {
+        return prop.split('_').join('-').toLowerCase();
+    }
+    /**
+     * For the given color, it'll lighten or darken the color by the percentage supplied. Positive percent will lighten, negative to darken.
+     *
+     * @param color
+     * @param percent
+     */
+    lightenDarkenColor(color, percent) {
+        let usePound = false;
+        if (color[0] === '#') {
+            color = color.slice(1);
+            usePound = true;
+        }
+        const num = parseInt(color, 16);
+        let r = (num >> 16) + percent;
+        if (r > 255) {
+            r = 255;
+        }
+        else if (r < 0) {
+            r = 0;
+        }
+        let b = ((num >> 8) & 0x00FF) + percent;
+        if (b > 255) {
+            b = 255;
+        }
+        else if (b < 0) {
+            b = 0;
+        }
+        let g = (num & 0x0000FF) + percent;
+        if (g > 255) {
+            g = 255;
+        }
+        else if (g < 0) {
+            g = 0;
+        }
+        let newColor = (g | (b << 8) | (r << 16)).toString(16);
+        while (newColor.length < 6) {
+            newColor = '0' + newColor;
+        }
+        return (usePound ? '#' : '') + newColor;
+    }
+    /**
+     * Converts a hex value to a Javascript object with r,g, and b variables.
+     *
+     * @param hex
+     */
+    hexToRgb(hex) {
+        const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+        return result ? {
+            r: parseInt(result[1], 16),
+            g: parseInt(result[2], 16),
+            b: parseInt(result[3], 16)
+        } : null;
+    }
+    /**
+     * Generates a random hex color
+     */
+    getRandomColor() {
+        return '#' + Math.floor(Math.random() * 16777215).toString(16);
+    }
+    /**
+     * On App Initialization (in app.component.ts, ngOnInit) call this to load themes and apply the user selected theme or default theme.
+     *
+     * @param applicationName
+     * @param themes
+     */
+    appInit(applicationName, themes) {
+        if (!applicationName) {
+            throw new Error('Application Name was not supplied.');
+        }
+        this.applicationName = applicationName;
+        this.themes.next(themes);
+        this.applySettings();
+    }
+    /**
+     * Return the themes for the current app
+     */
+    getThemes() {
+        return this.themes;
+    }
+    /**
+     * Apply the selected theme
+     */
+    applySettings() {
+        const settings = this.getTheme();
+        this.$selectedTheme.next(settings);
+        this.changeColors(settings);
+    }
+    /**
+     * Constructs a theme object based on another theme object
+     *
+     * @param theme
+     */
+    generateTheme(theme) {
+        let newTheme = {};
+        if (theme) {
+            for (const prop of Object.keys(theme)) {
+                // @ts-ignore
+                newTheme[prop] = theme[prop];
+            }
+        }
+        else {
+            newTheme = this.themes.getValue().find(theTheme => theTheme.isDefault);
+        }
+        return newTheme;
+    }
+    /**
+     * Returns a list of the color classes specifically based on the properties of the theme model
+     */
+    getClassesFromTheme(theme) {
+        const classes = [];
+        for (const prop of Object.keys(theme)) {
+            if (prop.toLowerCase().includes('bg') || prop.toLowerCase().includes('color')) {
+                classes.push(prop.split(/(?=[A-Z])/).join('_').toLowerCase());
+            }
+        }
+        return classes;
+    }
+    /**
+     * Returns the user selected theme from local storage
+     */
+    getTheme() {
+        const themeId = this.localStorageService.getObject(this.applicationName + this.THEME_KEY);
+        let defaultTheme = this.themes.value.filter(theme => theme.isDefault)[0];
+        for (const theme of this.themes.value) {
+            if (theme.themeId === themeId) {
+                return theme;
+            }
+        }
+        return defaultTheme;
+    }
+    /**
+     * Persists the user selected theme in local storage
+     *
+     * @param settings
+     */
+    saveTheme(settings) {
+        this.$selectedTheme.next(settings);
+        this.localStorageService.putObject(this.applicationName + this.THEME_KEY, settings.themeId);
+    }
+    /**
+     * Writes the theme information to a style tag in the header so that the theme is applied.
+     *
+     * @param theme
+     * @param prefix
+     */
+    changeColors(theme, prefix) {
+        if (!prefix) {
+            prefix = '';
+        }
+        const style = document.createElement('style');
+        let rootVars = ':root {';
+        // Render the color palette styles
+        if (theme.colorPalette) {
+            for (const prop of Object.keys(theme.colorPalette)) {
+                if (prop !== 'extension') {
+                    const value = theme.colorPalette[prop];
+                    const color = this.addHashmark(value);
+                    this.generateColors(style, color, prefix + this.toSnakeCase(prop));
+                    rootVars += `--${prefix}${this.toKebabCase(prop)}-color: ${color};`;
+                }
+            }
+            for (const extension of theme.colorPalette.extension) {
+                if (extension.textColor && !extension.color) {
+                    style.appendChild(document.createTextNode(`.${prefix}${extension.className}{color: ${this.addHashmark(extension.textColor)};}`));
+                }
+                if (extension.color) {
+                    if (!extension.textColor) {
+                        this.generateColors(style, this.addHashmark(extension.color), prefix + extension.className);
+                    }
+                    else {
+                        style.appendChild(document.createTextNode(`.${prefix}${extension.className}{background-color: ${this.addHashmark(extension.color)};color: ${this.addHashmark(extension.textColor)};fill: currentColor;}`));
+                    }
+                    rootVars += `--${prefix}${this.convertUnderscoreToDash(extension.className)}: ${this.addHashmark(extension.color)};`;
+                }
+            }
+        }
+        // Render the layout color styles
+        if (theme.layoutColors) {
+            for (const prop of Object.keys(theme.layoutColors)) {
+                const value = theme.layoutColors[prop];
+                const color = value.startsWith('#') ? value : '#' + value;
+                this.generateColors(style, color, prefix + this.toSnakeCase(prop));
+                rootVars += `--${prefix}${this.toKebabCase(prop)}: ${color};`;
+            }
+            if (this.isDarkTheme(theme.layoutColors.bodyColor)) {
+                style.appendChild(document.createTextNode(`.${prefix}bg_overlay{background-color:rgba(255,255,255,0.05);color:inherit;}`));
+                style.appendChild(document.createTextNode(`.${prefix}bg_overlay_rev{background-color:rgba(0,0,0,0.05);color:inherit;}`));
+                style.appendChild(document.createTextNode(`.${prefix}brdr{border:1px solid rgba(150,150,150,0.5);}`));
+            }
+            else {
+                style.appendChild(document.createTextNode(`.${prefix}bg_overlay{background-color:rgba(255,255,255,0.1);color:inherit;}`));
+                style.appendChild(document.createTextNode(`.${prefix}bg_overlay_rev{background-color:rgba(0,0,0,0.04);color:inherit;}`));
+                style.appendChild(document.createTextNode(`.${prefix}brdr{border:1px solid rgba(150,150,150,0.5);}`));
+            }
+        }
+        if (theme.accessibility && theme.accessibility.enabled) {
+            const outlineColor = theme.accessibility.highlightColor.startsWith('#') ? theme.accessibility.highlightColor : '#' + theme.accessibility.highlightColor;
+            style.appendChild(document.createTextNode(`.${prefix}access{outline: ${outlineColor} ${theme.accessibility.highlightThickness} solid !important;outline-color: transparent !important;transition:all 0.3s ease-in-out;}`));
+            style.appendChild(document.createTextNode(`.${prefix}access:focus{outline: ${outlineColor} ${theme.accessibility.highlightThickness} solid !important;outline-offset: ${theme.accessibility.highlightOffset};}`));
+            if (theme.accessibility.hoverEnabled) {
+                style.appendChild(document.createTextNode(`.${prefix}access:hover{outline: ${outlineColor} ${theme.accessibility.highlightThickness} solid !important;outline-offset: ${theme.accessibility.highlightOffset};}`));
+            }
+        }
+        // Render the button color styles
+        if (theme.buttonColorPalette) {
+            for (const prop of Object.keys(theme.buttonColorPalette)) {
+                const value = theme.buttonColorPalette[prop];
+                const color = value.startsWith('#') ? value : '#' + value;
+                this.generateColors(style, color, prefix + this.toSnakeCase(prop));
+                rootVars += `--${prefix}${this.toKebabCase(prop)}: ${color};`;
+            }
+        }
+        if (theme.stylingVariables) {
+            if (theme.stylingVariables.inputTextSize) {
+                style.appendChild(document.createTextNode(`.${prefix}ptl_input_text_size{font-size: ${theme.stylingVariables.inputTextSize};}`));
+            }
+            if (theme.stylingVariables.inputLabelSize) {
+                style.appendChild(document.createTextNode(`.${prefix}ptl_input_label_size{font-size: ${theme.stylingVariables.inputLabelSize};}`));
+            }
+            if (theme.stylingVariables.inputBgColor) {
+                style.appendChild(document.createTextNode(`.${prefix}ptl_input_bg_color{background-color: ${this.addHashmark(theme.stylingVariables.inputBgColor)};color: ${this.getTextColor(theme.stylingVariables.inputBgColor)}}`));
+            }
+            if (theme.stylingVariables.borderColor) {
+                style.appendChild(document.createTextNode(`.${prefix}ptl_brdr_color{border-color: ${this.addHashmark(theme.stylingVariables.borderColor)};}`));
+            }
+            if (theme.stylingVariables.borderSize) {
+                style.appendChild(document.createTextNode(`.${prefix}ptl_brdr_size{border-width: ${theme.stylingVariables.borderSize};border-style:solid;}`));
+            }
+            if (theme.stylingVariables.borderRadius) {
+                style.appendChild(document.createTextNode(`.${prefix}ptl_brdr_radius{border-radius: ${theme.stylingVariables.borderRadius};}`));
+            }
+            if (theme.stylingVariables.inputHeight) {
+                style.appendChild(document.createTextNode(`.${prefix}ptl_input_height{height: ${theme.stylingVariables.inputHeight};}`));
+            }
+            if (theme.stylingVariables.inputPadding) {
+                style.appendChild(document.createTextNode(`.${prefix}ptl_input_padding{padding: ${theme.stylingVariables.inputPadding};}`));
+            }
+            if (theme.stylingVariables.tooltipTextSize || theme.stylingVariables.tooltipBackgroundColor) {
+                const bgColor = theme.stylingVariables.tooltipBackgroundColor;
+                const textSize = theme.stylingVariables.tooltipTextSize;
+                const borderSize = theme.stylingVariables.tooltipBorderSize;
+                const borderColor = theme.stylingVariables.tooltipBorderColor;
+                const caretSize = theme.stylingVariables.tooltipCaretSize ?? '6px';
+                let tooltipStyle = '.particle_tooltip{';
+                if (bgColor) {
+                    const textColor = this.getTextColor(bgColor);
+                    tooltipStyle += `color: ${textColor};`;
+                    tooltipStyle += `background-color: ${bgColor};`;
+                }
+                if (borderColor && borderSize) {
+                    tooltipStyle += `border: ${borderSize} solid ${borderColor};`;
+                }
+                if (textSize) {
+                    tooltipStyle += 'font-size: ' + textSize + ';';
+                }
+                tooltipStyle += '}';
+                style.appendChild(document.createTextNode(tooltipStyle));
+                let caretStyleColor = null;
+                if (borderColor && borderSize) {
+                    caretStyleColor = borderColor;
+                }
+                else if (bgColor) {
+                    caretStyleColor = bgColor;
+                }
+                if (caretStyleColor) {
+                    style.appendChild(document.createTextNode(`.particle_tooltip.right::after{border-color: transparent ${caretStyleColor} transparent transparent;margin-top: -${caretSize};border-width: ${caretSize};}`));
+                    style.appendChild(document.createTextNode(`.particle_tooltip.left::after{border-color: transparent transparent transparent ${caretStyleColor};margin-top: -${caretSize};border-width: ${caretSize};}`));
+                    style.appendChild(document.createTextNode(`.particle_tooltip.top::after{border-color: ${caretStyleColor} transparent transparent transparent;margin-left: -${caretSize};border-width: ${caretSize};}`));
+                    style.appendChild(document.createTextNode(`.particle_tooltip.bottom::after{border-color: transparent transparent ${caretStyleColor} transparent;margin-left: -${caretSize};border-width: ${caretSize};}`));
+                }
+            }
+        }
+        const head = document.head || document.getElementsByTagName('head')[0];
+        this.removeThemeFromHeader(prefix);
+        // Write the fonts to the header
+        if (prefix === '') {
+            this.addFonts(theme, head, style);
+            rootVars = this.createZIndexes(rootVars, theme.zIndexList);
+        }
+        rootVars += '}';
+        style.appendChild(document.createTextNode(rootVars));
+        style.setAttribute('id', (prefix ? prefix + '-' : '') + 'particle-theme');
+        head.appendChild(style);
+        this.themeChangeDetectionService.changeTheme();
+    }
+    addHashmark(color) {
+        return color.startsWith('#') ? color : '#' + color;
+    }
+    addFonts(theme, head, style) {
+        if (!theme.fonts) {
+            return;
+        }
+        let defaultFont = null;
+        for (const font of theme.fonts) {
+            if (font.isDefault || theme.fonts.length === 1) {
+                defaultFont = font;
+            }
+            if (!this.fontExists(head, font)) {
+                let element = document.createElement('link');
+                if (font.source === 'adobe') {
+                    element.setAttribute('href', `https://use.typekit.net/${font.id}.css`);
+                }
+                else {
+                    element.setAttribute('href', `https://fonts.googleapis.com/css?family=${font.name.replace(' ', '+')}&display=swap`);
+                }
+                element.setAttribute('rel', 'stylesheet');
+                head.appendChild(element);
+            }
+        }
+        style.appendChild(document.createTextNode(`html * { font-family: ${defaultFont.name}, ${defaultFont.isSerif ? 'serif' : 'sans-serif'}; }`));
+    }
+    fontExists(head, font) {
+        for (const child of head.childNodes) {
+            if (child.href && font.source === 'adobe' && child.href.indexOf(font.id) > -1) {
+                return true;
+            }
+            else if (child.href && child.href.indexOf(font.name.replace(' ', '+')) > -1) {
+                return true;
+            }
+        }
+        return false;
+    }
+    removeThemeFromHeader(prefix) {
+        const head = document.head || document.getElementsByTagName('head')[0];
+        for (const child of head.childNodes) {
+            if (child.id === (prefix ? prefix + '-' : '') + 'particle-theme') {
+                head.removeChild(child);
+                break;
+            }
+        }
+    }
+    /**
+     * Determines the contrast between a given color and its auto-selected text color
+     *
+     * @param color
+     */
+    getContrast(color) {
+        const colorRgb = this.hexToRgb(color);
+        const textColorRgb = this.hexToRgb(this.getTextColor(color));
+        return this.contrast(colorRgb, textColorRgb);
+    }
+    /**
+     * Calculates luminance
+     *
+     * @param r
+     * @param g
+     * @param b
+     */
+    luminance(r, g, b) {
+        const a = [r, g, b].map(function (v) {
+            v /= 255;
+            return v <= 0.03928
+                ? v / 12.92
+                : Math.pow((v + 0.055) / 1.055, 2.4);
+        });
+        return a[0] * 0.2126 + a[1] * 0.7152 + a[2] * 0.0722;
+    }
+    isDarkTheme(color) {
+        const rgb = this.hexToRgb(color);
+        return (this.luminance(rgb.r, rgb.g, rgb.b) * 100) < 50;
+    }
+    /**
+     * Calculates the contrast
+     *
+     * @param rgb1
+     * @param rgb2
+     */
+    contrast(rgb1, rgb2) {
+        let contrast = (this.luminance(rgb1.r, rgb1.g, rgb1.b) + 0.05)
+            / (this.luminance(rgb2.r, rgb2.g, rgb2.b) + 0.05);
+        if (contrast < 1) {
+            contrast = (this.luminance(rgb2.r, rgb2.g, rgb2.b) + 0.05)
+                / (this.luminance(rgb1.r, rgb1.g, rgb1.b) + 0.05);
+        }
+        return contrast;
+    }
+    /**
+     * Returns the maximally contrasting text color for the supplied background color
+     *
+     * @param color
+     */
+    getTextColor(color) {
+        const rgb = this.hexToRgb(color);
+        let textRgb = this.hexToRgb('#FFFFFF');
+        const whiteContrast = this.contrast(textRgb, rgb);
+        textRgb = this.hexToRgb('#222222');
+        const blackContrast = this.contrast(textRgb, rgb);
+        // 7 is the contrast ratio for WCAG AAA, if we're less than that, go full black for max contrast
+        if (blackContrast > whiteContrast && blackContrast < 7) {
+            return '#000000';
+        }
+        return whiteContrast > blackContrast ? '#FFFFFF' : '#222222';
+    }
+    /**
+     * Generates the CSS for each of the colors in the theme. Will write the base color and 9 light and dark variants of the given color.
+     *
+     * @param style
+     * @param color
+     * @param className
+     */
+    generateColors(style, color, className) {
+        if (!color) {
+            return;
+        }
+        let textColor = this.getTextColor(color);
+        style.appendChild(document.createTextNode(`.${className}{background-color: ${color};color: ${textColor};fill: currentColor;}`));
+        for (let i = 1; i < 10; i++) {
+            const newColor = this.lightenDarkenColor(color, i * 10);
+            textColor = this.getTextColor(newColor);
+            style.appendChild(document.createTextNode(`.${className}_light_${i}{background-color: ${newColor};color: ${textColor};fill: currentColor;}`));
+        }
+        for (let i = 1; i < 10; i++) {
+            const newColor = this.lightenDarkenColor(color, 0 - (i * 10));
+            textColor = this.getTextColor(newColor);
+            style.appendChild(document.createTextNode(`.${className}_dark_${i}{background-color: ${newColor};color: ${textColor};fill: currentColor;}`));
+        }
+    }
+    getDefaultZIndexes() {
+        return this.defaultZIndexes;
+    }
+    createZIndexes(rootVars, zIndexes) {
+        let zIndexesToCreate = this.defaultZIndexes;
+        if (zIndexes) {
+            if (zIndexes.includes(Z_INDEX_LAYERS.BASE)
+                && zIndexes.includes(Z_INDEX_LAYERS.FRAME)
+                && zIndexes.includes(Z_INDEX_LAYERS.OVERLAY)
+                && zIndexes.includes(Z_INDEX_LAYERS.DIALOG)
+                && zIndexes.includes(Z_INDEX_LAYERS.NOTIFICATION)) {
+                zIndexesToCreate = zIndexes;
+            }
+            else {
+                console.warn('THEMING: Z Index List missing required layers, ignoring provided list.');
+            }
+        }
+        let i = 0;
+        for (const zIndex of zIndexesToCreate) {
+            rootVars += `--z-${zIndex}: ${i++};`;
+        }
+        return rootVars;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ThemingService, deps: [{ token: i1.LocalStorageService }, { token: i2.ThemeChangeDetectionService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ThemingService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ThemingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.LocalStorageService }, { type: i2.ThemeChangeDetectionService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"theming.service.js","sourceRoot":"","sources":["../../../../../../src/app/modules/theming/services/theming.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\r\nimport {BehaviorSubject, Observable} from 'rxjs';\r\nimport {Theme, ThemeFont, Z_INDEX_LAYERS} from '../models/theme.model';\r\nimport {ThemeChangeDetectionService} from './theme-change-detection.service';\r\nimport {LocalStorageService} from '../../../shared/services/local-storage.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ThemingService {\r\n\r\n  // PSA: ORDER MATTERS, DO NOT MOVE ITEMS AROUND\r\n  private readonly defaultZIndexes: Array<string> = [\r\n    Z_INDEX_LAYERS.BASE,\r\n    Z_INDEX_LAYERS.FRAME,\r\n    Z_INDEX_LAYERS.OVERLAY,\r\n    Z_INDEX_LAYERS.DIALOG,\r\n    Z_INDEX_LAYERS.NOTIFICATION\r\n  ];\r\n\r\n  /**\r\n   * Prefix used to build the key for local storage of the theme\r\n   */\r\n  private readonly THEME_KEY = 'theme';\r\n\r\n  /**\r\n   * A private BehaviorSubject to store the loaded themes\r\n   */\r\n  private themes = new BehaviorSubject<Theme[]>([]);\r\n\r\n  private $selectedTheme = new BehaviorSubject<Theme>(null as any);\r\n\r\n  get selectedTheme(): Observable<Theme> {\r\n    return this.$selectedTheme.asObservable();\r\n  }\r\n\r\n\r\n  /**\r\n   * Key for the product this is deployed into\r\n   */\r\n  protected applicationName: string = null as any;\r\n\r\n  /**\r\n   * Constructor\r\n   *\r\n   * @param localStorageService\r\n   * @param themeChangeDetectionService\r\n   */\r\n  constructor(\r\n    private localStorageService: LocalStorageService,\r\n    private themeChangeDetectionService: ThemeChangeDetectionService\r\n  ) {\r\n  }\r\n\r\n  /**\r\n   * Converts a JSON property name to snake case\r\n   *\r\n   * @param prop\r\n   */\r\n  private toSnakeCase(prop: string): string {\r\n    return prop.split(/(?=[A-Z])/).join('_').toLowerCase();\r\n  }\r\n\r\n  private toKebabCase(prop: string): string {\r\n    return prop.split(/(?=[A-Z])/).join('-').toLowerCase();\r\n  }\r\n\r\n  private convertUnderscoreToDash(prop: string): string {\r\n    return prop.split('_').join('-').toLowerCase();\r\n  }\r\n\r\n  /**\r\n   * For the given color, it'll lighten or darken the color by the percentage supplied. Positive percent will lighten, negative to darken.\r\n   *\r\n   * @param color\r\n   * @param percent\r\n   */\r\n  private lightenDarkenColor(color: string, percent: number): string {\r\n    let usePound = false;\r\n    if (color[0] === '#') {\r\n      color = color.slice(1);\r\n      usePound = true;\r\n    }\r\n\r\n    const num = parseInt(color, 16);\r\n\r\n    let r = (num >> 16) + percent;\r\n    if (r > 255) {\r\n      r = 255;\r\n    } else if (r < 0) {\r\n      r = 0;\r\n    }\r\n\r\n    let b = ((num >> 8) & 0x00FF) + percent;\r\n    if (b > 255) {\r\n      b = 255;\r\n    } else if (b < 0) {\r\n      b = 0;\r\n    }\r\n\r\n    let g = (num & 0x0000FF) + percent;\r\n    if (g > 255) {\r\n      g = 255;\r\n    } else if (g < 0) {\r\n      g = 0;\r\n    }\r\n\r\n    let newColor = (g | (b << 8) | (r << 16)).toString(16);\r\n\r\n    while (newColor.length < 6) {\r\n      newColor = '0' + newColor;\r\n    }\r\n\r\n    return (usePound ? '#' : '') + newColor;\r\n  }\r\n\r\n  /**\r\n   * Converts a hex value to a Javascript object with r,g, and b variables.\r\n   *\r\n   * @param hex\r\n   */\r\n  private hexToRgb(hex: string): any {\r\n    const result = /^#?([a-f\\d]{2})([a-f\\d]{2})([a-f\\d]{2})$/i.exec(hex);\r\n    return result ? {\r\n      r: parseInt(result[1], 16),\r\n      g: parseInt(result[2], 16),\r\n      b: parseInt(result[3], 16)\r\n    } : null;\r\n  }\r\n\r\n  /**\r\n   * Generates a random hex color\r\n   */\r\n  getRandomColor(): string {\r\n    return '#' + Math.floor(Math.random() * 16777215).toString(16);\r\n  }\r\n\r\n  /**\r\n   * On App Initialization (in app.component.ts, ngOnInit) call this to load themes and apply the user selected theme or default theme.\r\n   *\r\n   * @param applicationName\r\n   * @param themes\r\n   */\r\n  appInit(applicationName: string, themes: Theme[]): void {\r\n      if (!applicationName) {\r\n        throw new Error('Application Name was not supplied.');\r\n      }\r\n\r\n      this.applicationName = applicationName;\r\n      this.themes.next(themes);\r\n      this.applySettings();\r\n  }\r\n\r\n  /**\r\n   * Return the themes for the current app\r\n   */\r\n  getThemes(): Observable<Theme[]> {\r\n    return this.themes;\r\n  }\r\n\r\n  /**\r\n   * Apply the selected theme\r\n   */\r\n  applySettings(): void {\r\n    const settings = this.getTheme();\r\n    this.$selectedTheme.next(settings);\r\n    this.changeColors(settings);\r\n  }\r\n\r\n  /**\r\n   * Constructs a theme object based on another theme object\r\n   *\r\n   * @param theme\r\n   */\r\n  generateTheme(theme?: Theme): Theme {\r\n    let newTheme: Theme = {} as Theme;\r\n    if (theme) {\r\n      for (const prop of Object.keys(theme)) {\r\n        // @ts-ignore\r\n        newTheme[prop] = theme[prop];\r\n      }\r\n    } else {\r\n      newTheme = this.themes.getValue().find(theTheme => theTheme.isDefault) as Theme;\r\n    }\r\n\r\n    return newTheme;\r\n  }\r\n\r\n  /**\r\n   * Returns a list of the color classes specifically based on the properties of the theme model\r\n   */\r\n  getClassesFromTheme(theme: Theme): string[] {\r\n    const classes = [];\r\n    for (const prop of Object.keys(theme)) {\r\n      if (prop.toLowerCase().includes('bg') || prop.toLowerCase().includes('color')) {\r\n        classes.push(prop.split(/(?=[A-Z])/).join('_').toLowerCase());\r\n      }\r\n    }\r\n\r\n    return classes;\r\n  }\r\n\r\n  /**\r\n   * Returns the user selected theme from local storage\r\n   */\r\n  getTheme(): Theme {\r\n    const themeId = this.localStorageService.getObject(this.applicationName + this.THEME_KEY);\r\n    let defaultTheme = this.themes.value.filter(theme => theme.isDefault)[0];\r\n\r\n    for (const theme of this.themes.value) {\r\n      if (theme.themeId === themeId) {\r\n        return theme;\r\n      }\r\n    }\r\n\r\n    return defaultTheme;\r\n  }\r\n\r\n  /**\r\n   * Persists the user selected theme in local storage\r\n   *\r\n   * @param settings\r\n   */\r\n  saveTheme(settings: Theme): void {\r\n    this.$selectedTheme.next(settings);\r\n    this.localStorageService.putObject(this.applicationName + this.THEME_KEY, settings.themeId);\r\n  }\r\n\r\n  /**\r\n   * Writes the theme information to a style tag in the header so that the theme is applied.\r\n   *\r\n   * @param theme\r\n   * @param prefix\r\n   */\r\n  changeColors(theme: Theme, prefix?: string): void {\r\n    if (!prefix) {\r\n      prefix = '';\r\n    }\r\n\r\n    const style = document.createElement('style');\r\n    let rootVars = ':root {';\r\n\r\n    // Render the color palette styles\r\n    if (theme.colorPalette) {\r\n      for (const prop of Object.keys(theme.colorPalette)) {\r\n        if (prop !== 'extension') {\r\n          const value = (theme.colorPalette as any)[prop] as string;\r\n\r\n          const color = this.addHashmark(value);\r\n          this.generateColors(style, color, prefix + this.toSnakeCase(prop));\r\n\r\n          rootVars += `--${prefix}${this.toKebabCase(prop)}-color: ${color};`;\r\n        }\r\n      }\r\n\r\n      for (const extension of theme.colorPalette.extension) {\r\n        if (extension.textColor && !extension.color) {\r\n          style.appendChild(document.createTextNode(`.${prefix}${extension.className}{color: ${this.addHashmark(extension.textColor)};}`));\r\n        }\r\n\r\n        if (extension.color) {\r\n          if (!extension.textColor) {\r\n            this.generateColors(style, this.addHashmark(extension.color as string), prefix + extension.className);\r\n          } else {\r\n            style.appendChild(document.createTextNode(`.${prefix}${extension.className}{background-color: ${this.addHashmark(extension.color)};color: ${this.addHashmark(extension.textColor)};fill: currentColor;}`));\r\n          }\r\n\r\n          rootVars += `--${prefix}${this.convertUnderscoreToDash(extension.className)}: ${this.addHashmark(extension.color as string)};`;\r\n        }\r\n      }\r\n    }\r\n\r\n    // Render the layout color styles\r\n    if (theme.layoutColors) {\r\n      for (const prop of Object.keys(theme.layoutColors)) {\r\n        const value = (theme.layoutColors as any)[prop] as string;\r\n\r\n        const color = value.startsWith('#') ? value : '#' + value;\r\n        this.generateColors(style, color, prefix + this.toSnakeCase(prop));\r\n        rootVars += `--${prefix}${this.toKebabCase(prop)}: ${color};`;\r\n      }\r\n\r\n      if (this.isDarkTheme(theme.layoutColors.bodyColor)) {\r\n        style.appendChild(document.createTextNode(`.${prefix}bg_overlay{background-color:rgba(255,255,255,0.05);color:inherit;}`));\r\n        style.appendChild(document.createTextNode(`.${prefix}bg_overlay_rev{background-color:rgba(0,0,0,0.05);color:inherit;}`));\r\n        style.appendChild(document.createTextNode(`.${prefix}brdr{border:1px solid rgba(150,150,150,0.5);}`));\r\n      } else {\r\n        style.appendChild(document.createTextNode(`.${prefix}bg_overlay{background-color:rgba(255,255,255,0.1);color:inherit;}`));\r\n        style.appendChild(document.createTextNode(`.${prefix}bg_overlay_rev{background-color:rgba(0,0,0,0.04);color:inherit;}`));\r\n        style.appendChild(document.createTextNode(`.${prefix}brdr{border:1px solid rgba(150,150,150,0.5);}`));\r\n      }\r\n    }\r\n\r\n    if (theme.accessibility && theme.accessibility.enabled) {\r\n      const outlineColor = theme.accessibility.highlightColor.startsWith('#') ? theme.accessibility.highlightColor : '#' + theme.accessibility.highlightColor;\r\n      style.appendChild(document.createTextNode(`.${prefix}access{outline: ${outlineColor} ${theme.accessibility.highlightThickness} solid !important;outline-color: transparent !important;transition:all 0.3s ease-in-out;}`));\r\n      style.appendChild(document.createTextNode(`.${prefix}access:focus{outline: ${outlineColor} ${theme.accessibility.highlightThickness} solid !important;outline-offset: ${theme.accessibility.highlightOffset};}`));\r\n\r\n      if (theme.accessibility.hoverEnabled) {\r\n        style.appendChild(document.createTextNode(`.${prefix}access:hover{outline: ${outlineColor} ${theme.accessibility.highlightThickness} solid !important;outline-offset: ${theme.accessibility.highlightOffset};}`));\r\n      }\r\n    }\r\n\r\n    // Render the button color styles\r\n    if (theme.buttonColorPalette) {\r\n      for (const prop of Object.keys(theme.buttonColorPalette)) {\r\n        const value = (theme.buttonColorPalette as any)[prop] as string;\r\n\r\n        const color = value.startsWith('#') ? value : '#' + value;\r\n        this.generateColors(style, color, prefix + this.toSnakeCase(prop));\r\n\r\n        rootVars += `--${prefix}${this.toKebabCase(prop)}: ${color};`;\r\n      }\r\n    }\r\n\r\n    if (theme.stylingVariables) {\r\n      if (theme.stylingVariables.inputTextSize) {\r\n        style.appendChild(document.createTextNode(`.${prefix}ptl_input_text_size{font-size: ${theme.stylingVariables.inputTextSize};}`));\r\n      }\r\n\r\n      if (theme.stylingVariables.inputLabelSize) {\r\n        style.appendChild(document.createTextNode(`.${prefix}ptl_input_label_size{font-size: ${theme.stylingVariables.inputLabelSize};}`));\r\n      }\r\n\r\n      if (theme.stylingVariables.inputBgColor) {\r\n        style.appendChild(document.createTextNode(`.${prefix}ptl_input_bg_color{background-color: ${this.addHashmark(theme.stylingVariables.inputBgColor)};color: ${this.getTextColor(theme.stylingVariables.inputBgColor)}}`));\r\n      }\r\n\r\n      if (theme.stylingVariables.borderColor) {\r\n        style.appendChild(document.createTextNode(`.${prefix}ptl_brdr_color{border-color: ${this.addHashmark(theme.stylingVariables.borderColor)};}`));\r\n      }\r\n\r\n      if (theme.stylingVariables.borderSize) {\r\n        style.appendChild(document.createTextNode(`.${prefix}ptl_brdr_size{border-width: ${theme.stylingVariables.borderSize};border-style:solid;}`));\r\n      }\r\n\r\n      if (theme.stylingVariables.borderRadius) {\r\n        style.appendChild(document.createTextNode(`.${prefix}ptl_brdr_radius{border-radius: ${theme.stylingVariables.borderRadius};}`));\r\n      }\r\n\r\n      if (theme.stylingVariables.inputHeight) {\r\n        style.appendChild(document.createTextNode(`.${prefix}ptl_input_height{height: ${theme.stylingVariables.inputHeight};}`));\r\n      }\r\n\r\n      if (theme.stylingVariables.inputPadding) {\r\n        style.appendChild(document.createTextNode(`.${prefix}ptl_input_padding{padding: ${theme.stylingVariables.inputPadding};}`));\r\n      }\r\n\r\n      if (theme.stylingVariables.tooltipTextSize || theme.stylingVariables.tooltipBackgroundColor) {\r\n        const bgColor = theme.stylingVariables.tooltipBackgroundColor;\r\n        const textSize = theme.stylingVariables.tooltipTextSize;\r\n        const borderSize = theme.stylingVariables.tooltipBorderSize;\r\n        const borderColor = theme.stylingVariables.tooltipBorderColor;\r\n        const caretSize = theme.stylingVariables.tooltipCaretSize ?? '6px';\r\n\r\n        let tooltipStyle = '.particle_tooltip{';\r\n\r\n        if (bgColor) {\r\n          const textColor = this.getTextColor(bgColor);\r\n          tooltipStyle += `color: ${textColor};`;\r\n          tooltipStyle += `background-color: ${bgColor};`;\r\n        }\r\n\r\n        if (borderColor && borderSize) {\r\n          tooltipStyle += `border: ${borderSize} solid ${borderColor};`;\r\n        }\r\n\r\n        if (textSize) {\r\n          tooltipStyle += 'font-size: ' + textSize + ';';\r\n        }\r\n\r\n        tooltipStyle += '}';\r\n        style.appendChild(document.createTextNode(tooltipStyle));\r\n\r\n        let caretStyleColor: string = null as any;\r\n        if (borderColor && borderSize) {\r\n          caretStyleColor = borderColor;\r\n        } else if (bgColor) {\r\n          caretStyleColor = bgColor;\r\n        }\r\n\r\n        if (caretStyleColor) {\r\n          style.appendChild(document.createTextNode(`.particle_tooltip.right::after{border-color: transparent ${caretStyleColor} transparent transparent;margin-top: -${caretSize};border-width: ${caretSize};}`));\r\n          style.appendChild(document.createTextNode(`.particle_tooltip.left::after{border-color: transparent transparent transparent ${caretStyleColor};margin-top: -${caretSize};border-width: ${caretSize};}`));\r\n          style.appendChild(document.createTextNode(`.particle_tooltip.top::after{border-color: ${caretStyleColor} transparent transparent transparent;margin-left: -${caretSize};border-width: ${caretSize};}`));\r\n          style.appendChild(document.createTextNode(`.particle_tooltip.bottom::after{border-color: transparent transparent ${caretStyleColor} transparent;margin-left: -${caretSize};border-width: ${caretSize};}`));\r\n        }\r\n      }\r\n    }\r\n\r\n    const head = document.head || document.getElementsByTagName('head')[0];\r\n\r\n    this.removeThemeFromHeader(prefix);\r\n\r\n    // Write the fonts to the header\r\n    if (prefix === '') {\r\n      this.addFonts(theme, head, style);\r\n      rootVars = this.createZIndexes(rootVars, theme.zIndexList as Array<string>);\r\n    }\r\n\r\n    rootVars += '}';\r\n    style.appendChild(document.createTextNode(rootVars));\r\n    style.setAttribute('id', (prefix ? prefix + '-' : '') + 'particle-theme');\r\n    head.appendChild(style);\r\n\r\n    this.themeChangeDetectionService.changeTheme();\r\n  }\r\n\r\n  private addHashmark(color: string): string {\r\n    return color.startsWith('#') ? color : '#' + color;\r\n  }\r\n\r\n  private addFonts(theme: Theme, head: HTMLHeadElement, style: HTMLStyleElement): void {\r\n    if (!theme.fonts) {\r\n      return;\r\n    }\r\n\r\n    let defaultFont: ThemeFont = null as any;\r\n    for (const font of theme.fonts) {\r\n      if (font.isDefault || theme.fonts.length === 1) {\r\n        defaultFont = font;\r\n      }\r\n\r\n      if (!this.fontExists(head, font)) {\r\n        let element: HTMLLinkElement = document.createElement('link');\r\n        if (font.source === 'adobe') {\r\n          element.setAttribute('href', `https://use.typekit.net/${font.id}.css`);\r\n        } else {\r\n          element.setAttribute('href', `https://fonts.googleapis.com/css?family=${font.name.replace(' ', '+')}&display=swap`);\r\n        }\r\n        element.setAttribute('rel', 'stylesheet');\r\n        head.appendChild(element);\r\n      }\r\n    }\r\n\r\n    style.appendChild(document.createTextNode(`html * { font-family: ${defaultFont.name}, ${defaultFont.isSerif ? 'serif' : 'sans-serif'}; }`));\r\n  }\r\n\r\n  private fontExists(head: HTMLHeadElement, font: ThemeFont): boolean {\r\n    for (const child of <any>head.childNodes) {\r\n      if (child.href && font.source === 'adobe' && child.href.indexOf(font.id) > -1) {\r\n        return true;\r\n      } else if (child.href && child.href.indexOf(font.name.replace(' ', '+')) > -1) {\r\n        return true;\r\n      }\r\n    }\r\n\r\n    return false;\r\n  }\r\n\r\n  removeThemeFromHeader(prefix: string): void {\r\n    const head = document.head || document.getElementsByTagName('head')[0];\r\n\r\n    for (const child of <any>head.childNodes) {\r\n      if ((child as Element).id === (prefix ? prefix + '-' : '') + 'particle-theme') {\r\n        head.removeChild(child);\r\n        break;\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Determines the contrast between a given color and its auto-selected text color\r\n   *\r\n   * @param color\r\n   */\r\n  getContrast(color: string): number {\r\n    const colorRgb = this.hexToRgb(color);\r\n    const textColorRgb = this.hexToRgb(this.getTextColor(color));\r\n    return this.contrast(colorRgb, textColorRgb);\r\n  }\r\n\r\n  /**\r\n   * Calculates luminance\r\n   *\r\n   * @param r\r\n   * @param g\r\n   * @param b\r\n   */\r\n  private luminance(r: number, g: number, b: number): number {\r\n    const a = [r, g, b].map(function (v) {\r\n      v /= 255;\r\n      return v <= 0.03928\r\n        ? v / 12.92\r\n        : Math.pow((v + 0.055) / 1.055, 2.4);\r\n    });\r\n    return a[0] * 0.2126 + a[1] * 0.7152 + a[2] * 0.0722;\r\n  }\r\n\r\n  private isDarkTheme(color: string): boolean {\r\n    const rgb = this.hexToRgb(color);\r\n    return (this.luminance(rgb.r, rgb.g, rgb.b) * 100) < 50;\r\n  }\r\n\r\n  /**\r\n   * Calculates the contrast\r\n   *\r\n   * @param rgb1\r\n   * @param rgb2\r\n   */\r\n  private contrast(rgb1: any, rgb2: any): number {\r\n    let contrast = (this.luminance(rgb1.r, rgb1.g, rgb1.b) + 0.05)\r\n      / (this.luminance(rgb2.r, rgb2.g, rgb2.b) + 0.05);\r\n\r\n    if (contrast < 1) {\r\n      contrast = (this.luminance(rgb2.r, rgb2.g, rgb2.b) + 0.05)\r\n        / (this.luminance(rgb1.r, rgb1.g, rgb1.b) + 0.05);\r\n    }\r\n\r\n    return contrast;\r\n  }\r\n\r\n  /**\r\n   * Returns the maximally contrasting text color for the supplied background color\r\n   *\r\n   * @param color\r\n   */\r\n  getTextColor(color: string): string {\r\n    const rgb = this.hexToRgb(color);\r\n    let textRgb = this.hexToRgb('#FFFFFF');\r\n    const whiteContrast = this.contrast(textRgb, rgb);\r\n\r\n    textRgb = this.hexToRgb('#222222');\r\n    const blackContrast = this.contrast(textRgb, rgb);\r\n\r\n    // 7 is the contrast ratio for WCAG AAA, if we're less than that, go full black for max contrast\r\n    if (blackContrast > whiteContrast && blackContrast < 7) {\r\n      return '#000000';\r\n    }\r\n\r\n    return whiteContrast > blackContrast ? '#FFFFFF' : '#222222';\r\n  }\r\n\r\n  /**\r\n   * Generates the CSS for each of the colors in the theme. Will write the base color and 9 light and dark variants of the given color.\r\n   *\r\n   * @param style\r\n   * @param color\r\n   * @param className\r\n   */\r\n  private generateColors(style: HTMLStyleElement, color: string, className: string): void {\r\n    if (!color) {\r\n      return;\r\n    }\r\n\r\n    let textColor = this.getTextColor(color);\r\n    style.appendChild(document.createTextNode(`.${className}{background-color: ${color};color: ${textColor};fill: currentColor;}`));\r\n    for (let i = 1; i < 10; i++) {\r\n      const newColor = this.lightenDarkenColor(color, i * 10);\r\n      textColor = this.getTextColor(newColor);\r\n\r\n      style.appendChild(\r\n        document.createTextNode(`.${className}_light_${i}{background-color: ${newColor};color: ${textColor};fill: currentColor;}`));\r\n    }\r\n\r\n    for (let i = 1; i < 10; i++) {\r\n      const newColor = this.lightenDarkenColor(color, 0 - (i * 10));\r\n      textColor = this.getTextColor(newColor);\r\n\r\n      style.appendChild(\r\n        document.createTextNode(`.${className}_dark_${i}{background-color: ${newColor};color: ${textColor};fill: currentColor;}`));\r\n    }\r\n  }\r\n\r\n  getDefaultZIndexes(): Array<string> {\r\n    return this.defaultZIndexes;\r\n  }\r\n\r\n  private createZIndexes(rootVars: string, zIndexes: Array<string>): string {\r\n    let zIndexesToCreate = this.defaultZIndexes;\r\n\r\n    if (zIndexes) {\r\n      if (zIndexes.includes(Z_INDEX_LAYERS.BASE)\r\n        && zIndexes.includes(Z_INDEX_LAYERS.FRAME)\r\n        && zIndexes.includes(Z_INDEX_LAYERS.OVERLAY)\r\n        && zIndexes.includes(Z_INDEX_LAYERS.DIALOG)\r\n        && zIndexes.includes(Z_INDEX_LAYERS.NOTIFICATION)\r\n      ) {\r\n        zIndexesToCreate = zIndexes;\r\n      } else {\r\n        console.warn('THEMING: Z Index List missing required layers, ignoring provided list.');\r\n      }\r\n    }\r\n\r\n    let i = 0;\r\n    for (const zIndex of zIndexesToCreate) {\r\n      rootVars += `--z-${zIndex}: ${i++};`;\r\n    }\r\n\r\n    return rootVars;\r\n  }\r\n\r\n}\r\n"]}