@po-ui/ng-components 5.22.1 → 6.1.0

package/esm2020/lib/directives/po-tooltip/po-tooltip-base.directive.mjs

@@ -0,0 +1,115 @@
+import { __decorate } from "tslib";
+import { Input, Directive } from '@angular/core';
+import { InputBoolean } from '../../decorators';
+import { PO_CONTROL_POSITIONS } from './../../services/po-control-position/po-control-position.constants';
+import * as i0 from "@angular/core";
+const CONTENT_MAX_LENGTH = 140;
+const PO_TOOLTIP_POSITION_DEFAULT = 'bottom';
+/**
+ * @description
+ *
+ * A diretiva po-tooltip deve ser utilizada para oferecer informações adicionais quando os usuários
+ * passam o mouse sobre o elemento alvo ao qual ela está atribuída.
+ *
+ * O conteúdo é formado por um pequeno texto que deve contribuir para uma tomada de decisão ou
+ * orientação do usuário. A ativação dele pode estar em qualquer componente ou tag HTML.
+ *
+ * Para textos maiores ou no caso de haver a necessidade de utilizar algum outro elemento como
+ * conteúdo deve-se utilizar o [**po-popover**](https://po-ui.io/documentation/po-popover?view=doc).
+ */
+export class PoTooltipBaseDirective {
+    constructor() {
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Define que o po-tooltip será incluido no body e não dentro do elemento ao qual o tooltip foi especificado.
+         * Opção necessária para o caso de uso de tooltip em um elemento SVG.
+         *
+         * @default `false`
+         */
+        this.appendInBody = false;
+        this._tooltipPosition = 'bottom';
+        this._displayTooltip = false;
+        this._tooltip = '';
+    }
+    /**
+     * @description
+     *
+     * Habilita e atribui um texto ao po-tooltip, com limitação de 140 caracteres.
+     */
+    set tooltip(tooltip) {
+        if (tooltip && tooltip.length > CONTENT_MAX_LENGTH) {
+            this._tooltip = tooltip.substring(0, CONTENT_MAX_LENGTH);
+        }
+        else {
+            this._tooltip = tooltip;
+        }
+    }
+    get tooltip() {
+        return this._tooltip;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Define a posição que o po-tooltip abrirá em relação ao componente alvo. Sugere-se que seja
+     * usada a orientação "bottom" (abaixo), porém o mesmo é flexível e será rotacionado
+     * automaticamente para se adequar a tela, caso necessário.
+     *
+     * Posições válidas:
+     * - `right`: Posiciona o po-tooltip no lado direito do componente alvo.
+     * - `right-bottom`: Posiciona o po-tooltip no lado direito inferior do componente alvo.
+     * - `right-top`: Posiciona o po-tooltip no lado direito superior do componente alvo.
+     * - `bottom`: Posiciona o po-tooltip abaixo do componente alvo.
+     * - `bottom-left`: Posiciona o po-tooltip abaixo e à esquerda do componente alvo.
+     * - `bottom-right`: Posiciona o po-tooltip abaixo e à direita do componente alvo.
+     * - `left`: Posiciona o po-tooltip no lado esquerdo do componente alvo.
+     * - `left-top`: Posiciona o po-tooltip no lado esquerdo superior do componente alvo.
+     * - `left-bottom`: Posiciona o po-tooltip no lado esquerdo inferior do componente alvo.
+     * - `top`: Posiciona o po-tooltip acima do componente alvo.
+     * - `top-right`: Posiciona o po-tooltip acima e à direita do componente alvo.
+     * - `top-left`: Posiciona o po-tooltip acima e à esquerda do componente alvo.
+     *
+     * @default bottom
+     */
+    set tooltipPosition(position) {
+        this._tooltipPosition = PO_CONTROL_POSITIONS.includes(position) ? position : PO_TOOLTIP_POSITION_DEFAULT;
+    }
+    get tooltipPosition() {
+        return this._tooltipPosition;
+    }
+    set displayTooltip(value) {
+        this._displayTooltip = value;
+        this._displayTooltip ? this.addTooltipAction() : this.removeTooltipAction();
+    }
+    get displayTooltip() {
+        return this._displayTooltip;
+    }
+}
+PoTooltipBaseDirective.ɵfac = function PoTooltipBaseDirective_Factory(t) { return new (t || PoTooltipBaseDirective)(); };
+PoTooltipBaseDirective.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PoTooltipBaseDirective, inputs: { appendInBody: ["p-append-in-body", "appendInBody"], tooltip: ["p-tooltip", "tooltip"], tooltipPosition: ["p-tooltip-position", "tooltipPosition"], displayTooltip: ["p-display-tooltip", "displayTooltip"] } });
+__decorate([
+    InputBoolean()
+], PoTooltipBaseDirective.prototype, "appendInBody", void 0);
+__decorate([
+    InputBoolean()
+], PoTooltipBaseDirective.prototype, "displayTooltip", null);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoTooltipBaseDirective, [{
+        type: Directive
+    }], null, { appendInBody: [{
+            type: Input,
+            args: ['p-append-in-body']
+        }], tooltip: [{
+            type: Input,
+            args: ['p-tooltip']
+        }], tooltipPosition: [{
+            type: Input,
+            args: ['p-tooltip-position']
+        }], displayTooltip: [{
+            type: Input,
+            args: ['p-display-tooltip']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/directives/po-tooltip/po-tooltip-control-position.service.mjs

@@ -0,0 +1,11 @@
+import { Injectable } from '@angular/core';
+import { PoControlPositionService } from '../../services/po-control-position/po-control-position.service';
+import * as i0 from "@angular/core";
+export class PoTooltipControlPositionService extends PoControlPositionService {
+}
+PoTooltipControlPositionService.ɵfac = /*@__PURE__*/ function () { let ɵPoTooltipControlPositionService_BaseFactory; return function PoTooltipControlPositionService_Factory(t) { return (ɵPoTooltipControlPositionService_BaseFactory || (ɵPoTooltipControlPositionService_BaseFactory = i0.ɵɵgetInheritedFactory(PoTooltipControlPositionService)))(t || PoTooltipControlPositionService); }; }();
+PoTooltipControlPositionService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PoTooltipControlPositionService, factory: PoTooltipControlPositionService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoTooltipControlPositionService, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tdG9vbHRpcC1jb250cm9sLXBvc2l0aW9uLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS9zcmMvbGliL2RpcmVjdGl2ZXMvcG8tdG9vbHRpcC9wby10b29sdGlwLWNvbnRyb2wtcG9zaXRpb24uc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTNDLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLGdFQUFnRSxDQUFDOztBQUcxRyxNQUFNLE9BQU8sK0JBQWdDLFNBQVEsd0JBQXdCOzttVEFBaEUsK0JBQStCLFNBQS9CLCtCQUErQjtxRkFBL0IsK0JBQStCLFdBQS9CLCtCQUErQjt1RkFBL0IsK0JBQStCO2NBRDNDLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFBvQ29udHJvbFBvc2l0aW9uU2VydmljZSB9IGZyb20gJy4uLy4uL3NlcnZpY2VzL3BvLWNvbnRyb2wtcG9zaXRpb24vcG8tY29udHJvbC1wb3NpdGlvbi5zZXJ2aWNlJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIFBvVG9vbHRpcENvbnRyb2xQb3NpdGlvblNlcnZpY2UgZXh0ZW5kcyBQb0NvbnRyb2xQb3NpdGlvblNlcnZpY2Uge31cbiJdfQ==

package/esm2020/lib/directives/po-tooltip/po-tooltip.directive.mjs

@@ -0,0 +1,151 @@
+import { Directive, HostListener } from '@angular/core';
+import { PoTooltipBaseDirective } from './po-tooltip-base.directive';
+import { PoTooltipControlPositionService } from './po-tooltip-control-position.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./po-tooltip-control-position.service";
+/**
+ * @docsExtends PoTooltipBaseDirective
+ *
+ * @example
+ *
+ * <example name="po-tooltip-basic" title="PO Tooltip Basic" >
+ *  <file name="sample-po-tooltip-basic/sample-po-tooltip-basic.component.html"> </file>
+ *  <file name="sample-po-tooltip-basic/sample-po-tooltip-basic.component.ts"> </file>
+ * </example>
+ *
+ * <example name="po-tooltip-labs" title="PO Tooltip Labs" >
+ *  <file name="sample-po-tooltip-labs/sample-po-tooltip-labs.component.html"> </file>
+ *  <file name="sample-po-tooltip-labs/sample-po-tooltip-labs.component.ts"> </file>
+ * </example>
+ *
+ * <example name="po-tooltip-new-user" title="PO Tooltip - New User" >
+ *  <file name="sample-po-tooltip-new-user/sample-po-tooltip-new-user.component.html"> </file>
+ *  <file name="sample-po-tooltip-new-user/sample-po-tooltip-new-user.component.ts"> </file>
+ * </example>
+ *
+ */
+export class PoTooltipDirective extends PoTooltipBaseDirective {
+    constructor(elementRef, renderer, poControlPosition) {
+        super();
+        this.elementRef = elementRef;
+        this.renderer = renderer;
+        this.poControlPosition = poControlPosition;
+        this.tooltipOffset = 8;
+    }
+    onMouseEnter() {
+        if (!this.displayTooltip) {
+            this.addTooltipAction();
+        }
+    }
+    onMouseLeave() {
+        if (!this.displayTooltip) {
+            this.removeTooltipAction();
+        }
+    }
+    ngOnInit() {
+        this.initScrollEventListenerFunction();
+    }
+    addTooltipAction() {
+        setTimeout(() => {
+            if (this.tooltip) {
+                this.tooltipContent ? this.showTooltip() : this.createTooltip();
+                this.removeArrow(this.arrowDirection);
+                this.poControlPosition.adjustPosition(this.tooltipPosition);
+                this.arrowDirection = this.poControlPosition.getArrowDirection();
+                this.addArrow(this.arrowDirection);
+                this.lastTooltipText = this.tooltip;
+            }
+        });
+    }
+    removeTooltipAction() {
+        // necessita do timeout para conseguir adicionar ".po-invisible", pois quando tem alguns elementos
+        // próximos com tooltips e ficar passando o mouse em cima, os mesmos não estavam ficando invisiveis.
+        setTimeout(() => {
+            if (this.appendInBody && this.tooltipContent) {
+                this.renderer.removeChild(document.body, this.tooltipContent);
+                this.tooltipContent = undefined;
+            }
+            else {
+                this.hideTooltip();
+            }
+        });
+    }
+    addArrow(arrowDirection) {
+        this.renderer.addClass(this.divArrow, `po-arrow-${arrowDirection}`);
+    }
+    addScrollEventListener() {
+        window.addEventListener('scroll', this.eventListenerFunction, true);
+    }
+    // Monta a estrutura do tooltip
+    createTooltip() {
+        this.tooltipContent = this.renderer.createElement('div');
+        this.renderer.addClass(this.tooltipContent, 'po-tooltip');
+        this.divArrow = this.renderer.createElement('div');
+        this.renderer.addClass(this.divArrow, 'po-tooltip-arrow');
+        this.divContent = this.renderer.createElement('div');
+        this.renderer.addClass(this.divContent, 'po-tooltip-content');
+        this.textContent = this.renderer.createText(this.tooltip);
+        this.renderer.appendChild(this.divContent, this.textContent);
+        this.renderer.appendChild(this.tooltipContent, this.divArrow);
+        this.renderer.appendChild(this.tooltipContent, this.divContent);
+        const parentTarget = this.appendInBody ? document.body : this.elementRef.nativeElement;
+        this.renderer.appendChild(parentTarget, this.tooltipContent);
+        this.poControlPosition.setElements(this.tooltipContent, this.tooltipOffset, this.elementRef);
+        this.addScrollEventListener();
+    }
+    initScrollEventListenerFunction() {
+        this.eventListenerFunction = () => {
+            if (!this.isHidden) {
+                setTimeout(() => {
+                    this.poControlPosition.adjustPosition(this.tooltipPosition);
+                });
+            }
+        };
+    }
+    hideTooltip() {
+        if (this.tooltipContent) {
+            this.renderer.addClass(this.tooltipContent, 'po-invisible');
+            this.isHidden = true;
+            this.removeScrollEventListener();
+        }
+    }
+    removeArrow(arrowDirection) {
+        if (this.elementRef.nativeElement.querySelector(`.po-arrow-${arrowDirection}`)) {
+            this.renderer.removeClass(this.divArrow, `po-arrow-${arrowDirection}`);
+        }
+    }
+    removeScrollEventListener() {
+        window.removeEventListener('scroll', this.eventListenerFunction, true);
+    }
+    showTooltip() {
+        this.renderer.removeClass(this.tooltipContent, 'po-invisible');
+        this.updateTextContent();
+        this.isHidden = false;
+        this.addScrollEventListener();
+    }
+    updateTextContent() {
+        if (this.lastTooltipText !== this.tooltip) {
+            this.renderer.removeChild(this.divContent, this.textContent);
+            this.textContent = this.renderer.createText(this.tooltip);
+            this.renderer.appendChild(this.divContent, this.textContent);
+        }
+    }
+}
+PoTooltipDirective.ɵfac = function PoTooltipDirective_Factory(t) { return new (t || PoTooltipDirective)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.Renderer2), i0.ɵɵdirectiveInject(i1.PoTooltipControlPositionService)); };
+PoTooltipDirective.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PoTooltipDirective, selectors: [["", "p-tooltip", ""]], hostBindings: function PoTooltipDirective_HostBindings(rf, ctx) { if (rf & 1) {
+        i0.ɵɵlistener("mouseenter", function PoTooltipDirective_mouseenter_HostBindingHandler() { return ctx.onMouseEnter(); })("mouseleave", function PoTooltipDirective_mouseleave_HostBindingHandler() { return ctx.onMouseLeave(); });
+    } }, features: [i0.ɵɵProvidersFeature([PoTooltipControlPositionService]), i0.ɵɵInheritDefinitionFeature] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoTooltipDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[p-tooltip]',
+                providers: [PoTooltipControlPositionService]
+            }]
+    }], function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.PoTooltipControlPositionService }]; }, { onMouseEnter: [{
+            type: HostListener,
+            args: ['mouseenter']
+        }], onMouseLeave: [{
+            type: HostListener,
+            args: ['mouseleave']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-tooltip.directive.js","sourceRoot":"","sources":["../../../../../../projects/ui/src/lib/directives/po-tooltip/po-tooltip.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, HostListener, OnInit, Renderer2 } from '@angular/core';\n\nimport { PoTooltipBaseDirective } from './po-tooltip-base.directive';\nimport { PoTooltipControlPositionService } from './po-tooltip-control-position.service';\n\n/**\n * @docsExtends PoTooltipBaseDirective\n *\n * @example\n *\n * <example name=\"po-tooltip-basic\" title=\"PO Tooltip Basic\" >\n *  <file name=\"sample-po-tooltip-basic/sample-po-tooltip-basic.component.html\"> </file>\n *  <file name=\"sample-po-tooltip-basic/sample-po-tooltip-basic.component.ts\"> </file>\n * </example>\n *\n * <example name=\"po-tooltip-labs\" title=\"PO Tooltip Labs\" >\n *  <file name=\"sample-po-tooltip-labs/sample-po-tooltip-labs.component.html\"> </file>\n *  <file name=\"sample-po-tooltip-labs/sample-po-tooltip-labs.component.ts\"> </file>\n * </example>\n *\n * <example name=\"po-tooltip-new-user\" title=\"PO Tooltip - New User\" >\n *  <file name=\"sample-po-tooltip-new-user/sample-po-tooltip-new-user.component.html\"> </file>\n *  <file name=\"sample-po-tooltip-new-user/sample-po-tooltip-new-user.component.ts\"> </file>\n * </example>\n *\n */\n@Directive({\n  selector: '[p-tooltip]',\n  providers: [PoTooltipControlPositionService]\n})\nexport class PoTooltipDirective extends PoTooltipBaseDirective implements OnInit {\n  private arrowDirection: string;\n  private divArrow;\n  private divContent;\n  private isHidden: boolean;\n  private lastTooltipText: string;\n  private textContent;\n  private tooltipOffset: number = 8;\n\n  private eventListenerFunction: () => void;\n\n  constructor(\n    private elementRef: ElementRef,\n    private renderer: Renderer2,\n    private poControlPosition: PoTooltipControlPositionService\n  ) {\n    super();\n  }\n\n  @HostListener('mouseenter') onMouseEnter() {\n    if (!this.displayTooltip) {\n      this.addTooltipAction();\n    }\n  }\n\n  @HostListener('mouseleave') onMouseLeave() {\n    if (!this.displayTooltip) {\n      this.removeTooltipAction();\n    }\n  }\n\n  ngOnInit() {\n    this.initScrollEventListenerFunction();\n  }\n\n  protected addTooltipAction() {\n    setTimeout(() => {\n      if (this.tooltip) {\n        this.tooltipContent ? this.showTooltip() : this.createTooltip();\n\n        this.removeArrow(this.arrowDirection);\n\n        this.poControlPosition.adjustPosition(this.tooltipPosition);\n        this.arrowDirection = this.poControlPosition.getArrowDirection();\n\n        this.addArrow(this.arrowDirection);\n\n        this.lastTooltipText = this.tooltip;\n      }\n    });\n  }\n\n  protected removeTooltipAction() {\n    // necessita do timeout para conseguir adicionar \".po-invisible\", pois quando tem alguns elementos\n    // próximos com tooltips e ficar passando o mouse em cima, os mesmos não estavam ficando invisiveis.\n    setTimeout(() => {\n      if (this.appendInBody && this.tooltipContent) {\n        this.renderer.removeChild(document.body, this.tooltipContent);\n        this.tooltipContent = undefined;\n      } else {\n        this.hideTooltip();\n      }\n    });\n  }\n\n  private addArrow(arrowDirection) {\n    this.renderer.addClass(this.divArrow, `po-arrow-${arrowDirection}`);\n  }\n\n  private addScrollEventListener() {\n    window.addEventListener('scroll', this.eventListenerFunction, true);\n  }\n\n  // Monta a estrutura do tooltip\n  private createTooltip() {\n    this.tooltipContent = this.renderer.createElement('div');\n    this.renderer.addClass(this.tooltipContent, 'po-tooltip');\n\n    this.divArrow = this.renderer.createElement('div');\n    this.renderer.addClass(this.divArrow, 'po-tooltip-arrow');\n\n    this.divContent = this.renderer.createElement('div');\n    this.renderer.addClass(this.divContent, 'po-tooltip-content');\n\n    this.textContent = this.renderer.createText(this.tooltip);\n\n    this.renderer.appendChild(this.divContent, this.textContent);\n    this.renderer.appendChild(this.tooltipContent, this.divArrow);\n    this.renderer.appendChild(this.tooltipContent, this.divContent);\n\n    const parentTarget = this.appendInBody ? document.body : this.elementRef.nativeElement;\n    this.renderer.appendChild(parentTarget, this.tooltipContent);\n\n    this.poControlPosition.setElements(this.tooltipContent, this.tooltipOffset, this.elementRef);\n\n    this.addScrollEventListener();\n  }\n\n  private initScrollEventListenerFunction() {\n    this.eventListenerFunction = () => {\n      if (!this.isHidden) {\n        setTimeout(() => {\n          this.poControlPosition.adjustPosition(this.tooltipPosition);\n        });\n      }\n    };\n  }\n\n  private hideTooltip() {\n    if (this.tooltipContent) {\n      this.renderer.addClass(this.tooltipContent, 'po-invisible');\n      this.isHidden = true;\n\n      this.removeScrollEventListener();\n    }\n  }\n\n  private removeArrow(arrowDirection) {\n    if (this.elementRef.nativeElement.querySelector(`.po-arrow-${arrowDirection}`)) {\n      this.renderer.removeClass(this.divArrow, `po-arrow-${arrowDirection}`);\n    }\n  }\n\n  private removeScrollEventListener() {\n    window.removeEventListener('scroll', this.eventListenerFunction, true);\n  }\n\n  private showTooltip() {\n    this.renderer.removeClass(this.tooltipContent, 'po-invisible');\n    this.updateTextContent();\n    this.isHidden = false;\n\n    this.addScrollEventListener();\n  }\n\n  private updateTextContent() {\n    if (this.lastTooltipText !== this.tooltip) {\n      this.renderer.removeChild(this.divContent, this.textContent);\n      this.textContent = this.renderer.createText(this.tooltip);\n      this.renderer.appendChild(this.divContent, this.textContent);\n    }\n  }\n}\n"]}

package/esm2020/lib/directives/po-tooltip/po-tooltip.module.mjs

@@ -0,0 +1,24 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { PoTooltipDirective } from './po-tooltip.directive';
+import * as i0 from "@angular/core";
+/**
+ * @description
+ *
+ * Módulo da diretiva Po-Tooltip.
+ */
+export class PoTooltipModule {
+}
+PoTooltipModule.ɵfac = function PoTooltipModule_Factory(t) { return new (t || PoTooltipModule)(); };
+PoTooltipModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: PoTooltipModule });
+PoTooltipModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [[CommonModule]] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoTooltipModule, [{
+        type: NgModule,
+        args: [{
+                imports: [CommonModule],
+                declarations: [PoTooltipDirective],
+                exports: [PoTooltipDirective]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(PoTooltipModule, { declarations: [PoTooltipDirective], imports: [CommonModule], exports: [PoTooltipDirective] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tdG9vbHRpcC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS9zcmMvbGliL2RpcmVjdGl2ZXMvcG8tdG9vbHRpcC9wby10b29sdGlwLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6QyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQzs7QUFFNUQ7Ozs7R0FJRztBQU1ILE1BQU0sT0FBTyxlQUFlOzs4RUFBZixlQUFlO2lFQUFmLGVBQWU7cUVBSmpCLENBQUMsWUFBWSxDQUFDO3VGQUlaLGVBQWU7Y0FMM0IsUUFBUTtlQUFDO2dCQUNSLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztnQkFDdkIsWUFBWSxFQUFFLENBQUMsa0JBQWtCLENBQUM7Z0JBQ2xDLE9BQU8sRUFBRSxDQUFDLGtCQUFrQixDQUFDO2FBQzlCOzt3RkFDWSxlQUFlLG1CQUhYLGtCQUFrQixhQUR2QixZQUFZLGFBRVosa0JBQWtCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFBvVG9vbHRpcERpcmVjdGl2ZSB9IGZyb20gJy4vcG8tdG9vbHRpcC5kaXJlY3RpdmUnO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvblxuICpcbiAqIE3Ds2R1bG8gZGEgZGlyZXRpdmEgUG8tVG9vbHRpcC5cbiAqL1xuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV0sXG4gIGRlY2xhcmF0aW9uczogW1BvVG9vbHRpcERpcmVjdGl2ZV0sXG4gIGV4cG9ydHM6IFtQb1Rvb2x0aXBEaXJlY3RpdmVdXG59KVxuZXhwb3J0IGNsYXNzIFBvVG9vbHRpcE1vZHVsZSB7fVxuIl19

package/esm2020/lib/guards/guards.module.mjs

@@ -0,0 +1,18 @@
+import { NgModule } from '@angular/core';
+import * as i0 from "@angular/core";
+export class PoGuardsModule {
+}
+PoGuardsModule.ɵfac = function PoGuardsModule_Factory(t) { return new (t || PoGuardsModule)(); };
+PoGuardsModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: PoGuardsModule });
+PoGuardsModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [], imports: [[]] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoGuardsModule, [{
+        type: NgModule,
+        args: [{
+                declarations: [],
+                imports: [],
+                exports: [],
+                providers: [],
+                bootstrap: []
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3VhcmRzLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3VpL3NyYy9saWIvZ3VhcmRzL2d1YXJkcy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFTekMsTUFBTSxPQUFPLGNBQWM7OzRFQUFkLGNBQWM7Z0VBQWQsY0FBYztxRUFIZCxFQUFFLFlBRkosRUFBRTt1RkFLQSxjQUFjO2NBUDFCLFFBQVE7ZUFBQztnQkFDUixZQUFZLEVBQUUsRUFBRTtnQkFDaEIsT0FBTyxFQUFFLEVBQUU7Z0JBQ1gsT0FBTyxFQUFFLEVBQUU7Z0JBQ1gsU0FBUyxFQUFFLEVBQUU7Z0JBQ2IsU0FBUyxFQUFFLEVBQUU7YUFDZCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW10sXG4gIGltcG9ydHM6IFtdLFxuICBleHBvcnRzOiBbXSxcbiAgcHJvdmlkZXJzOiBbXSxcbiAgYm9vdHN0cmFwOiBbXVxufSlcbmV4cG9ydCBjbGFzcyBQb0d1YXJkc01vZHVsZSB7fVxuIl19

package/esm2020/lib/interceptors/interceptors.module.mjs

@@ -0,0 +1,21 @@
+import { NgModule } from '@angular/core';
+import { PoHttpInterceptorModule } from './po-http-interceptor/po-http-interceptor.module';
+import { PoHttpRequestModule } from './po-http-request/po-http-request.module';
+import * as i0 from "@angular/core";
+export class PoInterceptorsModule {
+}
+PoInterceptorsModule.ɵfac = function PoInterceptorsModule_Factory(t) { return new (t || PoInterceptorsModule)(); };
+PoInterceptorsModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: PoInterceptorsModule });
+PoInterceptorsModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [], imports: [[PoHttpInterceptorModule, PoHttpRequestModule], PoHttpInterceptorModule, PoHttpRequestModule] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoInterceptorsModule, [{
+        type: NgModule,
+        args: [{
+                declarations: [],
+                imports: [PoHttpInterceptorModule, PoHttpRequestModule],
+                exports: [PoHttpInterceptorModule, PoHttpRequestModule],
+                providers: [],
+                bootstrap: []
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(PoInterceptorsModule, { imports: [PoHttpInterceptorModule, PoHttpRequestModule], exports: [PoHttpInterceptorModule, PoHttpRequestModule] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJjZXB0b3JzLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3VpL3NyYy9saWIvaW50ZXJjZXB0b3JzL2ludGVyY2VwdG9ycy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6QyxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxrREFBa0QsQ0FBQztBQUMzRixPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSwwQ0FBMEMsQ0FBQzs7QUFTL0UsTUFBTSxPQUFPLG9CQUFvQjs7d0ZBQXBCLG9CQUFvQjtzRUFBcEIsb0JBQW9COzJFQUhwQixFQUFFLFlBRkosQ0FBQyx1QkFBdUIsRUFBRSxtQkFBbUIsQ0FBQyxFQUM3Qyx1QkFBdUIsRUFBRSxtQkFBbUI7dUZBSTNDLG9CQUFvQjtjQVBoQyxRQUFRO2VBQUM7Z0JBQ1IsWUFBWSxFQUFFLEVBQUU7Z0JBQ2hCLE9BQU8sRUFBRSxDQUFDLHVCQUF1QixFQUFFLG1CQUFtQixDQUFDO2dCQUN2RCxPQUFPLEVBQUUsQ0FBQyx1QkFBdUIsRUFBRSxtQkFBbUIsQ0FBQztnQkFDdkQsU0FBUyxFQUFFLEVBQUU7Z0JBQ2IsU0FBUyxFQUFFLEVBQUU7YUFDZDs7d0ZBQ1ksb0JBQW9CLGNBTHJCLHVCQUF1QixFQUFFLG1CQUFtQixhQUM1Qyx1QkFBdUIsRUFBRSxtQkFBbUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBQb0h0dHBJbnRlcmNlcHRvck1vZHVsZSB9IGZyb20gJy4vcG8taHR0cC1pbnRlcmNlcHRvci9wby1odHRwLWludGVyY2VwdG9yLm1vZHVsZSc7XG5pbXBvcnQgeyBQb0h0dHBSZXF1ZXN0TW9kdWxlIH0gZnJvbSAnLi9wby1odHRwLXJlcXVlc3QvcG8taHR0cC1yZXF1ZXN0Lm1vZHVsZSc7XG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW10sXG4gIGltcG9ydHM6IFtQb0h0dHBJbnRlcmNlcHRvck1vZHVsZSwgUG9IdHRwUmVxdWVzdE1vZHVsZV0sXG4gIGV4cG9ydHM6IFtQb0h0dHBJbnRlcmNlcHRvck1vZHVsZSwgUG9IdHRwUmVxdWVzdE1vZHVsZV0sXG4gIHByb3ZpZGVyczogW10sXG4gIGJvb3RzdHJhcDogW11cbn0pXG5leHBvcnQgY2xhc3MgUG9JbnRlcmNlcHRvcnNNb2R1bGUge31cbiJdfQ==