@po-ui/ng-components 5.22.3 → 6.2.0

package/esm2020/lib/services/po-control-position/po-control-position.service.mjs

@@ -0,0 +1,364 @@
+import { ElementRef, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * @docsPrivate
+ * @description
+ *
+ * Serviço responsável por gerenciar as posições de um elemento em relação a um elemento alvo. Ele pode receber as
+ * seguintes posições:
+ *
+ * - `right`: Posiciona o elemento no lado direito do componente alvo.
+ * - `right-bottom`: Posiciona o elemento no lado direito inferior do componente alvo.
+ * - `right-top`: Posiciona o elemento no lado direito superior do componente alvo.
+ * - `bottom`: Posiciona o elemento abaixo do componente alvo.
+ * - `bottom-left`: Posiciona o elemento abaixo e à esquerda do componente alvo.
+ * - `bottom-right`: Posiciona o elemento abaixo e à direita do componente alvo.
+ * - `left`: Posiciona o elemento no lado esquerdo do componente alvo.
+ * - `left-top`: Posiciona o elemento no lado esquerdo superior do componente alvo.
+ * - `left-bottom`: Posiciona o elemento no lado esquerdo inferior do componente alvo.
+ * - `top`: Posiciona o elemento acima do componente alvo.
+ * - `top-right`: Posiciona o elemento acima e à direita do componente alvo.
+ * - `top-left`: Posiciona o elemento acima e à esquerda do componente alvo.
+ *
+ * Caso o elemento não caiba na tela na posição indicada ele será rotacionado automaticamente para se adequar,
+ * inicialmente no lado definido como padrão e em seguida seguindo o sentido horário.
+ */
+const poControlPositionSidesDefault = [
+    'bottom',
+    'bottom-left',
+    'bottom-right',
+    'left',
+    'left-top',
+    'left-bottom',
+    'top',
+    'top-right',
+    'top-left',
+    'right',
+    'right-bottom',
+    'right-top'
+];
+export class PoControlPositionService {
+    constructor() {
+        this.differenceDiagonalToWidthArrow = 3;
+        this.isSetElementWidth = false;
+        // offset da seta em relação ao canto do componente
+        this.offsetArrow = 12;
+    }
+    /**
+     * @description Ajusta a posição do elemento, caso não couber em tela irá para próxima posição.
+     *
+     * @param value posição para exibição do elemento
+     */
+    adjustPosition(value) {
+        const position = value || 'bottom';
+        this.elementPosition(position);
+        this.customPositions && this.customPositions.length
+            ? this.adjustCustomPosition(position)
+            : this.adjustDefaultPosition(position);
+    }
+    /**
+     * @description Retorna a direção da seta, conforme a posição do elemento.
+     */
+    getArrowDirection() {
+        return this.arrowDirection;
+    }
+    /**
+     * @description Método responsável por definir as propriedades utilizadas para exibir o elemento na posição correta.
+     *
+     * @param element elemento que será exibido
+     * @param elementOffset offSet do elemento
+     * @param targetElement elemento de onde deve partir a exibição
+     * @param customPositions posições que sobrescreve as posições padrões
+     * @param isSetElementWidth indica se deve definir o tamanho do elemento a ser exibido, caso for verdadeiro será igual do targetElement
+     * @param isCornerAligned indica se o elemento filho será alinhado nos cantos do elemneto pai.
+     */
+    setElements(element, elementOffset, targetElement, customPositions, isSetElementWidth = false, isCornerAligned = false) {
+        this.element = element instanceof ElementRef ? element.nativeElement : element;
+        this.targetElement = targetElement instanceof ElementRef ? targetElement.nativeElement : targetElement;
+        this.elementOffset = elementOffset;
+        this.customPositions = customPositions;
+        this.isSetElementWidth = isSetElementWidth;
+        this.isCornerAligned = isCornerAligned;
+    }
+    adjustCustomPosition(position) {
+        const positionLength = this.customPositions.length;
+        let sidesCount = 0;
+        while (sidesCount++ < positionLength) {
+            if (this.overflowAllSides(position)) {
+                position = this.nextPosition(position, this.customPositions);
+                this.elementPosition(position);
+            }
+        }
+    }
+    adjustDefaultPosition(position) {
+        const mainPositions = this.getMainPositions();
+        const mainPositionLength = mainPositions.length;
+        let mainSidesCount = 0;
+        while (mainSidesCount++ < mainPositionLength) {
+            const mainPosition = this.getMainPosition(position);
+            this.elementPosition(position);
+            if (this.overflowMain(mainPosition)) {
+                position = this.nextPosition(mainPosition, mainPositions);
+                continue;
+            }
+            else if (this.overflowAllSides(position)) {
+                this.verifySubPositions(position);
+                return;
+            }
+            return;
+        }
+    }
+    elementPosition(position) {
+        this.isCornerAligned ? this.setAlignedElementPosition(position) : this.setElementPosition(position);
+    }
+    getMainPosition(position) {
+        return position.indexOf('-') > -1 ? position.substring(0, position.indexOf('-')) : position;
+    }
+    getMainPositions() {
+        const defaultMainPositions = ['top', 'right', 'bottom', 'left'];
+        return this.customPositions && this.customPositions.length
+            ? this.getMainPositionsByCustomPositions(this.customPositions)
+            : defaultMainPositions;
+    }
+    getMainPositionsByCustomPositions(customPositions) {
+        const mainPositions = [];
+        const customPositionsLength = customPositions.length;
+        for (let i = 0; i < customPositionsLength; i++) {
+            const position = customPositions[i];
+            const mainPosition = this.getMainPosition(position);
+            if (!mainPositions.includes(mainPosition)) {
+                mainPositions.push(mainPosition);
+            }
+        }
+        return mainPositions;
+    }
+    getOverflows() {
+        const sizesAndPositions = this.getSizesAndPositions();
+        return {
+            right: sizesAndPositions.element.right > sizesAndPositions.window.innerWidth,
+            top: sizesAndPositions.element.top <= 0,
+            left: sizesAndPositions.element.left <= 0,
+            bottom: sizesAndPositions.element.bottom > sizesAndPositions.window.innerHeight
+        };
+    }
+    getSizesAndPositions() {
+        return {
+            window: {
+                scrollY: window.scrollY,
+                scrollX: window.scrollX,
+                innerWidth: window.innerWidth,
+                innerHeight: window.innerHeight
+            },
+            element: this.element.getBoundingClientRect(),
+            target: this.targetElement ? this.targetElement.getBoundingClientRect() : { top: 0, bottom: 0, right: 0, left: 0 }
+        };
+    }
+    nextPosition(position, positions = []) {
+        const index = positions.indexOf(position);
+        const nextIndex = index + 1;
+        if (index > -1 && nextIndex < positions.length) {
+            return positions[nextIndex];
+        }
+        else {
+            return positions[0];
+        }
+    }
+    overflowAllSides(position) {
+        const overflows = this.getOverflows();
+        switch (position) {
+            case 'top':
+                return overflows.top || overflows.right || overflows.left;
+            case 'top-right':
+                return overflows.top || overflows.right || overflows.left;
+            case 'top-left':
+                return overflows.top || overflows.left || overflows.right;
+            case 'right':
+                return overflows.right || overflows.top || overflows.bottom;
+            case 'right-top':
+                return overflows.right || overflows.top;
+            case 'right-bottom':
+                return overflows.right || overflows.bottom;
+            case 'bottom':
+                return overflows.bottom || overflows.right || overflows.left;
+            case 'bottom-right':
+                return overflows.bottom || overflows.right || overflows.left;
+            case 'bottom-left':
+                return overflows.bottom || overflows.left || overflows.right;
+            case 'left':
+                return overflows.left || overflows.top || overflows.bottom;
+            case 'left-top':
+                return overflows.left || overflows.top;
+            case 'left-bottom':
+                return overflows.left || overflows.bottom;
+        }
+    }
+    overflowMain(position) {
+        const overflows = this.getOverflows();
+        switch (position) {
+            case 'top':
+                return overflows.top;
+            case 'right':
+                return overflows.right;
+            case 'bottom':
+                return overflows.bottom;
+            case 'left':
+                return overflows.left;
+        }
+    }
+    setAlignedArrowDirection(elementPosition) {
+        switch (elementPosition) {
+            case 'top-left':
+                return 'bottom-left';
+            case 'top-right':
+                return 'bottom-right';
+            case 'bottom-right':
+                return 'top-right';
+            case 'bottom-left':
+                return 'top-left';
+        }
+    }
+    setAlignedBottomPositions(displacement, sizesAndPositions) {
+        this.element.style.top = sizesAndPositions.target.bottom + this.elementOffset + 'px';
+        this.element.style.left = sizesAndPositions.target.left - displacement + 'px';
+    }
+    setAlignedElementPosition(position) {
+        this.setElementWidth();
+        const sizesAndPositions = this.getSizesAndPositions();
+        switch (position) {
+            case 'bottom-left':
+                this.setAlignedBottomPositions(0, sizesAndPositions);
+                break;
+            case 'bottom-right':
+                this.setAlignedBottomPositions(sizesAndPositions.element.width - sizesAndPositions.target.width, sizesAndPositions);
+                break;
+            case 'top-left':
+                this.setAlignedTopPositions(0, sizesAndPositions);
+                break;
+            case 'top-right':
+                this.setAlignedTopPositions(sizesAndPositions.element.width - sizesAndPositions.target.width, sizesAndPositions);
+                break;
+        }
+        this.arrowDirection = this.setAlignedArrowDirection(position);
+    }
+    setAlignedTopPositions(displacement, sizesAndPositions) {
+        this.element.style.top =
+            sizesAndPositions.target.top - sizesAndPositions.element.height - this.elementOffset + 'px';
+        this.element.style.left = sizesAndPositions.target.left - displacement + 'px';
+    }
+    setArrowDirection(elementPosition) {
+        switch (elementPosition) {
+            case 'top':
+                return 'bottom';
+            case 'top-left':
+                return 'bottom-right';
+            case 'top-right':
+                return 'bottom-left';
+            case 'right':
+                return 'left';
+            case 'right-top':
+                return 'left-bottom';
+            case 'right-bottom':
+                return 'left-top';
+            case 'bottom':
+                return 'top';
+            case 'bottom-right':
+                return 'top-left';
+            case 'bottom-left':
+                return 'top-right';
+            case 'left':
+                return 'right';
+            case 'left-bottom':
+                return 'right-top';
+            case 'left-top':
+                return 'right-bottom';
+        }
+    }
+    setBottomPositions(displacement, sizesAndPositions) {
+        this.element.style.top = sizesAndPositions.target.bottom + this.elementOffset + 'px';
+        this.element.style.left = sizesAndPositions.target.left + sizesAndPositions.target.width / 2 - displacement + 'px';
+    }
+    setElementPosition(position) {
+        this.setElementWidth();
+        const sizesAndPositions = this.getSizesAndPositions();
+        switch (position) {
+            case 'top':
+                this.setTopPositions(sizesAndPositions.element.width / 2, sizesAndPositions);
+                break;
+            case 'top-left':
+                this.setTopPositions(sizesAndPositions.element.width - this.offsetArrow - this.differenceDiagonalToWidthArrow, sizesAndPositions);
+                break;
+            case 'top-right':
+                this.setTopPositions(this.offsetArrow + this.differenceDiagonalToWidthArrow, sizesAndPositions);
+                break;
+            case 'right':
+                this.setRightPositions(sizesAndPositions.element.height / 2, sizesAndPositions);
+                break;
+            case 'right-top':
+                this.setRightPositions(sizesAndPositions.element.height - this.offsetArrow - this.differenceDiagonalToWidthArrow, sizesAndPositions);
+                break;
+            case 'right-bottom':
+                this.setRightPositions(this.offsetArrow, sizesAndPositions);
+                break;
+            case 'bottom':
+                this.setBottomPositions(sizesAndPositions.element.width / 2, sizesAndPositions);
+                break;
+            case 'bottom-right':
+                this.setBottomPositions(this.offsetArrow + this.differenceDiagonalToWidthArrow, sizesAndPositions);
+                break;
+            case 'bottom-left':
+                this.setBottomPositions(sizesAndPositions.element.width - this.offsetArrow - this.differenceDiagonalToWidthArrow, sizesAndPositions);
+                break;
+            case 'left':
+                this.setLeftPositions(sizesAndPositions.element.height / 2, sizesAndPositions);
+                break;
+            case 'left-bottom':
+                this.setLeftPositions(this.offsetArrow, sizesAndPositions);
+                break;
+            case 'left-top':
+                this.setLeftPositions(sizesAndPositions.element.height - this.offsetArrow, sizesAndPositions);
+                break;
+        }
+        this.arrowDirection = this.setArrowDirection(position);
+    }
+    setElementWidth() {
+        if (this.isSetElementWidth && this.targetElement) {
+            this.element.style.width = `${this.targetElement.clientWidth}px`;
+        }
+    }
+    setLeftPositions(displacement, sizesAndPositions) {
+        this.element.style.top = sizesAndPositions.target.top - displacement + sizesAndPositions.target.height / 2 + 'px';
+        this.element.style.left =
+            sizesAndPositions.target.left - sizesAndPositions.element.width - this.elementOffset + 'px';
+    }
+    setRightPositions(displacement, sizesAndPositions) {
+        this.element.style.top = sizesAndPositions.target.top - displacement + sizesAndPositions.target.height / 2 + 'px';
+        this.element.style.left = sizesAndPositions.target.right + this.elementOffset + 'px';
+    }
+    setTopPositions(displacement, sizesAndPositions) {
+        this.element.style.top =
+            sizesAndPositions.target.top - sizesAndPositions.element.height - this.elementOffset + 'px';
+        this.element.style.left = sizesAndPositions.target.left + sizesAndPositions.target.width / 2 - displacement + 'px';
+    }
+    verifySubPositions(position) {
+        if (position.indexOf('-') > -1) {
+            position = position.substring(0, position.indexOf('-'));
+            this.elementPosition(position);
+        }
+        let align = 0;
+        while (align++ < 3) {
+            if (this.overflowAllSides(position)) {
+                position = this.nextPosition(position, poControlPositionSidesDefault);
+                this.elementPosition(position);
+            }
+            else {
+                return null;
+            }
+        }
+    }
+}
+PoControlPositionService.ɵfac = function PoControlPositionService_Factory(t) { return new (t || PoControlPositionService)(); };
+PoControlPositionService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PoControlPositionService, factory: PoControlPositionService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoControlPositionService, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-control-position.service.js","sourceRoot":"","sources":["../../../../../../projects/ui/src/lib/services/po-control-position/po-control-position.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ElementRef, Injectable } from '@angular/core';\n\n/**\n * @docsPrivate\n * @description\n *\n * Serviço responsável por gerenciar as posições de um elemento em relação a um elemento alvo. Ele pode receber as\n * seguintes posições:\n *\n * - `right`: Posiciona o elemento no lado direito do componente alvo.\n * - `right-bottom`: Posiciona o elemento no lado direito inferior do componente alvo.\n * - `right-top`: Posiciona o elemento no lado direito superior do componente alvo.\n * - `bottom`: Posiciona o elemento abaixo do componente alvo.\n * - `bottom-left`: Posiciona o elemento abaixo e à esquerda do componente alvo.\n * - `bottom-right`: Posiciona o elemento abaixo e à direita do componente alvo.\n * - `left`: Posiciona o elemento no lado esquerdo do componente alvo.\n * - `left-top`: Posiciona o elemento no lado esquerdo superior do componente alvo.\n * - `left-bottom`: Posiciona o elemento no lado esquerdo inferior do componente alvo.\n * - `top`: Posiciona o elemento acima do componente alvo.\n * - `top-right`: Posiciona o elemento acima e à direita do componente alvo.\n * - `top-left`: Posiciona o elemento acima e à esquerda do componente alvo.\n *\n * Caso o elemento não caiba na tela na posição indicada ele será rotacionado automaticamente para se adequar,\n * inicialmente no lado definido como padrão e em seguida seguindo o sentido horário.\n */\n\nconst poControlPositionSidesDefault: Array<string> = [\n  'bottom',\n  'bottom-left',\n  'bottom-right',\n  'left',\n  'left-top',\n  'left-bottom',\n  'top',\n  'top-right',\n  'top-left',\n  'right',\n  'right-bottom',\n  'right-top'\n];\n\n@Injectable()\nexport class PoControlPositionService {\n  private arrowDirection: string;\n  private customPositions: Array<string>;\n  private differenceDiagonalToWidthArrow: number = 3;\n  private element: HTMLElement;\n  private elementOffset: number;\n  private isCornerAligned: boolean;\n  private isSetElementWidth: boolean = false;\n  // offset da seta em relação ao canto do componente\n  private offsetArrow: number = 12;\n  private targetElement: HTMLElement;\n\n  /**\n   * @description Ajusta a posição do elemento, caso não couber em tela irá para próxima posição.\n   *\n   * @param value posição para exibição do elemento\n   */\n  adjustPosition(value: string) {\n    const position = value || 'bottom';\n    this.elementPosition(position);\n    this.customPositions && this.customPositions.length\n      ? this.adjustCustomPosition(position)\n      : this.adjustDefaultPosition(position);\n  }\n\n  /**\n   * @description Retorna a direção da seta, conforme a posição do elemento.\n   */\n  getArrowDirection() {\n    return this.arrowDirection;\n  }\n\n  /**\n   * @description Método responsável por definir as propriedades utilizadas para exibir o elemento na posição correta.\n   *\n   * @param element elemento que será exibido\n   * @param elementOffset offSet do elemento\n   * @param targetElement elemento de onde deve partir a exibição\n   * @param customPositions posições que sobrescreve as posições padrões\n   * @param isSetElementWidth indica se deve definir o tamanho do elemento a ser exibido, caso for verdadeiro será igual do targetElement\n   * @param isCornerAligned indica se o elemento filho será alinhado nos cantos do elemneto pai.\n   */\n  setElements(\n    element: ElementRef | HTMLElement,\n    elementOffset: number,\n    targetElement: ElementRef | HTMLElement,\n    customPositions?: Array<string>,\n    isSetElementWidth: boolean = false,\n    isCornerAligned: boolean = false\n  ) {\n    this.element = element instanceof ElementRef ? element.nativeElement : element;\n    this.targetElement = targetElement instanceof ElementRef ? targetElement.nativeElement : targetElement;\n\n    this.elementOffset = elementOffset;\n\n    this.customPositions = customPositions;\n    this.isSetElementWidth = isSetElementWidth;\n    this.isCornerAligned = isCornerAligned;\n  }\n\n  private adjustCustomPosition(position: string) {\n    const positionLength = this.customPositions.length;\n\n    let sidesCount = 0;\n\n    while (sidesCount++ < positionLength) {\n      if (this.overflowAllSides(position)) {\n        position = this.nextPosition(position, this.customPositions);\n        this.elementPosition(position);\n      }\n    }\n  }\n\n  private adjustDefaultPosition(position: string) {\n    const mainPositions = this.getMainPositions();\n    const mainPositionLength = mainPositions.length;\n\n    let mainSidesCount = 0;\n\n    while (mainSidesCount++ < mainPositionLength) {\n      const mainPosition = this.getMainPosition(position);\n      this.elementPosition(position);\n\n      if (this.overflowMain(mainPosition)) {\n        position = this.nextPosition(mainPosition, mainPositions);\n        continue;\n      } else if (this.overflowAllSides(position)) {\n        this.verifySubPositions(position);\n        return;\n      }\n\n      return;\n    }\n  }\n\n  private elementPosition(position: string) {\n    this.isCornerAligned ? this.setAlignedElementPosition(position) : this.setElementPosition(position);\n  }\n\n  private getMainPosition(position: string) {\n    return position.indexOf('-') > -1 ? position.substring(0, position.indexOf('-')) : position;\n  }\n\n  private getMainPositions() {\n    const defaultMainPositions = ['top', 'right', 'bottom', 'left'];\n\n    return this.customPositions && this.customPositions.length\n      ? this.getMainPositionsByCustomPositions(this.customPositions)\n      : defaultMainPositions;\n  }\n\n  private getMainPositionsByCustomPositions(customPositions: Array<string>) {\n    const mainPositions = [];\n    const customPositionsLength = customPositions.length;\n\n    for (let i = 0; i < customPositionsLength; i++) {\n      const position = customPositions[i];\n\n      const mainPosition = this.getMainPosition(position);\n\n      if (!mainPositions.includes(mainPosition)) {\n        mainPositions.push(mainPosition);\n      }\n    }\n\n    return mainPositions;\n  }\n\n  private getOverflows() {\n    const sizesAndPositions = this.getSizesAndPositions();\n\n    return {\n      right: sizesAndPositions.element.right > sizesAndPositions.window.innerWidth,\n      top: sizesAndPositions.element.top <= 0,\n      left: sizesAndPositions.element.left <= 0,\n      bottom: sizesAndPositions.element.bottom > sizesAndPositions.window.innerHeight\n    };\n  }\n\n  private getSizesAndPositions() {\n    return {\n      window: {\n        scrollY: window.scrollY,\n        scrollX: window.scrollX,\n        innerWidth: window.innerWidth,\n        innerHeight: window.innerHeight\n      },\n      element: this.element.getBoundingClientRect(),\n      target: this.targetElement ? this.targetElement.getBoundingClientRect() : { top: 0, bottom: 0, right: 0, left: 0 }\n    };\n  }\n\n  private nextPosition(position: string, positions: Array<string> = []): string {\n    const index = positions.indexOf(position);\n    const nextIndex = index + 1;\n\n    if (index > -1 && nextIndex < positions.length) {\n      return positions[nextIndex];\n    } else {\n      return positions[0];\n    }\n  }\n\n  private overflowAllSides(position: string) {\n    const overflows = this.getOverflows();\n\n    switch (position) {\n      case 'top':\n        return overflows.top || overflows.right || overflows.left;\n      case 'top-right':\n        return overflows.top || overflows.right || overflows.left;\n      case 'top-left':\n        return overflows.top || overflows.left || overflows.right;\n      case 'right':\n        return overflows.right || overflows.top || overflows.bottom;\n      case 'right-top':\n        return overflows.right || overflows.top;\n      case 'right-bottom':\n        return overflows.right || overflows.bottom;\n      case 'bottom':\n        return overflows.bottom || overflows.right || overflows.left;\n      case 'bottom-right':\n        return overflows.bottom || overflows.right || overflows.left;\n      case 'bottom-left':\n        return overflows.bottom || overflows.left || overflows.right;\n      case 'left':\n        return overflows.left || overflows.top || overflows.bottom;\n      case 'left-top':\n        return overflows.left || overflows.top;\n      case 'left-bottom':\n        return overflows.left || overflows.bottom;\n    }\n  }\n\n  private overflowMain(position: string) {\n    const overflows = this.getOverflows();\n\n    switch (position) {\n      case 'top':\n        return overflows.top;\n      case 'right':\n        return overflows.right;\n      case 'bottom':\n        return overflows.bottom;\n      case 'left':\n        return overflows.left;\n    }\n  }\n\n  private setAlignedArrowDirection(elementPosition: string) {\n    switch (elementPosition) {\n      case 'top-left':\n        return 'bottom-left';\n      case 'top-right':\n        return 'bottom-right';\n      case 'bottom-right':\n        return 'top-right';\n      case 'bottom-left':\n        return 'top-left';\n    }\n  }\n\n  private setAlignedBottomPositions(displacement: number, sizesAndPositions) {\n    this.element.style.top = sizesAndPositions.target.bottom + this.elementOffset + 'px';\n    this.element.style.left = sizesAndPositions.target.left - displacement + 'px';\n  }\n\n  private setAlignedElementPosition(position: string) {\n    this.setElementWidth();\n\n    const sizesAndPositions: any = this.getSizesAndPositions();\n\n    switch (position) {\n      case 'bottom-left':\n        this.setAlignedBottomPositions(0, sizesAndPositions);\n        break;\n      case 'bottom-right':\n        this.setAlignedBottomPositions(\n          sizesAndPositions.element.width - sizesAndPositions.target.width,\n          sizesAndPositions\n        );\n        break;\n      case 'top-left':\n        this.setAlignedTopPositions(0, sizesAndPositions);\n        break;\n      case 'top-right':\n        this.setAlignedTopPositions(\n          sizesAndPositions.element.width - sizesAndPositions.target.width,\n          sizesAndPositions\n        );\n        break;\n    }\n\n    this.arrowDirection = this.setAlignedArrowDirection(position);\n  }\n\n  private setAlignedTopPositions(displacement: number, sizesAndPositions) {\n    this.element.style.top =\n      sizesAndPositions.target.top - sizesAndPositions.element.height - this.elementOffset + 'px';\n    this.element.style.left = sizesAndPositions.target.left - displacement + 'px';\n  }\n\n  private setArrowDirection(elementPosition: string) {\n    switch (elementPosition) {\n      case 'top':\n        return 'bottom';\n      case 'top-left':\n        return 'bottom-right';\n      case 'top-right':\n        return 'bottom-left';\n      case 'right':\n        return 'left';\n      case 'right-top':\n        return 'left-bottom';\n      case 'right-bottom':\n        return 'left-top';\n      case 'bottom':\n        return 'top';\n      case 'bottom-right':\n        return 'top-left';\n      case 'bottom-left':\n        return 'top-right';\n      case 'left':\n        return 'right';\n      case 'left-bottom':\n        return 'right-top';\n      case 'left-top':\n        return 'right-bottom';\n    }\n  }\n\n  private setBottomPositions(displacement: number, sizesAndPositions) {\n    this.element.style.top = sizesAndPositions.target.bottom + this.elementOffset + 'px';\n    this.element.style.left = sizesAndPositions.target.left + sizesAndPositions.target.width / 2 - displacement + 'px';\n  }\n\n  private setElementPosition(position: string) {\n    this.setElementWidth();\n\n    const sizesAndPositions = this.getSizesAndPositions();\n\n    switch (position) {\n      case 'top':\n        this.setTopPositions(sizesAndPositions.element.width / 2, sizesAndPositions);\n        break;\n      case 'top-left':\n        this.setTopPositions(\n          sizesAndPositions.element.width - this.offsetArrow - this.differenceDiagonalToWidthArrow,\n          sizesAndPositions\n        );\n        break;\n      case 'top-right':\n        this.setTopPositions(this.offsetArrow + this.differenceDiagonalToWidthArrow, sizesAndPositions);\n        break;\n      case 'right':\n        this.setRightPositions(sizesAndPositions.element.height / 2, sizesAndPositions);\n        break;\n      case 'right-top':\n        this.setRightPositions(\n          sizesAndPositions.element.height - this.offsetArrow - this.differenceDiagonalToWidthArrow,\n          sizesAndPositions\n        );\n        break;\n      case 'right-bottom':\n        this.setRightPositions(this.offsetArrow, sizesAndPositions);\n        break;\n      case 'bottom':\n        this.setBottomPositions(sizesAndPositions.element.width / 2, sizesAndPositions);\n        break;\n      case 'bottom-right':\n        this.setBottomPositions(this.offsetArrow + this.differenceDiagonalToWidthArrow, sizesAndPositions);\n        break;\n      case 'bottom-left':\n        this.setBottomPositions(\n          sizesAndPositions.element.width - this.offsetArrow - this.differenceDiagonalToWidthArrow,\n          sizesAndPositions\n        );\n        break;\n      case 'left':\n        this.setLeftPositions(sizesAndPositions.element.height / 2, sizesAndPositions);\n        break;\n      case 'left-bottom':\n        this.setLeftPositions(this.offsetArrow, sizesAndPositions);\n        break;\n      case 'left-top':\n        this.setLeftPositions(sizesAndPositions.element.height - this.offsetArrow, sizesAndPositions);\n        break;\n    }\n\n    this.arrowDirection = this.setArrowDirection(position);\n  }\n\n  private setElementWidth() {\n    if (this.isSetElementWidth && this.targetElement) {\n      this.element.style.width = `${this.targetElement.clientWidth}px`;\n    }\n  }\n\n  private setLeftPositions(displacement: number, sizesAndPositions) {\n    this.element.style.top = sizesAndPositions.target.top - displacement + sizesAndPositions.target.height / 2 + 'px';\n    this.element.style.left =\n      sizesAndPositions.target.left - sizesAndPositions.element.width - this.elementOffset + 'px';\n  }\n\n  private setRightPositions(displacement: number, sizesAndPositions) {\n    this.element.style.top = sizesAndPositions.target.top - displacement + sizesAndPositions.target.height / 2 + 'px';\n    this.element.style.left = sizesAndPositions.target.right + this.elementOffset + 'px';\n  }\n\n  private setTopPositions(displacement: number, sizesAndPositions) {\n    this.element.style.top =\n      sizesAndPositions.target.top - sizesAndPositions.element.height - this.elementOffset + 'px';\n    this.element.style.left = sizesAndPositions.target.left + sizesAndPositions.target.width / 2 - displacement + 'px';\n  }\n\n  private verifySubPositions(position: string) {\n    if (position.indexOf('-') > -1) {\n      position = position.substring(0, position.indexOf('-'));\n      this.elementPosition(position);\n    }\n\n    let align = 0;\n    while (align++ < 3) {\n      if (this.overflowAllSides(position)) {\n        position = this.nextPosition(position, poControlPositionSidesDefault);\n        this.elementPosition(position);\n      } else {\n        return null;\n      }\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,3 @@
+export * from './po-date.module';
+export * from './po-date.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS9zcmMvbGliL3NlcnZpY2VzL3BvLWRhdGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLG1CQUFtQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9wby1kYXRlLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL3BvLWRhdGUuc2VydmljZSc7XG4iXX0=

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

@@ -0,0 +1,21 @@
+import { NgModule } from '@angular/core';
+import { PoDateService } from './po-date.service';
+import * as i0 from "@angular/core";
+/**
+ * @description
+ *
+ * Módulo do serviço `po-date`.
+ */
+export class PoDateTimeModule {
+}
+PoDateTimeModule.ɵfac = function PoDateTimeModule_Factory(t) { return new (t || PoDateTimeModule)(); };
+PoDateTimeModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: PoDateTimeModule });
+PoDateTimeModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [PoDateService] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoDateTimeModule, [{
+        type: NgModule,
+        args: [{
+                providers: [PoDateService],
+                bootstrap: []
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tZGF0ZS5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS9zcmMvbGliL3NlcnZpY2VzL3BvLWRhdGUvcG8tZGF0ZS5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7O0FBRWxEOzs7O0dBSUc7QUFLSCxNQUFNLE9BQU8sZ0JBQWdCOztnRkFBaEIsZ0JBQWdCO2tFQUFoQixnQkFBZ0I7dUVBSGhCLENBQUMsYUFBYSxDQUFDO3VGQUdmLGdCQUFnQjtjQUo1QixRQUFRO2VBQUM7Z0JBQ1IsU0FBUyxFQUFFLENBQUMsYUFBYSxDQUFDO2dCQUMxQixTQUFTLEVBQUUsRUFBRTthQUNkIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgUG9EYXRlU2VydmljZSB9IGZyb20gJy4vcG8tZGF0ZS5zZXJ2aWNlJztcblxuLyoqXG4gKiBAZGVzY3JpcHRpb25cbiAqXG4gKiBNw7NkdWxvIGRvIHNlcnZpw6dvIGBwby1kYXRlYC5cbiAqL1xuQE5nTW9kdWxlKHtcbiAgcHJvdmlkZXJzOiBbUG9EYXRlU2VydmljZV0sXG4gIGJvb3RzdHJhcDogW11cbn0pXG5leHBvcnQgY2xhc3MgUG9EYXRlVGltZU1vZHVsZSB7fVxuIl19