@po-ui/ng-components 5.22.1 → 6.1.0

package/esm2020/lib/utils/util.mjs

@@ -0,0 +1,511 @@
+import { poLocales, poLocaleDefault } from '../services/po-language/po-language.constant';
+/**
+ * @deprecated
+ * Utilize o método `getShortBrowserLanguage`.
+ *
+ * @description
+ * Retorna idioma do browser ou o idioma padrão.
+ */
+export function browserLanguage() {
+    return getShortBrowserLanguage();
+}
+/**
+ * Converte e formata os bytes em formato mais legível para o usuário.
+ *
+ * Por exemplo:
+ * - 31457280 em 30 MB.
+ * - 21474836480 em 20 GB.
+ * - 12.5666666 em 12.57 Bytes (duas casas decimais).
+ *
+ * @param bytes {number} Valor em bytes
+ * @param decimals {number} Quantidade de casas decimais que terá após a conversão.
+ */
+export function formatBytes(bytes, decimals = 2) {
+    if (!bytes) {
+        return undefined;
+    }
+    const multiplier = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+    const result = Math.floor(Math.log(bytes) / Math.log(multiplier));
+    decimals = decimals < 0 ? 0 : decimals;
+    return `${parseFloat((bytes / Math.pow(multiplier, result)).toFixed(decimals))} ${sizes[result]}`;
+}
+/**
+ * Retorna o idioma atual do navegador
+ */
+export function getBrowserLanguage() {
+    // navigator.userLanguage is the value for IE10
+    const language = navigator.language || navigator['userLanguage'];
+    const shortLanguage = getShortLanguage(language);
+    return poLocales.includes(shortLanguage) ? language : poLocaleDefault;
+}
+/**
+ * Retorna o idioma do navegador, com somente as duas primeiras letras. Por exemplo: "pt" ou "es".
+ *
+ * Caso o valor retornado pelo navegador não estiver dentro dos idiomas suportados pelo PO,
+ * será retornado a linguagem padrão (poLocaleDefault).
+ */
+export function getShortBrowserLanguage() {
+    return getShortLanguage(getBrowserLanguage());
+}
+/**
+ * Retorna o idioma com somente a abreviação do idioma (duas primeiras letras).
+ * Por exemplo: "pt" ou "es".
+ *
+ * @param language {string} linguagem.
+ *
+ * @returns sigla do idioma padrão {string}.
+ *
+ * @default pt
+ */
+export function getShortLanguage(language) {
+    return (language || poLocaleDefault).toLowerCase().substring(0, 2);
+}
+export function isLanguage(value) {
+    const languageRegex = new RegExp('^[a-z]{2}(-[a-z]{2})?$', 'i');
+    return languageRegex.test(value);
+}
+/* istanbul ignore next */
+export function reloadCurrentPage() {
+    window.location.assign(location.href);
+}
+export function convertToBoolean(val) {
+    if (typeof val === 'string') {
+        val = val.toLowerCase().trim();
+        return val === 'true' || val === 'on' || val === '';
+    }
+    if (typeof val === 'number') {
+        return val === 1;
+    }
+    return !!val;
+}
+export function convertToInt(value, valueDefault) {
+    const validNumber = parseInt(value, 10);
+    const validDefaultValue = parseInt(valueDefault, 10);
+    const defaultValue = validDefaultValue || validDefaultValue === 0 ? validDefaultValue : undefined;
+    return validNumber || validNumber === 0 ? validNumber : defaultValue;
+}
+export function isTypeof(object, type) {
+    return typeof object === type;
+}
+/**
+ *
+ * @param fn Função que será executada dentro do contexto. Podendo ser o nome da função
+ * ou a referência da mesma.
+ *
+ * @param context Contexto do qual a função será executada.
+ */
+export function callFunction(fn, context, param) {
+    if (isTypeof(fn, 'function')) {
+        fn.call(context, param);
+    }
+    else {
+        context[fn](param);
+    }
+}
+export function convertIsoToDate(value, start, end) {
+    if (value) {
+        const day = parseInt(value.substring(8, 10), 10);
+        const month = parseInt(value.substring(5, 7), 10);
+        const year = parseInt(value.substring(0, 4), 10);
+        if (start) {
+            const date = new Date(year, month - 1, day, 0, 0, 0);
+            setYearFrom0To100(date, year);
+            return date;
+        }
+        else if (end) {
+            const date = new Date(year, month - 1, day, 23, 59, 59);
+            setYearFrom0To100(date, year);
+            return date;
+        }
+        else {
+            const milliseconds = Date.parse(value);
+            const timezone = new Date().getTimezoneOffset() * 60000;
+            return new Date(milliseconds + timezone);
+        }
+    }
+}
+export function convertDateToISODate(date) {
+    if (date) {
+        const getMonth = date.getMonth() + 1;
+        const day = date.getDate() < 10 ? '0' + date.getDate() : date.getDate();
+        const month = getMonth < 10 ? '0' + getMonth : getMonth;
+        const year = formatYear(date.getFullYear());
+        return year + '-' + month + '-' + day;
+    }
+    else {
+        return null;
+    }
+}
+export function convertDateToISOExtended(date, time) {
+    if (date) {
+        const getMonth = date.getMonth() + 1;
+        const day = date.getDate() < 10 ? '0' + date.getDate() : date.getDate();
+        const month = getMonth < 10 ? '0' + getMonth : getMonth;
+        const year = formatYear(date.getFullYear());
+        const dateString = date.toString();
+        if (time !== null) {
+            return year + '-' + month + '-' + day + time;
+        }
+        else {
+            return (year +
+                '-' +
+                month +
+                '-' +
+                day +
+                'T' +
+                dateString.substring(16, 24) +
+                dateString.substring(28, 31) +
+                ':' +
+                dateString.substring(31, 33));
+        }
+    }
+    else {
+        return null;
+    }
+}
+/**
+ * Transforma o ano em uma string no formato yyyy e caso o ano seja menor que 1000 preenche com zeros a esquerda.
+ *
+ * @param year Ano
+ */
+export function formatYear(year) {
+    if (year >= 1000) {
+        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}`;
+    }
+}
+// Verifica se o navegador em que está sendo usado é Internet Explorer ou Edge
+export function isIEOrEdge() {
+    const userAgent = window.navigator.userAgent;
+    return /msie\s|trident\/|edge\//i.test(userAgent);
+}
+// Verifica se o navegador em que está sendo usado é Internet Explorer
+export function isIE() {
+    const userAgent = window.navigator.userAgent;
+    return /msie\s|trident/i.test(userAgent);
+}
+// Verifica se o navegador em que está sendo usado é Firefox
+export function isFirefox() {
+    const userAgent = window.navigator.userAgent;
+    return userAgent.toLowerCase().indexOf('firefox') > -1;
+}
+// Verifica qual o dispositivo que está sendo usado
+export function isMobile() {
+    const userAgent = window.navigator.userAgent;
+    return userAgent.match(/Android|webOS|iPhone|iPad|iPod|BlackBerry|Windows Phone/i);
+}
+export function isEquals(value, comparedValue) {
+    return JSON.stringify(value) === JSON.stringify(comparedValue);
+}
+export function isKeyCodeEnter(event) {
+    return event.keyCode === 13 || event.which === 13;
+}
+/**
+ * Caso o ano original da data seja entre 0 e 100 atribui esse valor ao ano, pois o `new Date` do javascript transforma o ano para 190X.
+ *
+ * @param date Data
+ * @param year Ano original
+ */
+export function setYearFrom0To100(date, year) {
+    if (year >= 0 && year < 100) {
+        date.setFullYear(year);
+    }
+}
+export function sortOptionsByProperty(options, property) {
+    options.sort((optionA, optionB) => {
+        optionA = optionA[property].toString().toLowerCase();
+        optionB = optionB[property].toString().toLowerCase();
+        if (optionA < optionB) {
+            return -1;
+        }
+        if (optionA > optionB) {
+            return 1;
+        }
+        return 0;
+    });
+}
+/**
+ * Ordena o campos baseado no valor da propriedade `order`.
+ *
+ * Só serão aceitos valores com números inteiros maiores do que zero para a ordenação.
+ *
+ * Campos sem `order` ou com valores negativos, zerados ou inválidos
+ * receberão o valor default e seguirão o posicionamento dentro do
+ * array.
+ *
+ * @param fields campo que se deseja ordenar.
+ * @param defaultOrdering valor que será utilizado para manter na posição do array.
+ */
+export function sortFields(fields = [], defaultOrdering = -1) {
+    const resultClassification = { fieldAComesFirst: -1, fieldAComesAfter: 1, keepPositions: 0 };
+    const isOrderValid = (order) => isTypeof(order, 'number') && order > 0;
+    const applyDefaultOrdering = (order) => (isOrderValid(order) ? order : defaultOrdering);
+    return fields.sort((fieldA, fieldB) => {
+        const orderA = applyDefaultOrdering(fieldA.order);
+        const orderB = applyDefaultOrdering(fieldB.order);
+        if (orderA === orderB) {
+            return resultClassification.keepPositions;
+        }
+        if (orderA === defaultOrdering) {
+            return resultClassification.fieldAComesAfter;
+        }
+        if (orderB === defaultOrdering) {
+            return resultClassification.fieldAComesFirst;
+        }
+        return orderA - orderB;
+    });
+}
+export function removeDuplicatedOptions(list) {
+    for (let i = 0; i < list.length; i++) {
+        if (i === 0) {
+            continue;
+        }
+        if (list.findIndex(op => op.value === list[i].value) !== i) {
+            list.splice(i, 1);
+            i--;
+        }
+    }
+}
+export function removeUndefinedAndNullOptions(list) {
+    for (let i = 0; i < list.length; i++) {
+        if (list[i].value === undefined || list[i].value === null) {
+            list.splice(i, 1);
+            i--;
+        }
+    }
+}
+export function validValue(value) {
+    return (value !== null && value !== undefined && value !== '') || value === false;
+}
+export function isExternalLink(url) {
+    return url ? url.startsWith('http') : false;
+}
+export function openExternalLink(url) {
+    window.open(url, '_blank');
+}
+export function getFormattedLink(link) {
+    let formattedLink = '';
+    // Retira todos os pontos no começo da URL.
+    if (link) {
+        formattedLink = link.replace(/^(\.)+/g, '');
+    }
+    // Verifica se foi utilizado uma rota que não comece com barra.
+    if (!formattedLink.startsWith('/')) {
+        formattedLink = '/'.concat(formattedLink);
+    }
+    return formattedLink;
+}
+/**
+ * Método responsável por ordenar dois valores.
+ *
+ * @param leftSide Primeiro valor a ser comparado.
+ * @param rightSide Segundo valor a ser comparado.
+ * @param ascending Determina se será em ordem ascendente ou descendente.
+ */
+export function sortValues(leftSide, rightSide, ascending = true) {
+    const left = isTypeof(leftSide, 'string') ? leftSide.toLowerCase() : leftSide;
+    const right = isTypeof(rightSide, 'string') ? rightSide.toLowerCase() : rightSide;
+    const leftIsInvalid = left === null || left === undefined || Number.isNaN(left);
+    const rightIsInvalid = right === null || right === undefined || Number.isNaN(right);
+    if (ascending) {
+        if (left < right || leftIsInvalid) {
+            return -1;
+        }
+        else if (left > right || rightIsInvalid) {
+            return 1;
+        }
+    }
+    else if (ascending === false) {
+        if (left < right || leftIsInvalid) {
+            return 1;
+        }
+        else if (left > right || rightIsInvalid) {
+            return -1;
+        }
+    }
+    return 0;
+}
+export function validateDateRange(date, dateStart, dateEnd) {
+    if (dateStart && dateEnd) {
+        return date >= dateStart && date <= dateEnd;
+    }
+    else if (dateStart && !dateEnd) {
+        return date >= dateStart;
+    }
+    else if (!dateStart && dateEnd) {
+        return date <= dateEnd;
+    }
+    else {
+        return true;
+    }
+}
+export function uuid() {
+    function hex4() {
+        return Math.floor((1 + Math.random()) * 0x10000)
+            .toString(16)
+            .substring(1);
+    }
+    return hex4() + hex4() + '-' + hex4() + '-' + hex4() + '-' + hex4() + '-' + hex4() + hex4() + hex4();
+}
+export function capitalizeFirstLetter(text) {
+    return `${text.charAt(0).toUpperCase()}${text.slice(1)}`;
+}
+/**
+ * Mapeia um novo array apenas com as propriedades definidas pelo desenvolvedor baseado em um array de
+ * origem.
+ *
+ * Exemplo:
+ *
+ * ```
+ * const people = [
+ *  { id: 1, name: 'Fulano', birthdate: '1980-11-01', genre: 'Male', city: 'São Paulo', dependents: 2 },
+ *  { id: 2, name: 'Beltrano', birthdate: '1997-01-21', genre: 'Female', city: 'Joinville', dependents: 0 },
+ *  { id: 3, name: 'Siclano', birthdate: '1995-07-15', genre: 'Male', city: 'Joinville', dependents: 0 }
+ * ];
+ *
+ * const properties = ['id', 'name'];
+ *
+ * const idAndName = mapArrayByProperties(people, properties);
+ *
+ * console.log(idAndName); // [{ id: 1, name: 'Fulano' }, { id: 2, name: 'Beltrano' }, { id: 3, name: 'Siclano' }]
+ * ```
+ *
+ * Um outro uso para o método é "parear" todos os objetos do array com as mesmas propriedades.
+ *
+ * ```
+ * const customers = [
+ *  { id: 1, name: 'Fulano', city: 'São Paulo', dependents: 2 }, // sem genre
+ *  { id: 2, name: 'Beltrano', genre: 'Female', city: 'Joinville' }, // sem dependents
+ *  { id: 3, name: 'Siclano', genre: 'Male', city: 'Joinville', dependents: 0 }
+ * ];
+ * const properties = ['id', 'name', 'city', 'genre', 'dependents'];
+ *
+ * const pattern = mapArrayByProperties(customers, properties);
+ * console.log(pattern);
+ *
+ * // [
+ * //   { id: 1, name: 'Fulano', city: 'São Paulo', genre: undefined, dependents: 2 },
+ * //   { id: 2, name: 'Beltrano', city: 'Joinville', genre: 'Female', dependents: undefined },
+ * //   { id: 3, name: 'Siclano', city: 'Joinville', genre: 'Male', dependents: 0 }
+ * // ]
+ * ```
+ *
+ * @param items {Array<any>} Array de items original.
+ * @param properties {Array<string>} Array de string com a lista de propriedades que devem ser retornadas.
+ *
+ * @returns Array<any>
+ */
+export function mapArrayByProperties(items = [], properties = []) {
+    return items.map(item => mapObjectByProperties(item, properties));
+}
+/**
+ * Mapeia um novo objeto apenas com as propriedades definidas pelo desenvolvedor.
+ *
+ * Exemplo:
+ *
+ * ```
+ * const person = { id: 1, name: 'Fulano', birthdate: '1980-11-01', genre: 'Male', city: 'São Paulo', dependents: 2 };
+ *
+ * const properties = ['id', 'name'];
+ *
+ * const idAndName = mapObjectByProperties(person, properties);
+ *
+ * console.log(idAndName); // { id: 1, name: 'Fulano' }
+ * ```
+ *
+ * @param object {Array<any>} Array de items original.
+ * @param properties {Array<string>} Array de string com a lista de propriedades que devem ser retornadas.
+ *
+ * @returns Array<any>
+ */
+export function mapObjectByProperties(object = {}, properties = []) {
+    const getSelectedProperties = (selectedProperties, property) => ({
+        ...selectedProperties,
+        [property]: object[property]
+    });
+    return properties.reduce(getSelectedProperties, {});
+}
+/**
+ * Retorna os valores de um objeto dentro de um array.
+ *
+ * > Simula o Object.values(obj), o mesmo deve ser removido assim que a versão typescrit for atualizada.
+ *
+ * @param object Objeto de onde será pego os valores.
+ */
+export function valuesFromObject(object = {}) {
+    return Object.keys(object).map(property => object[property]);
+}
+/**
+ * Converte um arquivo em base64.
+ *
+ * @param file arquivo que será convertido.
+ */
+export function convertImageToBase64(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.readAsDataURL(file);
+        reader.onload = () => resolve(reader.result);
+        /* istanbul ignore next */
+        reader.onerror = error => reject(error);
+    });
+}
+/**
+ * Converte um número em decimal baseado na quantidade de casas decimais.
+ *
+ * Caso o valor seja inválido, será retornado o valor `undefined`.
+ * Valores inválidos são: `false`, `NaN`, `strings` que não numéricas, `undefined` e `null`.
+ *
+ * @param number valor que será convertido
+ * @param decimalsPlace quantidade de casas decimais
+ */
+export function convertNumberToDecimal(number, decimalsPlace) {
+    const isValidValue = (number || number === 0) && !isNaN(number);
+    const floatValue = isValidValue ? parseFloat(number) : undefined;
+    try {
+        return parseFloat(floatValue.toFixed(decimalsPlace));
+    }
+    catch {
+        return floatValue;
+    }
+}
+/**
+ * Retorna uma copia do objeto sujo, sem as propriedades nulas ou indefinidas.
+ * Retorna o objeto sem as propriedades que contém valores nulos ou indefinidos.
+ *
+ * @param dirtyObject
+ */
+export function clearObject(dirtyObject) {
+    const cleanObject = {};
+    Object.keys(dirtyObject).forEach(key => {
+        if (dirtyObject[key] !== null && dirtyObject[key] !== undefined) {
+            cleanObject[key] = dirtyObject[key];
+        }
+    });
+    return cleanObject;
+}
+export function validateObjectType(value) {
+    return isTypeof(value, 'object') && !Array.isArray(value) ? value : undefined;
+}
+/**
+ * Retorna os elementos DOM capazes de receber foco.
+ *
+ * > Atualmente são considerados "focáveis" os elementos DOM `input`, `select`,
+ * `textarea`, `button` e `a`.
+ *
+ * @param parentElement Elemento DOM pai.
+ * @returns Lista dos elementos DOM filhos "focáveis".
+ */
+export function getFocusableElements(parentElement) {
+    const focusableElements = 'button:not([disabled]), [href], input, select, textarea, [tabindex]:not([tabindex="-1"]';
+    return parentElement.querySelectorAll(focusableElements);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../../projects/ui/src/lib/utils/util.ts"],"names":[],"mappings":"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","sourcesContent":["import { ViewContainerRef } from '@angular/core';\nimport { poLocales, poLocaleDefault } from '../services/po-language/po-language.constant';\n\n/**\n * @deprecated\n * Utilize o método `getShortBrowserLanguage`.\n *\n * @description\n * Retorna idioma do browser ou o idioma padrão.\n */\nexport function browserLanguage() {\n  return getShortBrowserLanguage();\n}\n\n/**\n * Converte e formata os bytes em formato mais legível para o usuário.\n *\n * Por exemplo:\n * - 31457280 em 30 MB.\n * - 21474836480 em 20 GB.\n * - 12.5666666 em 12.57 Bytes (duas casas decimais).\n *\n * @param bytes {number} Valor em bytes\n * @param decimals {number} Quantidade de casas decimais que terá após a conversão.\n */\nexport function formatBytes(bytes: number, decimals = 2): string {\n  if (!bytes) {\n    return undefined;\n  }\n\n  const multiplier = 1024;\n  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];\n  const result = Math.floor(Math.log(bytes) / Math.log(multiplier));\n  decimals = decimals < 0 ? 0 : decimals;\n\n  return `${parseFloat((bytes / Math.pow(multiplier, result)).toFixed(decimals))} ${sizes[result]}`;\n}\n\n/**\n * Retorna o idioma atual do navegador\n */\nexport function getBrowserLanguage(): string {\n  // navigator.userLanguage is the value for IE10\n  const language = navigator.language || navigator['userLanguage'];\n  const shortLanguage = getShortLanguage(language);\n\n  return poLocales.includes(shortLanguage) ? language : poLocaleDefault;\n}\n\n/**\n * Retorna o idioma do navegador, com somente as duas primeiras letras. Por exemplo: \"pt\" ou \"es\".\n *\n * Caso o valor retornado pelo navegador não estiver dentro dos idiomas suportados pelo PO,\n * será retornado a linguagem padrão (poLocaleDefault).\n */\nexport function getShortBrowserLanguage(): string {\n  return getShortLanguage(getBrowserLanguage());\n}\n\n/**\n * Retorna o idioma com somente a abreviação do idioma (duas primeiras letras).\n * Por exemplo: \"pt\" ou \"es\".\n *\n * @param language {string} linguagem.\n *\n * @returns sigla do idioma padrão {string}.\n *\n * @default pt\n */\nexport function getShortLanguage(language: string): string {\n  return (language || poLocaleDefault).toLowerCase().substring(0, 2);\n}\n\nexport function isLanguage(value) {\n  const languageRegex = new RegExp('^[a-z]{2}(-[a-z]{2})?$', 'i');\n\n  return languageRegex.test(value);\n}\n\n/* istanbul ignore next */\nexport function reloadCurrentPage() {\n  window.location.assign(location.href);\n}\n\nexport function convertToBoolean(val: any): boolean {\n  if (typeof val === 'string') {\n    val = val.toLowerCase().trim();\n    return val === 'true' || val === 'on' || val === '';\n  }\n\n  if (typeof val === 'number') {\n    return val === 1;\n  }\n\n  return !!val;\n}\n\nexport function convertToInt(value: any, valueDefault?: any): number {\n  const validNumber = parseInt(value, 10);\n  const validDefaultValue = parseInt(valueDefault, 10);\n  const defaultValue = validDefaultValue || validDefaultValue === 0 ? validDefaultValue : undefined;\n\n  return validNumber || validNumber === 0 ? validNumber : defaultValue;\n}\n\nexport function isTypeof(object: any, type: any) {\n  return typeof object === type;\n}\n\n/**\n *\n * @param fn Função que será executada dentro do contexto. Podendo ser o nome da função\n * ou a referência da mesma.\n *\n * @param context Contexto do qual a função será executada.\n */\nexport function callFunction(fn: any, context: any, param?): void {\n  if (isTypeof(fn, 'function')) {\n    fn.call(context, param);\n  } else {\n    context[fn](param);\n  }\n}\n\nexport function convertIsoToDate(value: string, start: boolean, end: boolean) {\n  if (value) {\n    const day = parseInt(value.substring(8, 10), 10);\n    const month = parseInt(value.substring(5, 7), 10);\n    const year = parseInt(value.substring(0, 4), 10);\n    if (start) {\n      const date = new Date(year, month - 1, day, 0, 0, 0);\n\n      setYearFrom0To100(date, year);\n\n      return date;\n    } else if (end) {\n      const date = new Date(year, month - 1, day, 23, 59, 59);\n\n      setYearFrom0To100(date, year);\n\n      return date;\n    } else {\n      const milliseconds = Date.parse(value);\n      const timezone = new Date().getTimezoneOffset() * 60000;\n      return new Date(milliseconds + timezone);\n    }\n  }\n}\n\nexport function convertDateToISODate(date: Date) {\n  if (date) {\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 = formatYear(date.getFullYear());\n\n    return year + '-' + month + '-' + day;\n  } else {\n    return null;\n  }\n}\n\nexport function convertDateToISOExtended(date: Date, time?: string) {\n  if (date) {\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 = formatYear(date.getFullYear());\n\n    const dateString = date.toString();\n\n    if (time !== null) {\n      return year + '-' + month + '-' + day + time;\n    } else {\n      return (\n        year +\n        '-' +\n        month +\n        '-' +\n        day +\n        'T' +\n        dateString.substring(16, 24) +\n        dateString.substring(28, 31) +\n        ':' +\n        dateString.substring(31, 33)\n      );\n    }\n  } else {\n    return null;\n  }\n}\n\n/**\n * Transforma o ano em uma string no formato yyyy e caso o ano seja menor que 1000 preenche com zeros a esquerda.\n *\n * @param year Ano\n */\nexport function formatYear(year: number) {\n  if (year >= 1000) {\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// Verifica se o navegador em que está sendo usado é Internet Explorer ou Edge\nexport function isIEOrEdge() {\n  const userAgent = window.navigator.userAgent;\n\n  return /msie\\s|trident\\/|edge\\//i.test(userAgent);\n}\n\n// Verifica se o navegador em que está sendo usado é Internet Explorer\nexport function isIE() {\n  const userAgent = window.navigator.userAgent;\n\n  return /msie\\s|trident/i.test(userAgent);\n}\n\n// Verifica se o navegador em que está sendo usado é Firefox\nexport function isFirefox() {\n  const userAgent = window.navigator.userAgent;\n\n  return userAgent.toLowerCase().indexOf('firefox') > -1;\n}\n\n// Verifica qual o dispositivo que está sendo usado\nexport function isMobile() {\n  const userAgent = window.navigator.userAgent;\n\n  return userAgent.match(/Android|webOS|iPhone|iPad|iPod|BlackBerry|Windows Phone/i);\n}\n\nexport function isEquals(value, comparedValue) {\n  return JSON.stringify(value) === JSON.stringify(comparedValue);\n}\n\nexport function isKeyCodeEnter(event: any): boolean {\n  return event.keyCode === 13 || event.which === 13;\n}\n\n/**\n * Caso o ano original da data seja entre 0 e 100 atribui esse valor ao ano, pois o `new Date` do javascript transforma o ano para 190X.\n *\n * @param date Data\n * @param year Ano original\n */\nexport function setYearFrom0To100(date: Date, year: number) {\n  if (year >= 0 && year < 100) {\n    date.setFullYear(year);\n  }\n}\n\nexport function sortOptionsByProperty(options: Array<any>, property: string) {\n  options.sort((optionA, optionB) => {\n    optionA = optionA[property].toString().toLowerCase();\n    optionB = optionB[property].toString().toLowerCase();\n\n    if (optionA < optionB) {\n      return -1;\n    }\n    if (optionA > optionB) {\n      return 1;\n    }\n    return 0;\n  });\n}\n\n/**\n * Ordena o campos baseado no valor da propriedade `order`.\n *\n * Só serão aceitos valores com números inteiros maiores do que zero para a ordenação.\n *\n * Campos sem `order` ou com valores negativos, zerados ou inválidos\n * receberão o valor default e seguirão o posicionamento dentro do\n * array.\n *\n * @param fields campo que se deseja ordenar.\n * @param defaultOrdering valor que será utilizado para manter na posição do array.\n */\nexport function sortFields(fields = [], defaultOrdering = -1) {\n  const resultClassification = { fieldAComesFirst: -1, fieldAComesAfter: 1, keepPositions: 0 };\n\n  const isOrderValid = (order: number) => isTypeof(order, 'number') && order > 0;\n  const applyDefaultOrdering = (order: number) => (isOrderValid(order) ? order : defaultOrdering);\n\n  return fields.sort((fieldA, fieldB) => {\n    const orderA = applyDefaultOrdering(fieldA.order);\n    const orderB = applyDefaultOrdering(fieldB.order);\n\n    if (orderA === orderB) {\n      return resultClassification.keepPositions;\n    }\n\n    if (orderA === defaultOrdering) {\n      return resultClassification.fieldAComesAfter;\n    }\n\n    if (orderB === defaultOrdering) {\n      return resultClassification.fieldAComesFirst;\n    }\n\n    return orderA - orderB;\n  });\n}\n\nexport function removeDuplicatedOptions(list: Array<any>) {\n  for (let i = 0; i < list.length; i++) {\n    if (i === 0) {\n      continue;\n    }\n\n    if (list.findIndex(op => op.value === list[i].value) !== i) {\n      list.splice(i, 1);\n      i--;\n    }\n  }\n}\n\nexport function removeUndefinedAndNullOptions(list: Array<any>) {\n  for (let i = 0; i < list.length; i++) {\n    if (list[i].value === undefined || list[i].value === null) {\n      list.splice(i, 1);\n      i--;\n    }\n  }\n}\n\nexport function validValue(value: any) {\n  return (value !== null && value !== undefined && value !== '') || value === false;\n}\n\nexport function isExternalLink(url): boolean {\n  return url ? url.startsWith('http') : false;\n}\n\nexport function openExternalLink(url): void {\n  window.open(url, '_blank');\n}\n\nexport function getFormattedLink(link: string): string {\n  let formattedLink = '';\n  // Retira todos os pontos no começo da URL.\n  if (link) {\n    formattedLink = link.replace(/^(\\.)+/g, '');\n  }\n  // Verifica se foi utilizado uma rota que não comece com barra.\n  if (!formattedLink.startsWith('/')) {\n    formattedLink = '/'.concat(formattedLink);\n  }\n  return formattedLink;\n}\n\n/**\n * Método responsável por ordenar dois valores.\n *\n * @param leftSide Primeiro valor a ser comparado.\n * @param rightSide Segundo valor a ser comparado.\n * @param ascending Determina se será em ordem ascendente ou descendente.\n */\nexport function sortValues(leftSide: string | Date, rightSide: string | Date, ascending: boolean = true): number {\n  const left = isTypeof(leftSide, 'string') ? (leftSide as string).toLowerCase() : leftSide;\n  const right = isTypeof(rightSide, 'string') ? (rightSide as string).toLowerCase() : rightSide;\n\n  const leftIsInvalid = left === null || left === undefined || Number.isNaN(left);\n  const rightIsInvalid = right === null || right === undefined || Number.isNaN(right);\n\n  if (ascending) {\n    if (left < right || leftIsInvalid) {\n      return -1;\n    } else if (left > right || rightIsInvalid) {\n      return 1;\n    }\n  } else if (ascending === false) {\n    if (left < right || leftIsInvalid) {\n      return 1;\n    } else if (left > right || rightIsInvalid) {\n      return -1;\n    }\n  }\n  return 0;\n}\n\nexport function validateDateRange(date: Date, dateStart: Date, dateEnd: Date) {\n  if (dateStart && dateEnd) {\n    return date >= dateStart && date <= dateEnd;\n  } else if (dateStart && !dateEnd) {\n    return date >= dateStart;\n  } else if (!dateStart && dateEnd) {\n    return date <= dateEnd;\n  } else {\n    return true;\n  }\n}\n\nexport function uuid() {\n  function hex4() {\n    return Math.floor((1 + Math.random()) * 0x10000)\n      .toString(16)\n      .substring(1);\n  }\n\n  return hex4() + hex4() + '-' + hex4() + '-' + hex4() + '-' + hex4() + '-' + hex4() + hex4() + hex4();\n}\n\nexport function capitalizeFirstLetter(text: string): string {\n  return `${text.charAt(0).toUpperCase()}${text.slice(1)}`;\n}\n\n/**\n * Mapeia um novo array apenas com as propriedades definidas pelo desenvolvedor baseado em um array de\n * origem.\n *\n * Exemplo:\n *\n * ```\n * const people = [\n *  { id: 1, name: 'Fulano', birthdate: '1980-11-01', genre: 'Male', city: 'São Paulo', dependents: 2 },\n *  { id: 2, name: 'Beltrano', birthdate: '1997-01-21', genre: 'Female', city: 'Joinville', dependents: 0 },\n *  { id: 3, name: 'Siclano', birthdate: '1995-07-15', genre: 'Male', city: 'Joinville', dependents: 0 }\n * ];\n *\n * const properties = ['id', 'name'];\n *\n * const idAndName = mapArrayByProperties(people, properties);\n *\n * console.log(idAndName); // [{ id: 1, name: 'Fulano' }, { id: 2, name: 'Beltrano' }, { id: 3, name: 'Siclano' }]\n * ```\n *\n * Um outro uso para o método é \"parear\" todos os objetos do array com as mesmas propriedades.\n *\n * ```\n * const customers = [\n *  { id: 1, name: 'Fulano', city: 'São Paulo', dependents: 2 }, // sem genre\n *  { id: 2, name: 'Beltrano', genre: 'Female', city: 'Joinville' }, // sem dependents\n *  { id: 3, name: 'Siclano', genre: 'Male', city: 'Joinville', dependents: 0 }\n * ];\n * const properties = ['id', 'name', 'city', 'genre', 'dependents'];\n *\n * const pattern = mapArrayByProperties(customers, properties);\n * console.log(pattern);\n *\n * // [\n * //   { id: 1, name: 'Fulano', city: 'São Paulo', genre: undefined, dependents: 2 },\n * //   { id: 2, name: 'Beltrano', city: 'Joinville', genre: 'Female', dependents: undefined },\n * //   { id: 3, name: 'Siclano', city: 'Joinville', genre: 'Male', dependents: 0 }\n * // ]\n * ```\n *\n * @param items {Array<any>} Array de items original.\n * @param properties {Array<string>} Array de string com a lista de propriedades que devem ser retornadas.\n *\n * @returns Array<any>\n */\nexport function mapArrayByProperties(items: Array<any> = [], properties: Array<string> = []): Array<any> {\n  return items.map(item => mapObjectByProperties(item, properties));\n}\n\n/**\n * Mapeia um novo objeto apenas com as propriedades definidas pelo desenvolvedor.\n *\n * Exemplo:\n *\n * ```\n * const person = { id: 1, name: 'Fulano', birthdate: '1980-11-01', genre: 'Male', city: 'São Paulo', dependents: 2 };\n *\n * const properties = ['id', 'name'];\n *\n * const idAndName = mapObjectByProperties(person, properties);\n *\n * console.log(idAndName); // { id: 1, name: 'Fulano' }\n * ```\n *\n * @param object {Array<any>} Array de items original.\n * @param properties {Array<string>} Array de string com a lista de propriedades que devem ser retornadas.\n *\n * @returns Array<any>\n */\nexport function mapObjectByProperties(object: any = {}, properties: Array<string> = []) {\n  const getSelectedProperties = (selectedProperties, property) => ({\n    ...selectedProperties,\n    [property]: object[property]\n  });\n\n  return properties.reduce(getSelectedProperties, {});\n}\n\n/**\n * Retorna os valores de um objeto dentro de um array.\n *\n * > Simula o Object.values(obj), o mesmo deve ser removido assim que a versão typescrit for atualizada.\n *\n * @param object Objeto de onde será pego os valores.\n */\nexport function valuesFromObject(object: any = {}): Array<any> {\n  return Object.keys(object).map(property => object[property]);\n}\n\n/**\n * Converte um arquivo em base64.\n *\n * @param file arquivo que será convertido.\n */\nexport function convertImageToBase64(file: File): Promise<any> {\n  return new Promise((resolve, reject) => {\n    const reader = new FileReader();\n\n    reader.readAsDataURL(file);\n    reader.onload = () => resolve(reader.result);\n    /* istanbul ignore next */\n    reader.onerror = error => reject(error);\n  });\n}\n\n/**\n * Converte um número em decimal baseado na quantidade de casas decimais.\n *\n * Caso o valor seja inválido, será retornado o valor `undefined`.\n * Valores inválidos são: `false`, `NaN`, `strings` que não numéricas, `undefined` e `null`.\n *\n * @param number valor que será convertido\n * @param decimalsPlace quantidade de casas decimais\n */\nexport function convertNumberToDecimal(number: any, decimalsPlace: number): number {\n  const isValidValue = (number || number === 0) && !isNaN(number);\n\n  const floatValue = isValidValue ? parseFloat(number) : undefined;\n\n  try {\n    return parseFloat(floatValue.toFixed(decimalsPlace));\n  } catch {\n    return floatValue;\n  }\n}\n\n/**\n * Retorna uma copia do objeto sujo, sem as propriedades nulas ou indefinidas.\n * Retorna o objeto sem as propriedades que contém valores nulos ou indefinidos.\n *\n * @param dirtyObject\n */\nexport function clearObject(dirtyObject: object): any {\n  const cleanObject = {};\n\n  Object.keys(dirtyObject).forEach(key => {\n    if (dirtyObject[key] !== null && dirtyObject[key] !== undefined) {\n      cleanObject[key] = dirtyObject[key];\n    }\n  });\n\n  return cleanObject;\n}\n\nexport function validateObjectType(value: any) {\n  return isTypeof(value, 'object') && !Array.isArray(value) ? value : undefined;\n}\n\n/**\n * Retorna os elementos DOM capazes de receber foco.\n *\n * > Atualmente são considerados \"focáveis\" os elementos DOM `input`, `select`,\n * `textarea`, `button` e `a`.\n *\n * @param parentElement Elemento DOM pai.\n * @returns Lista dos elementos DOM filhos \"focáveis\".\n */\nexport function getFocusableElements(parentElement: Element): NodeListOf<Element> {\n  const focusableElements = 'button:not([disabled]), [href], input, select, textarea, [tabindex]:not([tabindex=\"-1\"]';\n  return parentElement.querySelectorAll(focusableElements);\n}\n"]}

package/esm2020/po-ui-ng-components.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tdWktbmctY29tcG9uZW50cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3VpL3NyYy9wby11aS1uZy1jb21wb25lbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=