@po-ui/ng-components 17.7.0 → 17.9.0

package/esm2022/lib/services/po-theme/po-theme.service.mjs

@@ -0,0 +1,260 @@
+import { DOCUMENT } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import { PoThemeTypeEnum } from './enum/po-theme-type.enum';
+import { poThemeDefault } from './helpers/po-theme-poui.constant';
+import * as i0 from "@angular/core";
+/**
+ * @description
+ *
+ * O `PoThemeService` possibilita a personalização das cores do tema padrão do `PO-UI`, permitindo a alteração dos valores das variáveis de estilo usadas no CSS padrão.
+ *
+ * > Para saber mais sobre como customizar as cores do tema padrão verifique o item [Customizando cores do tema padrão](https://po-ui.io/guides/colors-customization) na aba `Guias`.
+ *
+ * > Obs.: Não está documentado aqui e não indicamos a customização das cores de 'feedback' por motivos de acessibilidade e usabilidade.
+ */
+export class PoThemeService {
+    window;
+    document;
+    renderer;
+    theme = poThemeDefault;
+    constructor(window, document, rendererFactory) {
+        this.window = window;
+        this.document = document;
+        this.renderer = rendererFactory.createRenderer(null, null);
+    }
+    /**
+     * Define o tema a ser aplicado no componente, de acordo com o tipo de tema especificado.
+     *
+     * Este método define o tema a ser aplicado no componente com base no objeto `theme` fornecido e no tipo de tema especificado.
+     * Ele atualiza as propriedades do componente para refletir o tema selecionado, como cores, estilos e comportamentos.
+     *
+     * @param {PoTheme} theme - Objeto contendo as definições de tema a serem aplicadas no componente.
+     * @param {PoThemeTypeEnum} [themeType=PoThemeTypeEnum.light] - (Opcional) Tipo de tema a ser aplicado, podendo ser 'light' (claro) ou 'dark' (escuro). Por padrão, o tema claro é aplicado.
+     */
+    setTheme(theme, themeType = PoThemeTypeEnum.light) {
+        // Change theme name, remove special characteres and number, replace space with dash
+        theme.name = theme.name
+            .toLowerCase()
+            .replace(/[^a-zA-Z ]/g, '')
+            .replace(/\s+/g, '-');
+        theme.active = themeType;
+        const _themeType = theme.type[PoThemeTypeEnum[themeType]];
+        if (!_themeType) {
+            return;
+        }
+        const colorStyles = _themeType.color ? this.generateThemeStyles(_themeType.color) : '';
+        const perComponentStyles = _themeType.perComponent ? this.generatePerComponentStyles(_themeType.perComponent) : '';
+        const onRootStyles = _themeType.onRoot ? this.generateAdditionalStyles(_themeType.onRoot) : '';
+        const additionalStyles = this.generateAdditionalStyles(_themeType);
+        const combinedStyles = `
+      .${theme.name}-${PoThemeTypeEnum[themeType]}:root { 
+        ${colorStyles} 
+        ${perComponentStyles}
+        ${onRootStyles}
+        ${additionalStyles} 
+      }`;
+        this.applyThemeStyles(combinedStyles);
+        this.changeThemeType(theme);
+    }
+    /**
+     * @docsPrivate
+     *
+     * Gera estilos adicionais com base nos tokens de tema fornecidos, excluindo os tokens de cor.
+     * @param theme Os tokens de tema contendo os estilos adicionais a serem gerados.
+     * @returns Uma string contendo os estilos adicionais formatados.
+     */
+    generateAdditionalStyles(theme) {
+        return Object.entries(theme)
+            .filter(([key]) => !['color', 'perComponent', 'onRoot'].includes(key))
+            .map(([key, value]) => `${key}: ${value};`)
+            .join(' ');
+    }
+    /**
+     * @docsPrivate
+     *
+     * Aplica os estilos de tema ao documento.
+     * @param styleCss Os estilos CSS a serem aplicados.
+     */
+    applyThemeStyles(styleCss) {
+        const styleElement = this.createStyleElement(styleCss);
+        const existingStyleElement = document.head.querySelector('#pouiTheme');
+        if (existingStyleElement) {
+            this.renderer.removeChild(document.head, existingStyleElement);
+        }
+        this.renderer.appendChild(document.head, styleElement);
+    }
+    changeThemeType(theme) {
+        this.cleanThemeActive();
+        this.setThemeActive(theme);
+        document.getElementsByTagName('html')[0].classList.add(...[`${theme.name}-${PoThemeTypeEnum[theme.active]}`]);
+    }
+    /**
+     * Persiste e define o tema do aplicativo com base nos dados armazenados.
+     *
+     * Este método recupera os dados do tema armazenados e os aplica ao aplicativo.
+     *
+     * @returns {PoTheme} Recupera o tema armazenado.
+     */
+    persistThemeActive() {
+        const _theme = this.getThemeActive();
+        this.setTheme(_theme, _theme.active);
+        return _theme;
+    }
+    /**
+     * Altera o tipo do tema armazenado e aplica os novos estilos ao documento.
+     *
+     * Este método altera o tipo do tema armazenado ativo (light/dark)
+     *
+     * @param {PoThemeTypeEnum} themeType O tipo de tema a ser aplicado, light ou dark.
+     */
+    changeCurrentThemeType(type) {
+        const _theme = this.getThemeActive();
+        _theme.active = type;
+        this.changeThemeType(_theme);
+    }
+    /**
+     * Método remove o tema armazenado e limpa todos os estilos de tema
+     * aplicados ao documento.
+     */
+    cleanThemeActive() {
+        const _theme = this.getThemeActive();
+        document.getElementsByTagName('html')[0].classList.remove(`${_theme.name}-${PoThemeTypeEnum[_theme.active]}`);
+        localStorage.removeItem('totvs-theme');
+    }
+    /**
+     * @docsPrivate
+     *
+     * Este método define um dados do tema e o armazena.
+     * @param theme Os tokens de tema contendo os estilos adicionais a serem gerados.
+     */
+    setThemeActive(theme) {
+        if (theme) {
+            localStorage.setItem('totvs-theme', JSON.stringify(theme));
+            this.theme = theme;
+        }
+    }
+    /**
+     * Retorna o tema ativo como um observable.
+     * @returns {PoTheme} Tema ativo.
+     */
+    getThemeActive() {
+        try {
+            const themeData = JSON.parse(localStorage.getItem('totvs-theme'));
+            if (themeData && JSON.stringify(themeData) !== JSON.stringify(this.theme)) {
+                this.theme = themeData;
+            }
+        }
+        catch (error) {
+            console.error('Erro ao obter o tema do armazenamento local:', error);
+        }
+        return this.theme;
+    }
+    /**
+     * @docsPrivate
+     *
+     * Gera estilos CSS com base nos tokens de cores fornecidos.
+     * @param themeColor Os tokens de cor a serem usados para gerar os estilos.
+     * @returns Uma string contendo os estilos CSS gerados.
+     */
+    createStyleElement(css) {
+        const styleElement = this.renderer.createElement('style');
+        styleElement.id = 'pouiTheme';
+        this.renderer.appendChild(styleElement, this.renderer.createText(css));
+        return styleElement;
+    }
+    /**
+     * @docsPrivate
+     *
+     * Gera estilos CSS com base nos tokens de cores fornecidos.
+     * @param themeColor Os tokens de cor a serem usados para gerar os estilos.
+     * @returns Uma string contendo os estilos CSS gerados.
+     */
+    generateThemeStyles(themeColor) {
+        const selectBgIconStyle = this.getSelectBgIconsStyle(themeColor);
+        return [
+            Object.entries(themeColor)
+                .flatMap(([type, values]) => Object.entries(values).flatMap(([tonality, tonalityValues]) => {
+                if (type === 'action') {
+                    return [`--color-${type}-${tonality}: ${tonalityValues};`];
+                }
+                else {
+                    return Object.entries(tonalityValues).map(([level, colorValue]) => `--color-${type}-${tonality}-${level}: ${colorValue};`);
+                }
+            }))
+                .join(''),
+            selectBgIconStyle
+        ].join('');
+    }
+    /**
+     * @docsPrivate
+     *
+     * Gera estilos CSS com base nos tokens per Component fornecidos.
+     * @param themePerComponent Os tokens de cor a serem usados para gerar os estilos.
+     * @returns Uma string contendo os estilos CSS gerados.
+     */
+    generatePerComponentStyles(themePerComponent) {
+        return Object.entries(themePerComponent)
+            .flatMap(([type, values]) => Object.entries(values).flatMap(([level, colorValue]) => [`${type} {${level}: ${colorValue};};`]))
+            .join('');
+    }
+    /**
+     * Define o tema atual como o tema "PoUI Padrão".
+     *
+     * @param {PoThemeTypeEnum} type O tipo de Tema a ser aplicado, light / dark.
+     */
+    setDefaultTheme(type) {
+        this.setTheme(poThemeDefault, type);
+    }
+    /**
+     * @docsPrivate
+     *
+     * Retorna o estilo CSS para o fundo dos ícones do componente po-select, com base nas cores do tema.
+     *
+     * @param {PoThemeColor} themeColor - Objeto contendo as cores do tema.
+     * @returns {string} - Estilo CSS para o fundo dos ícones do po-select.
+     */
+    getSelectBgIconsStyle(themeColor) {
+        let selectBgIcon = '';
+        if (themeColor?.brand?.['01']?.dark) {
+            selectBgIcon += `po-select { --background-image: url("${this.getSelectBgIcon(themeColor.brand['01'].dark)}"); };`;
+        }
+        if (themeColor?.feedback?.negative?.base)
+            selectBgIcon += `po-select.ng-dirty.ng-invalid select { --background-image: url("${this.getSelectBgIcon(themeColor.feedback.negative.base)}"); };`;
+        if (themeColor?.neutral?.light?.['30'])
+            selectBgIcon += `select:disabled { --background-image: url("${this.getSelectBgIcon(themeColor.neutral.light['30'])}"); };`;
+        return selectBgIcon;
+    }
+    /**
+     * @docsPrivate
+     *
+     * Retorna a imagem SVG utilizada como fundo do po-select.
+     *
+     * @param {string} color Cor da Imagem - Utilizada no atributo 'fill'.
+     * @returns {string} Imagem SVG utilizada no po-select.
+     */
+    getSelectBgIcon(color) {
+        let svg = `"data:image/svg+xml,%3Csvg width='24' height='24' viewBox='0 0 24 24' fill='none' `;
+        svg = svg.concat(`xmlns='http://www.w3.org/2000/svg'%3E%3Cpath fill-rule='evenodd' clip-rule='evenodd' `);
+        svg = svg.concat(`d='M18.707 8.29301C18.316 7.90201 17.684 7.90201 17.293 8.29301L12 13.586L6.70701 `);
+        svg = svg.concat(`8.29301C6.31601 7.90201 5.68401 7.90201 5.29301 8.29301C4.90201 8.68401 4.90201 `);
+        svg = svg.concat(`9.31601 5.29301 9.70701L11.293 15.707C11.488 15.902 11.744 16 12 16C12.256 16 12.512 `);
+        svg = svg.concat(`15.902 12.707 15.707L18.707 9.70701C19.098 9.31601 19.098 8.68401 18.707 8.29301Z' `);
+        svg = svg.concat(`fill='%23${color}'/%3E%3C/svg%3E%0A");`);
+        return svg;
+    }
+    static ɵfac = function PoThemeService_Factory(t) { return new (t || PoThemeService)(i0.ɵɵinject('Window'), i0.ɵɵinject(DOCUMENT), i0.ɵɵinject(i0.RendererFactory2)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PoThemeService, factory: PoThemeService.ɵfac, providedIn: 'root' });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoThemeService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: Window, decorators: [{
+                type: Inject,
+                args: ['Window']
+            }] }, { type: Document, decorators: [{
+                type: Inject,
+                args: [DOCUMENT]
+            }] }, { type: i0.RendererFactory2 }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-theme.service.js","sourceRoot":"","sources":["../../../../../../projects/ui/src/lib/services/po-theme/po-theme.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport { Inject, Injectable, Renderer2, RendererFactory2 } from '@angular/core';\nimport { BehaviorSubject, Observable } from 'rxjs';\nimport { PoThemeTypeEnum } from './enum/po-theme-type.enum';\nimport { poThemeDefault } from './helpers/po-theme-poui.constant';\nimport { PoThemeColor } from './interfaces/po-theme-color.interface';\nimport { PoThemeTokens } from './interfaces/po-theme-tokens.interface';\nimport { PoTheme } from './interfaces/po-theme.interface';\n\n/**\n * @description\n *\n * O `PoThemeService` possibilita a personalização das cores do tema padrão do `PO-UI`, permitindo a alteração dos valores das variáveis de estilo usadas no CSS padrão.\n *\n * > Para saber mais sobre como customizar as cores do tema padrão verifique o item [Customizando cores do tema padrão](https://po-ui.io/guides/colors-customization) na aba `Guias`.\n *\n * > Obs.: Não está documentado aqui e não indicamos a customização das cores de 'feedback' por motivos de acessibilidade e usabilidade.\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class PoThemeService {\n  private renderer: Renderer2;\n  private theme: PoTheme = poThemeDefault;\n\n  constructor(\n    @Inject('Window') private window: Window,\n    @Inject(DOCUMENT) private document: Document,\n    rendererFactory: RendererFactory2\n  ) {\n    this.renderer = rendererFactory.createRenderer(null, null);\n  }\n\n  /**\n   * Define o tema a ser aplicado no componente, de acordo com o tipo de tema especificado.\n   *\n   * Este método define o tema a ser aplicado no componente com base no objeto `theme` fornecido e no tipo de tema especificado.\n   * Ele atualiza as propriedades do componente para refletir o tema selecionado, como cores, estilos e comportamentos.\n   *\n   * @param {PoTheme} theme - Objeto contendo as definições de tema a serem aplicadas no componente.\n   * @param {PoThemeTypeEnum} [themeType=PoThemeTypeEnum.light] - (Opcional) Tipo de tema a ser aplicado, podendo ser 'light' (claro) ou 'dark' (escuro). Por padrão, o tema claro é aplicado.\n   */\n  setTheme(theme: PoTheme, themeType: PoThemeTypeEnum = PoThemeTypeEnum.light): void {\n    // Change theme name, remove special characteres and number, replace space with dash\n    theme.name = theme.name\n      .toLowerCase()\n      .replace(/[^a-zA-Z ]/g, '')\n      .replace(/\\s+/g, '-');\n    theme.active = themeType;\n\n    const _themeType = theme.type[PoThemeTypeEnum[themeType]];\n    if (!_themeType) {\n      return;\n    }\n\n    const colorStyles = _themeType.color ? this.generateThemeStyles(_themeType.color) : '';\n    const perComponentStyles = _themeType.perComponent ? this.generatePerComponentStyles(_themeType.perComponent) : '';\n    const onRootStyles = _themeType.onRoot ? this.generateAdditionalStyles(_themeType.onRoot) : '';\n    const additionalStyles = this.generateAdditionalStyles(_themeType);\n\n    const combinedStyles = `\n      .${theme.name}-${PoThemeTypeEnum[themeType]}:root { \n        ${colorStyles} \n        ${perComponentStyles}\n        ${onRootStyles}\n        ${additionalStyles} \n      }`;\n\n    this.applyThemeStyles(combinedStyles);\n    this.changeThemeType(theme);\n  }\n\n  /**\n   * @docsPrivate\n   *\n   * Gera estilos adicionais com base nos tokens de tema fornecidos, excluindo os tokens de cor.\n   * @param theme Os tokens de tema contendo os estilos adicionais a serem gerados.\n   * @returns Uma string contendo os estilos adicionais formatados.\n   */\n  private generateAdditionalStyles(theme: PoThemeTokens): string {\n    return Object.entries(theme)\n      .filter(([key]) => !['color', 'perComponent', 'onRoot'].includes(key))\n      .map(([key, value]) => `${key}: ${value};`)\n      .join(' ');\n  }\n\n  /**\n   * @docsPrivate\n   *\n   * Aplica os estilos de tema ao documento.\n   * @param styleCss Os estilos CSS a serem aplicados.\n   */\n  private applyThemeStyles(styleCss: string): void {\n    const styleElement = this.createStyleElement(styleCss);\n    const existingStyleElement = document.head.querySelector('#pouiTheme');\n\n    if (existingStyleElement) {\n      this.renderer.removeChild(document.head, existingStyleElement);\n    }\n\n    this.renderer.appendChild(document.head, styleElement);\n  }\n\n  private changeThemeType(theme: PoTheme) {\n    this.cleanThemeActive();\n    this.setThemeActive(theme);\n    document.getElementsByTagName('html')[0].classList.add(...[`${theme.name}-${PoThemeTypeEnum[theme.active]}`]);\n  }\n\n  /**\n   * Persiste e define o tema do aplicativo com base nos dados armazenados.\n   *\n   * Este método recupera os dados do tema armazenados e os aplica ao aplicativo.\n   *\n   * @returns {PoTheme} Recupera o tema armazenado.\n   */\n  persistThemeActive() {\n    const _theme = this.getThemeActive();\n    this.setTheme(_theme, _theme.active);\n    return _theme;\n  }\n\n  /**\n   * Altera o tipo do tema armazenado e aplica os novos estilos ao documento.\n   *\n   * Este método altera o tipo do tema armazenado ativo (light/dark)\n   *\n   * @param {PoThemeTypeEnum} themeType O tipo de tema a ser aplicado, light ou dark.\n   */\n  changeCurrentThemeType(type: PoThemeTypeEnum): void {\n    const _theme = this.getThemeActive();\n    _theme.active = type;\n    this.changeThemeType(_theme);\n  }\n\n  /**\n   * Método remove o tema armazenado e limpa todos os estilos de tema\n   * aplicados ao documento.\n   */\n  cleanThemeActive(): void {\n    const _theme = this.getThemeActive();\n    document.getElementsByTagName('html')[0].classList.remove(`${_theme.name}-${PoThemeTypeEnum[_theme.active]}`);\n    localStorage.removeItem('totvs-theme');\n  }\n\n  /**\n   * @docsPrivate\n   *\n   * Este método define um dados do tema e o armazena.\n   * @param theme Os tokens de tema contendo os estilos adicionais a serem gerados.\n   */\n  private setThemeActive(theme: PoTheme): void {\n    if (theme) {\n      localStorage.setItem('totvs-theme', JSON.stringify(theme));\n      this.theme = theme;\n    }\n  }\n\n  /**\n   * Retorna o tema ativo como um observable.\n   * @returns {PoTheme} Tema ativo.\n   */\n  getThemeActive(): PoTheme {\n    try {\n      const themeData = JSON.parse(localStorage.getItem('totvs-theme'));\n      if (themeData && JSON.stringify(themeData) !== JSON.stringify(this.theme)) {\n        this.theme = themeData;\n      }\n    } catch (error) {\n      console.error('Erro ao obter o tema do armazenamento local:', error);\n    }\n    return this.theme;\n  }\n\n  /**\n   * @docsPrivate\n   *\n   * Gera estilos CSS com base nos tokens de cores fornecidos.\n   * @param themeColor Os tokens de cor a serem usados para gerar os estilos.\n   * @returns Uma string contendo os estilos CSS gerados.\n   */\n  private createStyleElement(css: string): HTMLStyleElement {\n    const styleElement = this.renderer.createElement('style');\n    styleElement.id = 'pouiTheme';\n    this.renderer.appendChild(styleElement, this.renderer.createText(css));\n    return styleElement;\n  }\n\n  /**\n   * @docsPrivate\n   *\n   * Gera estilos CSS com base nos tokens de cores fornecidos.\n   * @param themeColor Os tokens de cor a serem usados para gerar os estilos.\n   * @returns Uma string contendo os estilos CSS gerados.\n   */\n  private generateThemeStyles(themeColor: PoThemeColor): string {\n    const selectBgIconStyle = this.getSelectBgIconsStyle(themeColor);\n\n    return [\n      Object.entries(themeColor)\n        .flatMap(([type, values]) =>\n          Object.entries(values).flatMap(([tonality, tonalityValues]) => {\n            if (type === 'action') {\n              return [`--color-${type}-${tonality}: ${tonalityValues};`];\n            } else {\n              return Object.entries(tonalityValues).map(\n                ([level, colorValue]) => `--color-${type}-${tonality}-${level}: ${colorValue};`\n              );\n            }\n          })\n        )\n        .join(''),\n      selectBgIconStyle\n    ].join('');\n  }\n\n  /**\n   * @docsPrivate\n   *\n   * Gera estilos CSS com base nos tokens per Component fornecidos.\n   * @param themePerComponent Os tokens de cor a serem usados para gerar os estilos.\n   * @returns Uma string contendo os estilos CSS gerados.\n   */\n  private generatePerComponentStyles(themePerComponent: any): string {\n    return Object.entries(themePerComponent)\n      .flatMap(([type, values]) =>\n        Object.entries(values).flatMap(([level, colorValue]) => [`${type} {${level}: ${colorValue};};`])\n      )\n      .join('');\n  }\n\n  /**\n   * Define o tema atual como o tema \"PoUI Padrão\".\n   *\n   * @param {PoThemeTypeEnum} type O tipo de Tema a ser aplicado, light / dark.\n   */\n  setDefaultTheme(type: PoThemeTypeEnum): void {\n    this.setTheme(poThemeDefault, type);\n  }\n\n  /**\n   * @docsPrivate\n   *\n   * Retorna o estilo CSS para o fundo dos ícones do componente po-select, com base nas cores do tema.\n   *\n   * @param {PoThemeColor} themeColor - Objeto contendo as cores do tema.\n   * @returns {string} - Estilo CSS para o fundo dos ícones do po-select.\n   */\n  private getSelectBgIconsStyle(themeColor: PoThemeColor): string {\n    let selectBgIcon = '';\n\n    if (themeColor?.brand?.['01']?.dark) {\n      selectBgIcon += `po-select { --background-image: url(\"${this.getSelectBgIcon(themeColor.brand['01'].dark)}\"); };`;\n    }\n    if (themeColor?.feedback?.negative?.base)\n      selectBgIcon += `po-select.ng-dirty.ng-invalid select { --background-image: url(\"${this.getSelectBgIcon(themeColor.feedback.negative.base)}\"); };`;\n\n    if (themeColor?.neutral?.light?.['30'])\n      selectBgIcon += `select:disabled { --background-image: url(\"${this.getSelectBgIcon(themeColor.neutral.light['30'])}\"); };`;\n\n    return selectBgIcon;\n  }\n\n  /**\n   * @docsPrivate\n   *\n   * Retorna a imagem SVG utilizada como fundo do po-select.\n   *\n   * @param {string} color Cor da Imagem - Utilizada no atributo 'fill'.\n   * @returns {string} Imagem SVG utilizada no po-select.\n   */\n  private getSelectBgIcon(color: string): string {\n    let svg: string = `\"data:image/svg+xml,%3Csvg width='24' height='24' viewBox='0 0 24 24' fill='none' `;\n\n    svg = svg.concat(`xmlns='http://www.w3.org/2000/svg'%3E%3Cpath fill-rule='evenodd' clip-rule='evenodd' `);\n    svg = svg.concat(`d='M18.707 8.29301C18.316 7.90201 17.684 7.90201 17.293 8.29301L12 13.586L6.70701 `);\n    svg = svg.concat(`8.29301C6.31601 7.90201 5.68401 7.90201 5.29301 8.29301C4.90201 8.68401 4.90201 `);\n    svg = svg.concat(`9.31601 5.29301 9.70701L11.293 15.707C11.488 15.902 11.744 16 12 16C12.256 16 12.512 `);\n    svg = svg.concat(`15.902 12.707 15.707L18.707 9.70701C19.098 9.31601 19.098 8.68401 18.707 8.29301Z' `);\n    svg = svg.concat(`fill='%23${color}'/%3E%3C/svg%3E%0A\");`);\n\n    return svg;\n  }\n}\n"]}

package/esm2022/lib/services/services.module.mjs

@@ -8,6 +8,7 @@ import { PoDialogModule } from './po-dialog/po-dialog.module';
 import { PoI18nPipe } from './po-i18n/po-i18n.pipe';
 import { PoLanguageModule } from './po-language/po-language.module';
 import { PoNotificationModule } from './po-notification/po-notification.module';
+import { PoThemeModule } from './po-theme/po-theme.module';
 import * as i0 from "@angular/core";
 export class PoServicesModule {
     static ɵfac = function PoServicesModule_Factory(t) { return new (t || PoServicesModule)(); };
@@ -19,13 +20,15 @@ export class PoServicesModule {
             PoDateTimeModule,
             PoDialogModule,
             PoLanguageModule,
-            PoNotificationModule, PoActiveOverlayModule,
+            PoNotificationModule,
+            PoThemeModule, PoActiveOverlayModule,
             PoColorPaletteModule,
             PoComponentInjectorModule,
             PoControlPositionModule,
             PoDateTimeModule,
             PoDialogModule,
-            PoNotificationModule] });
+            PoNotificationModule,
+            PoThemeModule] });
 }
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoServicesModule, [{
         type: NgModule,
@@ -39,7 +42,8 @@ export class PoServicesModule {
                     PoDateTimeModule,
                     PoDialogModule,
                     PoLanguageModule,
-                    PoNotificationModule
+                    PoNotificationModule,
+                    PoThemeModule
                 ],
                 exports: [
                     PoActiveOverlayModule,
@@ -49,7 +53,8 @@ export class PoServicesModule {
                     PoDateTimeModule,
                     PoDialogModule,
                     PoI18nPipe,
-                    PoNotificationModule
+                    PoNotificationModule,
+                    PoThemeModule
                 ],
                 providers: [],
                 bootstrap: []
@@ -62,12 +67,14 @@ export class PoServicesModule {
         PoDateTimeModule,
         PoDialogModule,
         PoLanguageModule,
-        PoNotificationModule], exports: [PoActiveOverlayModule,
+        PoNotificationModule,
+        PoThemeModule], exports: [PoActiveOverlayModule,
         PoColorPaletteModule,
         PoComponentInjectorModule,
         PoControlPositionModule,
         PoDateTimeModule,
         PoDialogModule,
         PoI18nPipe,
-        PoNotificationModule] }); })();
-//# sourceMappingURL=data:application/json;base64,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
+        PoNotificationModule,
+        PoThemeModule] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmljZXMubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdWkvc3JjL2xpYi9zZXJ2aWNlcy9zZXJ2aWNlcy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6QyxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSw4Q0FBOEMsQ0FBQztBQUNyRixPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw0Q0FBNEMsQ0FBQztBQUNsRixPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxzREFBc0QsQ0FBQztBQUNqRyxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxrREFBa0QsQ0FBQztBQUMzRixPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUM1RCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDOUQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ3BELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQ3BFLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDBDQUEwQyxDQUFDO0FBQ2hGLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQzs7QUE2QjNELE1BQU0sT0FBTyxnQkFBZ0I7MEVBQWhCLGdCQUFnQjs0REFBaEIsZ0JBQWdCO2dFQXhCekIscUJBQXFCO1lBQ3JCLG9CQUFvQjtZQUNwQix5QkFBeUI7WUFDekIsdUJBQXVCO1lBQ3ZCLGdCQUFnQjtZQUNoQixjQUFjO1lBQ2QsZ0JBQWdCO1lBQ2hCLG9CQUFvQjtZQUNwQixhQUFhLEVBR2IscUJBQXFCO1lBQ3JCLG9CQUFvQjtZQUNwQix5QkFBeUI7WUFDekIsdUJBQXVCO1lBQ3ZCLGdCQUFnQjtZQUNoQixjQUFjO1lBRWQsb0JBQW9CO1lBQ3BCLGFBQWE7O2lGQUtKLGdCQUFnQjtjQTNCNUIsUUFBUTtlQUFDO2dCQUNSLFlBQVksRUFBRSxDQUFDLFVBQVUsQ0FBQztnQkFDMUIsT0FBTyxFQUFFO29CQUNQLHFCQUFxQjtvQkFDckIsb0JBQW9CO29CQUNwQix5QkFBeUI7b0JBQ3pCLHVCQUF1QjtvQkFDdkIsZ0JBQWdCO29CQUNoQixjQUFjO29CQUNkLGdCQUFnQjtvQkFDaEIsb0JBQW9CO29CQUNwQixhQUFhO2lCQUNkO2dCQUNELE9BQU8sRUFBRTtvQkFDUCxxQkFBcUI7b0JBQ3JCLG9CQUFvQjtvQkFDcEIseUJBQXlCO29CQUN6Qix1QkFBdUI7b0JBQ3ZCLGdCQUFnQjtvQkFDaEIsY0FBYztvQkFDZCxVQUFVO29CQUNWLG9CQUFvQjtvQkFDcEIsYUFBYTtpQkFDZDtnQkFDRCxTQUFTLEVBQUUsRUFBRTtnQkFDYixTQUFTLEVBQUUsRUFBRTthQUNkOzt3RkFDWSxnQkFBZ0IsbUJBMUJaLFVBQVUsYUFFdkIscUJBQXFCO1FBQ3JCLG9CQUFvQjtRQUNwQix5QkFBeUI7UUFDekIsdUJBQXVCO1FBQ3ZCLGdCQUFnQjtRQUNoQixjQUFjO1FBQ2QsZ0JBQWdCO1FBQ2hCLG9CQUFvQjtRQUNwQixhQUFhLGFBR2IscUJBQXFCO1FBQ3JCLG9CQUFvQjtRQUNwQix5QkFBeUI7UUFDekIsdUJBQXVCO1FBQ3ZCLGdCQUFnQjtRQUNoQixjQUFjO1FBQ2QsVUFBVTtRQUNWLG9CQUFvQjtRQUNwQixhQUFhIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgUG9BY3RpdmVPdmVybGF5TW9kdWxlIH0gZnJvbSAnLi9wby1hY3RpdmUtb3ZlcmxheS9wby1hY3RpdmUtb3ZlcmxheS5tb2R1bGUnO1xuaW1wb3J0IHsgUG9Db2xvclBhbGV0dGVNb2R1bGUgfSBmcm9tICcuL3BvLWNvbG9yLXBhbGV0dGUvcG8tY29sb3ItcGFsZXR0ZS5tb2R1bGUnO1xuaW1wb3J0IHsgUG9Db21wb25lbnRJbmplY3Rvck1vZHVsZSB9IGZyb20gJy4vcG8tY29tcG9uZW50LWluamVjdG9yL3BvLWNvbXBvbmVudC1pbmplY3Rvci5tb2R1bGUnO1xuaW1wb3J0IHsgUG9Db250cm9sUG9zaXRpb25Nb2R1bGUgfSBmcm9tICcuL3BvLWNvbnRyb2wtcG9zaXRpb24vcG8tY29udHJvbC1wb3NpdGlvbi5tb2R1bGUnO1xuaW1wb3J0IHsgUG9EYXRlVGltZU1vZHVsZSB9IGZyb20gJy4vcG8tZGF0ZS9wby1kYXRlLm1vZHVsZSc7XG5pbXBvcnQgeyBQb0RpYWxvZ01vZHVsZSB9IGZyb20gJy4vcG8tZGlhbG9nL3BvLWRpYWxvZy5tb2R1bGUnO1xuaW1wb3J0IHsgUG9JMThuUGlwZSB9IGZyb20gJy4vcG8taTE4bi9wby1pMThuLnBpcGUnO1xuaW1wb3J0IHsgUG9MYW5ndWFnZU1vZHVsZSB9IGZyb20gJy4vcG8tbGFuZ3VhZ2UvcG8tbGFuZ3VhZ2UubW9kdWxlJztcbmltcG9ydCB7IFBvTm90aWZpY2F0aW9uTW9kdWxlIH0gZnJvbSAnLi9wby1ub3RpZmljYXRpb24vcG8tbm90aWZpY2F0aW9uLm1vZHVsZSc7XG5pbXBvcnQgeyBQb1RoZW1lTW9kdWxlIH0gZnJvbSAnLi9wby10aGVtZS9wby10aGVtZS5tb2R1bGUnO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtQb0kxOG5QaXBlXSxcbiAgaW1wb3J0czogW1xuICAgIFBvQWN0aXZlT3ZlcmxheU1vZHVsZSxcbiAgICBQb0NvbG9yUGFsZXR0ZU1vZHVsZSxcbiAgICBQb0NvbXBvbmVudEluamVjdG9yTW9kdWxlLFxuICAgIFBvQ29udHJvbFBvc2l0aW9uTW9kdWxlLFxuICAgIFBvRGF0ZVRpbWVNb2R1bGUsXG4gICAgUG9EaWFsb2dNb2R1bGUsXG4gICAgUG9MYW5ndWFnZU1vZHVsZSxcbiAgICBQb05vdGlmaWNhdGlvbk1vZHVsZSxcbiAgICBQb1RoZW1lTW9kdWxlXG4gIF0sXG4gIGV4cG9ydHM6IFtcbiAgICBQb0FjdGl2ZU92ZXJsYXlNb2R1bGUsXG4gICAgUG9Db2xvclBhbGV0dGVNb2R1bGUsXG4gICAgUG9Db21wb25lbnRJbmplY3Rvck1vZHVsZSxcbiAgICBQb0NvbnRyb2xQb3NpdGlvbk1vZHVsZSxcbiAgICBQb0RhdGVUaW1lTW9kdWxlLFxuICAgIFBvRGlhbG9nTW9kdWxlLFxuICAgIFBvSTE4blBpcGUsXG4gICAgUG9Ob3RpZmljYXRpb25Nb2R1bGUsXG4gICAgUG9UaGVtZU1vZHVsZVxuICBdLFxuICBwcm92aWRlcnM6IFtdLFxuICBib290c3RyYXA6IFtdXG59KVxuZXhwb3J0IGNsYXNzIFBvU2VydmljZXNNb2R1bGUge31cbiJdfQ==