@po-ui/ng-components 5.22.1 → 6.1.0

package/esm2020/lib/services/po-date/po-date.service.mjs

@@ -0,0 +1,203 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * @docsPrivate
+ *
+ * @description
+ *
+ * Serviço responsável por gerenciar o tratamento dos formatos de data e hora.
+ */
+export class PoDateService {
+    constructor() {
+        this.dateRegex = new RegExp('^(?:[0-9])\\d{1}(?:[0-9])\\d{1}-' + '(?:0[1-9]|1[0-2])-' + '(?:0[1-9]|[12]\\d|3[01])$');
+        this.isoRegex = new RegExp('^(?:[0-9])\\d{1}(?:[0-9])\\d{1}-' +
+            '(?:0[1-9]|1[0-2])-' +
+            '(?:0[1-9]|[12]\\d|3[01])' +
+            'T(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:Z|-0[1-9]|-1\\d|-2[0-3]|' +
+            '-00:?(?:0[1-9]|[0-5]\\d)|\\+[01]\\d|\\+2[0-3])' +
+            '(?:|:?[0-5]\\d)$');
+    }
+    /**
+     * Método responsável por converter datas do formato `yyyy-mm-ddThh:mm:ss+|-hh:mm` para o formato `Date`.
+     *
+     * @param dateString Data no formato `yyyy-mm-ddThh:mm:ss+|-hh:mm`.
+     * @param minDate Definir `true` caso seja `minDate`.
+     * @param maxDate Definir `true` caso seja `maxDate`.
+     */
+    convertIsoToDate(dateString, minDate, maxDate) {
+        if (dateString) {
+            const { year, month, day } = this.getDateFromIso(dateString);
+            if (minDate) {
+                const date = new Date(year, month - 1, day, 0, 0, 0);
+                this.setYearFrom0To100(date, year);
+                return date;
+            }
+            else if (maxDate) {
+                const date = new Date(year, month - 1, day, 23, 59, 59);
+                this.setYearFrom0To100(date, year);
+                return date;
+            }
+            else {
+                const miliseconds = Date.parse(dateString);
+                const timezone = new Date().getTimezoneOffset() * 60000;
+                return new Date(miliseconds + timezone);
+            }
+        }
+    }
+    /**
+     * Método responsável por converter data do formato `Date` para o formato `yyyy-mm-dd`.
+     *
+     * @param date Data no formato `Date`.
+     */
+    convertDateToISO(date) {
+        if (date) {
+            const fullYear = date.getFullYear();
+            const getMonth = date.getMonth() + 1;
+            const day = date.getDate() < 10 ? '0' + date.getDate() : date.getDate();
+            const month = getMonth < 10 ? '0' + getMonth : getMonth;
+            const year = this.formatYear(fullYear);
+            return year + '-' + month + '-' + day;
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * Método responsável por adicionar zeros a esquerda do anos em formato string.
+     *
+     * @param year Ano a ser validado.
+     */
+    formatYear(year) {
+        if (year > 999) {
+            return year.toString();
+        }
+        if (year > 99 && year < 1000) {
+            return `0${year}`;
+        }
+        if (year > 9 && year < 100) {
+            return `00${year}`;
+        }
+        if (year >= 0 && year < 10) {
+            return `000${year}`;
+        }
+    }
+    /**
+     * Método responsável por retornar o dia, mês e ano separados em formato de objeto.
+     *
+     * @param isoDate Ano em formato string.
+     */
+    getDateFromIso(isoDate) {
+        const day = parseInt(isoDate.substring(8, 10), 10);
+        const month = parseInt(isoDate.substring(5, 7), 10);
+        const year = parseInt(isoDate.substring(0, 4), 10);
+        return { year, month, day };
+    }
+    /**
+     * Método responsável por retornar a data com a hora definida para `00:00:00` caso `isMinDate` for igual a `true` ou `23:59:59`
+     * caso `isMindate` seja igual a `false` .
+     *
+     * @param date Data no formato `Date` ou `yyyy-mm-ddThh:mm:ss+|-hh:mm`.
+     * @param isMinDate Caso `true` aplica `00:00:00`, caso `false` aplica `23:59:59` a hora da data informada.
+     */
+    getDateForDateRange(date, isMinDate) {
+        const lastHour = isMinDate ? [0, 0, 0] : [23, 59, 59];
+        if (date instanceof Date) {
+            const { year, month, day } = this.splitDate(date);
+            const validDate = new Date(year, month, day, ...lastHour);
+            this.setYearFrom0To100(validDate, year);
+            return validDate;
+        }
+        else if (this.isValidIso(date)) {
+            return this.convertIsoToDate(date, isMinDate, !isMinDate);
+        }
+    }
+    /**
+     * Retorna `true` caso o período seja válido, para isso a primeira data deve ser maior que a segunda data.
+     *
+     * @param dateA primeira data
+     * @param dateB segunda data
+     */
+    isDateRangeValid(dateA = '', dateB = '') {
+        const dateASplitted = dateA.split('-').map(item => parseInt(item, 10));
+        const dateBSplitted = dateB.split('-').map(item => parseInt(item, 10));
+        for (let index = 0; index <= dateASplitted.length; index++) {
+            if (dateASplitted[index] > dateBSplitted[index]) {
+                return true;
+            }
+            else if (dateASplitted[index] < dateBSplitted[index]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Método responsável por validar se uma data está no formato `yyyy-mm-ddThh:mm:ss+|-hh:mm` ou `yyyy-mm-dd`.
+     *
+     * @param stringDate Data.
+     */
+    isValidIso(stringDate) {
+        return this.dateRegex.test(stringDate) || this.isoRegex.test(stringDate);
+    }
+    /**
+     * Método responsável por corrigir a data caso a mesma esteja entre os anos 0 e 99.
+     *
+     * @param date Data.
+     * @param year .
+     */
+    setYearFrom0To100(date, year) {
+        if (year >= 0 && year < 100) {
+            date.setFullYear(year);
+        }
+    }
+    /**
+     * Método responsável por retornar o dia , mês e ano de uma data informada.
+     *
+     * @param date Valor da data.
+     */
+    splitDate(date) {
+        const year = date.getFullYear();
+        const month = date.getMonth();
+        const day = date.getDate();
+        return { year, month, day };
+    }
+    /**
+     * Método responsável por validar se uma data está entre a `minDate` e `maxDate`.
+     *
+     * @param date Data a ser validada.
+     * @param minDate Data inicial.
+     * @param maxDate Data final.
+     */
+    validateDateRange(date, minDate, maxDate) {
+        if (minDate && maxDate) {
+            return date >= minDate && date <= maxDate;
+        }
+        else if (minDate && !maxDate) {
+            return date >= minDate;
+        }
+        else if (!minDate && maxDate) {
+            return date <= maxDate;
+        }
+        else {
+            return true;
+        }
+    }
+    /**
+     * Método responsável por validar se a data foi informada nos padrões 'yyyy-mm-dd', 'yyyy-mm-ddThh:mm:ss+|-hh:mm' ou
+     * 'Date' padrão do javascript.
+     *
+     * @param date Data que será validada.
+     */
+    validateDate(date) {
+        const validDate = date instanceof Date ? this.convertDateToISO(date) : date;
+        return this.isValidIso(validDate) ? validDate : undefined;
+    }
+}
+PoDateService.ɵfac = function PoDateService_Factory(t) { return new (t || PoDateService)(); };
+PoDateService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PoDateService, factory: PoDateService.ɵfac, providedIn: 'root' });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoDateService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-date.service.js","sourceRoot":"","sources":["../../../../../../projects/ui/src/lib/services/po-date/po-date.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { sortValues } from '../../utils/util';\n\n/**\n * @docsPrivate\n *\n * @description\n *\n * Serviço responsável por gerenciar o tratamento dos formatos de data e hora.\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class PoDateService {\n  private readonly dateRegex = new RegExp(\n    '^(?:[0-9])\\\\d{1}(?:[0-9])\\\\d{1}-' + '(?:0[1-9]|1[0-2])-' + '(?:0[1-9]|[12]\\\\d|3[01])$'\n  );\n\n  private readonly isoRegex = new RegExp(\n    '^(?:[0-9])\\\\d{1}(?:[0-9])\\\\d{1}-' +\n      '(?:0[1-9]|1[0-2])-' +\n      '(?:0[1-9]|[12]\\\\d|3[01])' +\n      'T(?:[01]\\\\d|2[0-3]):[0-5]\\\\d:[0-5]\\\\d(?:Z|-0[1-9]|-1\\\\d|-2[0-3]|' +\n      '-00:?(?:0[1-9]|[0-5]\\\\d)|\\\\+[01]\\\\d|\\\\+2[0-3])' +\n      '(?:|:?[0-5]\\\\d)$'\n  );\n\n  /**\n   * Método responsável por converter datas do formato `yyyy-mm-ddThh:mm:ss+|-hh:mm` para o formato `Date`.\n   *\n   * @param dateString Data no formato `yyyy-mm-ddThh:mm:ss+|-hh:mm`.\n   * @param minDate Definir `true` caso seja `minDate`.\n   * @param maxDate Definir `true` caso seja `maxDate`.\n   */\n  convertIsoToDate(dateString: string, minDate?: boolean, maxDate?: boolean): Date {\n    if (dateString) {\n      const { year, month, day } = this.getDateFromIso(dateString);\n\n      if (minDate) {\n        const date = new Date(year, month - 1, day, 0, 0, 0);\n        this.setYearFrom0To100(date, year);\n        return date;\n      } else if (maxDate) {\n        const date = new Date(year, month - 1, day, 23, 59, 59);\n        this.setYearFrom0To100(date, year);\n        return date;\n      } else {\n        const miliseconds = Date.parse(dateString);\n        const timezone = new Date().getTimezoneOffset() * 60000;\n        return new Date(miliseconds + timezone);\n      }\n    }\n  }\n\n  /**\n   * Método responsável por converter data do formato `Date` para o formato `yyyy-mm-dd`.\n   *\n   * @param date Data no formato `Date`.\n   */\n  convertDateToISO(date: Date) {\n    if (date) {\n      const fullYear = date.getFullYear();\n      const getMonth = date.getMonth() + 1;\n      const day = date.getDate() < 10 ? '0' + date.getDate() : date.getDate();\n      const month = getMonth < 10 ? '0' + getMonth : getMonth;\n      const year = this.formatYear(fullYear);\n      return year + '-' + month + '-' + day;\n    } else {\n      return null;\n    }\n  }\n\n  /**\n   * Método responsável por adicionar zeros a esquerda do anos em formato string.\n   *\n   * @param year Ano a ser validado.\n   */\n  formatYear(year: number) {\n    if (year > 999) {\n      return year.toString();\n    }\n\n    if (year > 99 && year < 1000) {\n      return `0${year}`;\n    }\n\n    if (year > 9 && year < 100) {\n      return `00${year}`;\n    }\n\n    if (year >= 0 && year < 10) {\n      return `000${year}`;\n    }\n  }\n\n  /**\n   * Método responsável por retornar o dia, mês e ano separados em formato de objeto.\n   *\n   * @param isoDate Ano em formato string.\n   */\n  getDateFromIso(isoDate: string): { year: number; month: number; day: number } {\n    const day = parseInt(isoDate.substring(8, 10), 10);\n    const month = parseInt(isoDate.substring(5, 7), 10);\n    const year = parseInt(isoDate.substring(0, 4), 10);\n\n    return { year, month, day };\n  }\n\n  /**\n   * Método responsável por retornar a data com a hora definida para `00:00:00` caso `isMinDate` for igual a `true` ou `23:59:59`\n   * caso `isMindate` seja igual a `false` .\n   *\n   * @param date Data no formato `Date` ou `yyyy-mm-ddThh:mm:ss+|-hh:mm`.\n   * @param isMinDate Caso `true` aplica `00:00:00`, caso `false` aplica `23:59:59` a hora da data informada.\n   */\n  getDateForDateRange(date: any, isMinDate: boolean) {\n    const lastHour = isMinDate ? [0, 0, 0] : [23, 59, 59];\n    if (date instanceof Date) {\n      const { year, month, day } = this.splitDate(date);\n      const validDate = new Date(year, month, day, ...lastHour);\n      this.setYearFrom0To100(validDate, year);\n      return validDate;\n    } else if (this.isValidIso(date)) {\n      return this.convertIsoToDate(date, isMinDate, !isMinDate);\n    }\n  }\n\n  /**\n   * Retorna `true` caso o período seja válido, para isso a primeira data deve ser maior que a segunda data.\n   *\n   * @param dateA primeira data\n   * @param dateB segunda data\n   */\n  isDateRangeValid(dateA: string = '', dateB: string = ''): boolean {\n    const dateASplitted = dateA.split('-').map(item => parseInt(item, 10));\n    const dateBSplitted = dateB.split('-').map(item => parseInt(item, 10));\n\n    for (let index = 0; index <= dateASplitted.length; index++) {\n      if (dateASplitted[index] > dateBSplitted[index]) {\n        return true;\n      } else if (dateASplitted[index] < dateBSplitted[index]) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Método responsável por validar se uma data está no formato `yyyy-mm-ddThh:mm:ss+|-hh:mm` ou `yyyy-mm-dd`.\n   *\n   * @param stringDate Data.\n   */\n  isValidIso(stringDate: string) {\n    return this.dateRegex.test(stringDate) || this.isoRegex.test(stringDate);\n  }\n\n  /**\n   * Método responsável por corrigir a data caso a mesma esteja entre os anos 0 e 99.\n   *\n   * @param date Data.\n   * @param year .\n   */\n  setYearFrom0To100(date: Date, year: number) {\n    if (year >= 0 && year < 100) {\n      date.setFullYear(year);\n    }\n  }\n\n  /**\n   * Método responsável por retornar o dia , mês e ano de uma data informada.\n   *\n   * @param date Valor da data.\n   */\n  splitDate(date: Date) {\n    const year = date.getFullYear();\n    const month = date.getMonth();\n    const day = date.getDate();\n    return { year, month, day };\n  }\n\n  /**\n   * Método responsável por validar se uma data está entre a `minDate` e `maxDate`.\n   *\n   * @param date Data a ser validada.\n   * @param minDate Data inicial.\n   * @param maxDate Data final.\n   */\n  validateDateRange(date: Date, minDate: Date, maxDate: Date) {\n    if (minDate && maxDate) {\n      return date >= minDate && date <= maxDate;\n    } else if (minDate && !maxDate) {\n      return date >= minDate;\n    } else if (!minDate && maxDate) {\n      return date <= maxDate;\n    } else {\n      return true;\n    }\n  }\n\n  /**\n   * Método responsável por validar se a data foi informada nos padrões 'yyyy-mm-dd', 'yyyy-mm-ddThh:mm:ss+|-hh:mm' ou\n   * 'Date' padrão do javascript.\n   *\n   * @param date Data que será validada.\n   */\n  private validateDate(date: string | Date) {\n    const validDate = date instanceof Date ? this.convertDateToISO(date) : date;\n\n    return this.isValidIso(validDate) ? validDate : undefined;\n  }\n}\n"]}

package/esm2020/lib/services/po-dialog/po-dialog.component.mjs

@@ -0,0 +1,132 @@
+import { Component, ViewChild } from '@angular/core';
+import { poLocaleDefault } from '../po-language/po-language.constant';
+import { PoDialogType } from './po-dialog.enum';
+import { PoModalComponent } from '../../components/po-modal/po-modal.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../po-language/po-language.service";
+import * as i2 from "../../components/po-modal/po-modal.component";
+export const poDialogAlertLiteralsDefault = {
+    en: { ok: 'Ok' },
+    es: { ok: 'Ok' },
+    pt: { ok: 'Ok' },
+    ru: { ok: 'Ок' }
+};
+export const poDialogConfirmLiteralsDefault = {
+    en: { cancel: 'Cancel', confirm: 'Confirm' },
+    es: { cancel: 'Cancelar', confirm: 'Confirmar' },
+    pt: { cancel: 'Cancelar', confirm: 'Confirmar' },
+    ru: { cancel: 'отменить', confirm: 'подтвердить' }
+};
+/**
+ * @docsPrivate
+ *
+ * @description
+ *
+ * Componente que serve como container do po-dialog.service
+ */
+export class PoDialogComponent {
+    constructor(languageService) {
+        // Objeto primary do poModal
+        this.primaryAction = { label: 'ok', action: () => { } };
+        this.language = languageService.getShortLanguage();
+    }
+    ngOnDestroy() {
+        this.closeSubscription.unsubscribe();
+    }
+    ngOnInit() {
+        this.closeSubscription = this.poModal.onXClosed.subscribe(close => this.close(true));
+    }
+    // Fecha o poModal
+    close(xClosed = false) {
+        if (xClosed && this.closeAction) {
+            this.closeAction();
+        }
+        this.poModal.close();
+        this.destroy();
+    }
+    destroy() {
+        if (this.componentRef) {
+            this.componentRef.destroy();
+        }
+    }
+    // Insere os valores recebidos de this.open para o poModal
+    configDialog(primaryLabel, primaryAction, secondaryLabel, secondaryAction, closeAction) {
+        this.primaryAction = {
+            label: primaryLabel,
+            action: () => {
+                if (primaryAction) {
+                    primaryAction();
+                }
+                this.close();
+            }
+        };
+        if (secondaryLabel) {
+            this.secondaryAction = {
+                label: secondaryLabel,
+                action: () => {
+                    if (secondaryAction) {
+                        secondaryAction();
+                    }
+                    this.close();
+                }
+            };
+        }
+        this.closeAction = closeAction;
+    }
+    // Insere os valores recebidos de po-dialog.service de acordo com o tipo de diálago solicitado
+    open(dialogOptions, dialogType, componentRef) {
+        this.title = dialogOptions.title;
+        this.message = dialogOptions.message;
+        this.componentRef = componentRef;
+        this.setDialogLiterals(dialogOptions, dialogType);
+        switch (dialogType) {
+            case PoDialogType.Confirm: {
+                this.configDialog(this.literalsConfirm.confirm, dialogOptions.confirm, this.literalsConfirm.cancel, dialogOptions.cancel, dialogOptions.close);
+                break;
+            }
+            case PoDialogType.Alert: {
+                this.configDialog(this.literalsAlert.ok, dialogOptions.ok);
+                break;
+            }
+        }
+        this.poModal.open();
+    }
+    setDialogLiterals(dialogOptions, dialogType) {
+        const alertLiterals = poDialogAlertLiteralsDefault;
+        const confirmLiterals = poDialogConfirmLiteralsDefault;
+        const literals = dialogOptions.literals;
+        if (dialogType === PoDialogType.Alert) {
+            this.literalsAlert = { ...alertLiterals[poLocaleDefault], ...alertLiterals[this.language], ...literals };
+        }
+        else {
+            this.literalsConfirm = {
+                ...confirmLiterals[poLocaleDefault],
+                ...confirmLiterals[this.language],
+                ...literals
+            };
+        }
+    }
+}
+PoDialogComponent.ɵfac = function PoDialogComponent_Factory(t) { return new (t || PoDialogComponent)(i0.ɵɵdirectiveInject(i1.PoLanguageService)); };
+PoDialogComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PoDialogComponent, selectors: [["ng-component"]], viewQuery: function PoDialogComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(PoModalComponent, 7);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.poModal = _t.first);
+    } }, decls: 2, vars: 4, consts: [[3, "p-title", "p-primary-action", "p-secondary-action"], [3, "innerHtml"]], template: function PoDialogComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "po-modal", 0);
+        i0.ɵɵelement(1, "div", 1);
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵproperty("p-title", ctx.title)("p-primary-action", ctx.primaryAction)("p-secondary-action", ctx.secondaryAction);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("innerHtml", ctx.message, i0.ɵɵsanitizeHtml);
+    } }, directives: [i2.PoModalComponent], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoDialogComponent, [{
+        type: Component,
+        args: [{ template: "<po-modal [p-title]=\"title\" [p-primary-action]=\"primaryAction\" [p-secondary-action]=\"secondaryAction\">\n  <div [innerHtml]=\"message\"></div>\n</po-modal>\n" }]
+    }], function () { return [{ type: i1.PoLanguageService }]; }, { poModal: [{
+            type: ViewChild,
+            args: [PoModalComponent, { static: true }]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-dialog.component.js","sourceRoot":"","sources":["../../../../../../projects/ui/src/lib/services/po-dialog/po-dialog.component.ts","../../../../../../projects/ui/src/lib/services/po-dialog/po-dialog.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, ComponentRef, OnDestroy, OnInit, ViewChild } from '@angular/core';\n\nimport { Subscription } from 'rxjs';\n\nimport { poLocaleDefault } from '../po-language/po-language.constant';\n\nimport { PoLanguageService } from '../po-language/po-language.service';\n\nimport { PoDialogAlertLiterals } from './interfaces/po-dialog-alert-literals.interface';\nimport { PoDialogAlertOptions, PoDialogConfirmOptions } from './interfaces/po-dialog.interface';\nimport { PoDialogConfirmLiterals } from './interfaces/po-dialog-confirm-literals.interface';\nimport { PoDialogType } from './po-dialog.enum';\nimport { PoModalAction } from '../../components/po-modal/po-modal-action.interface';\nimport { PoModalComponent } from '../../components/po-modal/po-modal.component';\n\nexport const poDialogAlertLiteralsDefault = {\n  en: <PoDialogAlertLiterals>{ ok: 'Ok' },\n  es: <PoDialogAlertLiterals>{ ok: 'Ok' },\n  pt: <PoDialogAlertLiterals>{ ok: 'Ok' },\n  ru: <PoDialogAlertLiterals>{ ok: 'Ок' }\n};\n\nexport const poDialogConfirmLiteralsDefault = {\n  en: <PoDialogConfirmLiterals>{ cancel: 'Cancel', confirm: 'Confirm' },\n  es: <PoDialogConfirmLiterals>{ cancel: 'Cancelar', confirm: 'Confirmar' },\n  pt: <PoDialogConfirmLiterals>{ cancel: 'Cancelar', confirm: 'Confirmar' },\n  ru: <PoDialogConfirmLiterals>{ cancel: 'отменить', confirm: 'подтвердить' }\n};\n\n/**\n * @docsPrivate\n *\n * @description\n *\n * Componente que serve como container do po-dialog.service\n */\n\n@Component({\n  templateUrl: './po-dialog.component.html'\n})\nexport class PoDialogComponent implements OnDestroy, OnInit {\n  // ViewChild para o uso do po-modal.component\n  @ViewChild(PoModalComponent, { static: true }) poModal: PoModalComponent;\n\n  // Title do poModal\n  title: string;\n\n  // Message do poModal\n  message: string;\n\n  // Objeto primary do poModal\n  primaryAction: PoModalAction = { label: 'ok', action: () => {} };\n\n  // Objeto secondary do poModal\n  secondaryAction: PoModalAction;\n\n  // Callback executado ao fechar o poModal\n  closeAction: Function;\n\n  // Literais usadas nos botão de alerta do poModal\n  literalsAlert: PoDialogAlertLiterals;\n\n  // Literais usadas nos botões de confirmação do poModal\n  literalsConfirm: PoDialogConfirmLiterals;\n\n  // Atributo para armazenar a referencia do componente criado via serviço.\n  private componentRef: ComponentRef<PoDialogComponent>;\n  private closeSubscription: Subscription;\n  private language: string;\n\n  constructor(languageService: PoLanguageService) {\n    this.language = languageService.getShortLanguage();\n  }\n\n  ngOnDestroy() {\n    this.closeSubscription.unsubscribe();\n  }\n\n  ngOnInit() {\n    this.closeSubscription = this.poModal.onXClosed.subscribe(close => this.close(true));\n  }\n\n  // Fecha o poModal\n  close(xClosed = false): void {\n    if (xClosed && this.closeAction) {\n      this.closeAction();\n    }\n\n    this.poModal.close();\n    this.destroy();\n  }\n\n  destroy() {\n    if (this.componentRef) {\n      this.componentRef.destroy();\n    }\n  }\n\n  // Insere os valores recebidos de this.open para o poModal\n  configDialog(primaryLabel?, primaryAction?, secondaryLabel?, secondaryAction?, closeAction?) {\n    this.primaryAction = {\n      label: primaryLabel,\n      action: () => {\n        if (primaryAction) {\n          primaryAction();\n        }\n        this.close();\n      }\n    };\n\n    if (secondaryLabel) {\n      this.secondaryAction = {\n        label: secondaryLabel,\n        action: () => {\n          if (secondaryAction) {\n            secondaryAction();\n          }\n          this.close();\n        }\n      };\n    }\n\n    this.closeAction = closeAction;\n  }\n\n  // Insere os valores recebidos de po-dialog.service de acordo com o tipo de diálago solicitado\n  open(\n    dialogOptions: PoDialogConfirmOptions | PoDialogAlertOptions,\n    dialogType: PoDialogType,\n    componentRef?: ComponentRef<PoDialogComponent>\n  ): void {\n    this.title = dialogOptions.title;\n    this.message = dialogOptions.message;\n\n    this.componentRef = componentRef;\n\n    this.setDialogLiterals(dialogOptions, dialogType);\n\n    switch (dialogType) {\n      case PoDialogType.Confirm: {\n        this.configDialog(\n          this.literalsConfirm.confirm,\n          (<PoDialogConfirmOptions>dialogOptions).confirm,\n          this.literalsConfirm.cancel,\n          (<PoDialogConfirmOptions>dialogOptions).cancel,\n          (<PoDialogConfirmOptions>dialogOptions).close\n        );\n        break;\n      }\n      case PoDialogType.Alert: {\n        this.configDialog(this.literalsAlert.ok, (<PoDialogAlertOptions>dialogOptions).ok);\n        break;\n      }\n    }\n\n    this.poModal.open();\n  }\n\n  private setDialogLiterals(dialogOptions: PoDialogConfirmOptions | PoDialogAlertOptions, dialogType: PoDialogType) {\n    const alertLiterals = poDialogAlertLiteralsDefault;\n    const confirmLiterals = poDialogConfirmLiteralsDefault;\n    const literals = dialogOptions.literals;\n\n    if (dialogType === PoDialogType.Alert) {\n      this.literalsAlert = { ...alertLiterals[poLocaleDefault], ...alertLiterals[this.language], ...literals };\n    } else {\n      this.literalsConfirm = {\n        ...confirmLiterals[poLocaleDefault],\n        ...confirmLiterals[this.language],\n        ...literals\n      };\n    }\n  }\n}\n","<po-modal [p-title]=\"title\" [p-primary-action]=\"primaryAction\" [p-secondary-action]=\"secondaryAction\">\n  <div [innerHtml]=\"message\"></div>\n</po-modal>\n"]}

package/esm2020/lib/services/po-dialog/po-dialog.module.mjs

@@ -0,0 +1,21 @@
+import { NgModule } from '@angular/core';
+import { PoModalModule } from '../../components/po-modal/po-modal.module';
+import { PoDialogComponent } from './po-dialog.component';
+import { PoDialogService } from './po-dialog.service';
+import * as i0 from "@angular/core";
+export class PoDialogModule {
+}
+PoDialogModule.ɵfac = function PoDialogModule_Factory(t) { return new (t || PoDialogModule)(); };
+PoDialogModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: PoDialogModule });
+PoDialogModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [PoDialogService], imports: [[PoModalModule]] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoDialogModule, [{
+        type: NgModule,
+        args: [{
+                declarations: [PoDialogComponent],
+                imports: [PoModalModule],
+                exports: [PoDialogComponent],
+                providers: [PoDialogService]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(PoDialogModule, { declarations: [PoDialogComponent], imports: [PoModalModule], exports: [PoDialogComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tZGlhbG9nLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3VpL3NyYy9saWIvc2VydmljZXMvcG8tZGlhbG9nL3BvLWRpYWxvZy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sMkNBQTJDLENBQUM7QUFDMUUsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDMUQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHFCQUFxQixDQUFDOztBQVF0RCxNQUFNLE9BQU8sY0FBYzs7NEVBQWQsY0FBYztnRUFBZCxjQUFjO3FFQUZkLENBQUMsZUFBZSxDQUFDLFlBRm5CLENBQUMsYUFBYSxDQUFDO3VGQUliLGNBQWM7Y0FOMUIsUUFBUTtlQUFDO2dCQUNSLFlBQVksRUFBRSxDQUFDLGlCQUFpQixDQUFDO2dCQUNqQyxPQUFPLEVBQUUsQ0FBQyxhQUFhLENBQUM7Z0JBQ3hCLE9BQU8sRUFBRSxDQUFDLGlCQUFpQixDQUFDO2dCQUM1QixTQUFTLEVBQUUsQ0FBQyxlQUFlLENBQUM7YUFDN0I7O3dGQUNZLGNBQWMsbUJBTFYsaUJBQWlCLGFBQ3RCLGFBQWEsYUFDYixpQkFBaUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBQb01vZGFsTW9kdWxlIH0gZnJvbSAnLi4vLi4vY29tcG9uZW50cy9wby1tb2RhbC9wby1tb2RhbC5tb2R1bGUnO1xuaW1wb3J0IHsgUG9EaWFsb2dDb21wb25lbnQgfSBmcm9tICcuL3BvLWRpYWxvZy5jb21wb25lbnQnO1xuaW1wb3J0IHsgUG9EaWFsb2dTZXJ2aWNlIH0gZnJvbSAnLi9wby1kaWFsb2cuc2VydmljZSc7XG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW1BvRGlhbG9nQ29tcG9uZW50XSxcbiAgaW1wb3J0czogW1BvTW9kYWxNb2R1bGVdLFxuICBleHBvcnRzOiBbUG9EaWFsb2dDb21wb25lbnRdLFxuICBwcm92aWRlcnM6IFtQb0RpYWxvZ1NlcnZpY2VdXG59KVxuZXhwb3J0IGNsYXNzIFBvRGlhbG9nTW9kdWxlIHt9XG4iXX0=

package/esm2020/lib/services/po-dialog/po-dialog.service.mjs

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core';
+import { PoDialogBaseService } from './po-dialog-base.service';
+import { PoDialogComponent } from './po-dialog.component';
+import * as i0 from "@angular/core";
+import * as i1 from "./../po-component-injector/po-component-injector.service";
+/**
+ * @docsExtends PoDialogBaseService
+ *
+ * @example
+ *
+ * <example name="po-dialog-basic" title="PO Dialog Basic">
+ *  <file name="sample-po-dialog-basic/sample-po-dialog-basic.component.html"> </file>
+ *  <file name="sample-po-dialog-basic/sample-po-dialog-basic.component.ts"> </file>
+ * </example>
+ *
+ * <example name="po-dialog-labs" title="PO Dialog Labs">
+ *  <file name="sample-po-dialog-labs/sample-po-dialog-labs.component.html"> </file>
+ *  <file name="sample-po-dialog-labs/sample-po-dialog-labs.component.ts"> </file>
+ * </example>
+ *
+ * <example name="po-dialog-cancel-credit-card" title="PO Dialog - Cancel Credit Card">
+ *  <file name="sample-po-dialog-cancel-credit-card/sample-po-dialog-cancel-credit-card.component.html"> </file>
+ *  <file name="sample-po-dialog-cancel-credit-card/sample-po-dialog-cancel-credit-card.component.ts"> </file>
+ * </example>
+ */
+export class PoDialogService extends PoDialogBaseService {
+    constructor(poComponentInjector) {
+        super();
+        this.poComponentInjector = poComponentInjector;
+    }
+    openDialog(dialogType, dialogOptions) {
+        const componentRef = this.poComponentInjector.createComponentInApplication(PoDialogComponent);
+        componentRef.changeDetectorRef.detectChanges();
+        componentRef.instance.open(dialogOptions, dialogType, componentRef);
+    }
+}
+PoDialogService.ɵfac = function PoDialogService_Factory(t) { return new (t || PoDialogService)(i0.ɵɵinject(i1.PoComponentInjectorService)); };
+PoDialogService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PoDialogService, factory: PoDialogService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoDialogService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.PoComponentInjectorService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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