@controleonline/ui-common 1.2.70

package/src/utils/config.js

@@ -0,0 +1,14 @@
+export default class Config {
+  getConfig(key) {
+    let storedUser = this.getAllConfig();
+    return storedUser ? storedUser[key] : {};
+  }
+  getAllConfig() {
+    return JSON.parse(localStorage.getItem("config")) || {};
+  }
+  setConfig(key, data) {
+    let storedUser = this.getAllConfig();
+    storedUser[key] = data;
+    localStorage.setItem("config", JSON.stringify(storedUser));
+  }
+}

package/src/utils/formatter.js

@@ -0,0 +1,419 @@
+export default class Formatter {
+
+  /* ================= UTIL ================= */
+
+  static onlyNumbers(value) {
+    return String(value || '').replace(/\D/g, '');
+  }
+
+  /* ================= DOCUMENTOS ================= */
+
+  static formatDocument(value) {
+
+    const numbers = Formatter.onlyNumbers(value);
+
+    if (numbers.length === 11)
+      return Formatter.maskCPF(numbers);
+
+    if (numbers.length === 14)
+      return Formatter.maskCNPJ(numbers);
+
+    return value || '';
+  }
+
+  static formatBRDocument(value) {
+    return Formatter.maskBRDocument(value);
+  }
+
+  /* ================= MÁSCARAS DIGITAÇÃO ================= */
+
+  static maskCPF(value) {
+
+    value = Formatter.onlyNumbers(value).slice(0, 11);
+
+    return value
+      .replace(/^(\d{3})(\d)/, '$1.$2')
+      .replace(/^(\d{3})\.(\d{3})(\d)/, '$1.$2.$3')
+      .replace(/\.(\d{3})(\d)/, '.$1-$2');
+  }
+
+  static maskCNPJ(value) {
+
+    value = Formatter.onlyNumbers(value).slice(0, 14);
+
+    return value
+      .replace(/^(\d{2})(\d)/, '$1.$2')
+      .replace(/^(\d{2})\.(\d{3})(\d)/, '$1.$2.$3')
+      .replace(/\.(\d{3})(\d)/, '.$1/$2')
+      .replace(/(\d{4})(\d)/, '$1-$2');
+  }
+
+  static maskBRDocument(value) {
+
+    const numbers = Formatter.onlyNumbers(value);
+
+    if (numbers.length <= 11)
+      return Formatter.maskCPF(numbers);
+
+    return Formatter.maskCNPJ(numbers);
+  }
+
+  /* ================= TELEFONE ================= */
+
+  static maskPhoneBR(value) {
+
+    value = Formatter.onlyNumbers(value).slice(0, 11);
+
+    // if (value.length <= 2)
+    //   return `(${value}`;
+
+    // if (value.length <= 6)
+    //   return value.replace(/(\d{2})(\d+)/, '($1) $2');
+
+    if (value.length <= 8)
+      return value.replace(/(\d{4})(\d+)/, '$1-$2');
+
+    if (value.length <= 9)
+      return value.replace(/(\d{1})(\d{4})(\d+)/, '$1 $2-$3');
+
+    if (value.length <= 10)
+      return value.replace(/(\d{2})(\d{4})(\d+)/, '($1) $2-$3');
+
+    return value.replace(/(\d{2})(\d{1})(\d{4})(\d+)/, '($1) $2 $3-$4');
+  }
+
+  static formatBRPhone(value) {
+
+    const numbers = Formatter.onlyNumbers(value);
+
+    if (numbers.length === 10)
+      return numbers.replace(/(\d{2})(\d{4})(\d{4})/, '($1) $2-$3');
+
+    if (numbers.length === 11)
+      return numbers.replace(/(\d{2})(\d{1})(\d{4})(\d{4})/, '($1) $2 $3-$4');
+
+    return value || '';
+  }
+
+  static formatPhone(value) {
+    return Formatter.maskPhoneBR(value);
+  }
+
+  /* ================= VALIDAÇÕES ================= */
+
+  static validateEmail(email) {
+    if (!email) return false;
+    return /\S+@\S+\.\S+/.test(email);
+  }
+
+  static validateCPF(cpf) {
+
+    cpf = Formatter.onlyNumbers(cpf);
+
+    if (cpf.length !== 11) return false;
+    if (/^(\d)\1+$/.test(cpf)) return false;
+
+    let sum = 0;
+
+    for (let i = 0; i < 9; i++)
+      sum += cpf[i] * (10 - i);
+
+    let rev = 11 - (sum % 11);
+    if (rev >= 10) rev = 0;
+
+    if (rev != cpf[9]) return false;
+
+    sum = 0;
+
+    for (let i = 0; i < 10; i++)
+      sum += cpf[i] * (11 - i);
+
+    rev = 11 - (sum % 11);
+    if (rev >= 10) rev = 0;
+
+    return rev == cpf[10];
+  }
+
+  static validateCNPJ(cnpj) {
+
+    cnpj = Formatter.onlyNumbers(cnpj);
+
+    if (cnpj.length !== 14) return false;
+    if (/^(\d)\1+$/.test(cnpj)) return false;
+
+    let length = cnpj.length - 2;
+    let numbers = cnpj.substring(0, length);
+    let digits = cnpj.substring(length);
+
+    let sum = 0;
+    let pos = length - 7;
+
+    for (let i = length; i >= 1; i--) {
+
+      sum += numbers[length - i] * pos--;
+
+      if (pos < 2)
+        pos = 9;
+    }
+
+    let result = sum % 11 < 2 ? 0 : 11 - sum % 11;
+
+    if (result != digits[0])
+      return false;
+
+    length = length + 1;
+    numbers = cnpj.substring(0, length);
+
+    sum = 0;
+    pos = length - 7;
+
+    for (let i = length; i >= 1; i--) {
+
+      sum += numbers[length - i] * pos--;
+
+      if (pos < 2)
+        pos = 9;
+    }
+
+    result = sum % 11 < 2 ? 0 : 11 - sum % 11;
+
+    return result == digits[1];
+  }
+
+  /* ================= DATAS ================= */
+
+  static formatDateToBR(dateInput) {
+
+    if (!dateInput) return '';
+
+    const dateOnly = String(dateInput).split(' ')[0];
+    const parts = dateOnly.split(/[-/]/);
+
+    if (parts.length !== 3)
+      return dateInput;
+
+    const [part1, part2, part3] = parts;
+
+    let day, month, year;
+
+    if (part1.length === 4) {
+
+      year = part1;
+      month = part2;
+      day = part3;
+
+    } else if (part3.length === 4) {
+
+      day = part1;
+      month = part2;
+      year = part3;
+
+    } else {
+      return dateInput;
+    }
+
+    if (day > 31 || month > 12 || day < 1 || month < 1)
+      return dateInput;
+
+    return `${String(day).padStart(2, '0')}/${String(month).padStart(2, '0')}/${year}`;
+  }
+
+  static validateBRDate(value) {
+
+    if (!value) return true;
+
+    const normalizedValue = value.replace(/[-/]/g, '/');
+
+    const regex = /^\d{2}\/\d{2}\/\d{4}$/;
+
+    if (!regex.test(normalizedValue))
+      return 'Data inválida. Formato esperado: DD/MM/YYYY';
+
+    const [day, month, year] = normalizedValue.split('/').map(Number);
+
+    const date = new Date(year, month - 1, day);
+
+    if (
+      date.getFullYear() !== year ||
+      date.getMonth() + 1 !== month ||
+      date.getDate() !== day
+    )
+      return 'Data inválida';
+
+    return true;
+  }
+
+  /* ================= CEP ================= */
+
+  static formatCEP(value) {
+
+    if (!value) return '';
+
+    value = Formatter.onlyNumbers(value);
+
+    if (value.length === 7)
+      value = `0${value}`;
+
+    return value.replace(/(\d{5})(\d{3})/, '$1-$2');
+  }
+
+  /* ================= NUMÉRICOS ================= */
+
+  static formatFloat(value) {
+
+    const formatedValue = String(value || 0)
+      .replace(/[^0-9.,]/g, '')
+      .replace('.', '')
+      .replace(',', '.');
+
+    return parseFloat(formatedValue) || 0;
+  }
+
+  static formatMoney(value, currency = 'R$', locale = 'pt-BR') {
+
+    if (!value && value !== 0)
+      return `${currency} 0,00`;
+
+    const numericValue =
+      typeof value === 'string'
+        ? parseFloat(value.replace('.', '').replace(',', '.')) || 0
+        : value;
+
+    const formatter = new Intl.NumberFormat(locale, {
+      minimumFractionDigits: 2,
+      maximumFractionDigits: 2,
+    });
+
+    return `${currency} ${formatter.format(numericValue)}`;
+  }
+
+  static formatInteger(value, locale = 'pt-BR') {
+
+    const numericValue = Number(value || 0);
+
+    return new Intl.NumberFormat(locale, {
+      maximumFractionDigits: 0,
+    }).format(Number.isFinite(numericValue) ? numericValue : 0);
+  }
+
+  static formatDecimal(value, locale = 'pt-BR', maximumFractionDigits = 1) {
+
+    const numericValue = Number(value || 0);
+
+    return new Intl.NumberFormat(locale, {
+      maximumFractionDigits,
+    }).format(Number.isFinite(numericValue) ? numericValue : 0);
+  }
+
+  static formatPercent(value, locale = 'pt-BR', maximumFractionDigits = 1) {
+
+    return `${Formatter.formatDecimal(value, locale, maximumFractionDigits)}%`;
+  }
+
+  static formatSignedInteger(value, locale = 'pt-BR') {
+
+    const numericValue = Number(value || 0);
+
+    if (numericValue > 0)
+      return `+${Formatter.formatInteger(numericValue, locale)}`;
+
+    if (numericValue < 0)
+      return `-${Formatter.formatInteger(Math.abs(numericValue), locale)}`;
+
+    return '0';
+  }
+
+  static formatSignedPercent(value, locale = 'pt-BR', maximumFractionDigits = 1) {
+
+    const numericValue = Number(value || 0);
+
+    if (numericValue > 0)
+      return `+${Formatter.formatPercent(numericValue, locale, maximumFractionDigits)}`;
+
+    if (numericValue < 0)
+      return `-${Formatter.formatPercent(Math.abs(numericValue), locale, maximumFractionDigits)}`;
+
+    return '0%';
+  }
+
+  static formatDateShort(value) {
+
+    if (!value) return '';
+
+    const date = new Date(value);
+
+    if (isNaN(date.getTime()))
+      return '';
+
+    const day = String(date.getDate()).padStart(2, '0');
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+
+    return `${day}/${month}`;
+  }
+
+  /* ================= DATAS AUX ================= */
+
+  static buildAmericanDate(dateString) {
+
+    if (!dateString) return null;
+
+    const normalizedDate = dateString.replaceAll('/', '-');
+
+    const [day, month, year] = normalizedDate.split('-').map(Number);
+
+    const date = new Date(year, month - 1, day);
+
+    if (isNaN(date.getTime()))
+      return null;
+
+    const yyyy = date.getFullYear();
+    const mm = String(date.getMonth() + 1).padStart(2, '0');
+    const dd = String(date.getDate()).padStart(2, '0');
+
+    return `${yyyy}-${mm}-${dd}`;
+  }
+
+  static getCurrentDate() {
+
+    const today = new Date();
+
+    const year = today.getFullYear();
+    const month = String(today.getMonth() + 1).padStart(2, '0');
+    const day = String(today.getDate()).padStart(2, '0');
+
+    return `${year}-${month}-${day}`;
+  }
+
+  static formatDateYmdTodmY(value, withTime = false) {
+
+    if (!value) return '';
+
+    const date = new Date(value);
+
+    if (isNaN(date.getTime()))
+      return value;
+
+    const clientTimeZoneOffset = new Date().getTimezoneOffset();
+
+    const timeZoneDiffMinutes = clientTimeZoneOffset - date.getTimezoneOffset();
+
+    date.setMinutes(date.getMinutes() + timeZoneDiffMinutes);
+
+    const options = {
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      hour12: false,
+    };
+
+    if (withTime) {
+
+      options.hour = '2-digit';
+      options.minute = '2-digit';
+      options.second = '2-digit';
+    }
+
+    return date.toLocaleString('pt-BR', options);
+  }
+
+}

package/src/utils/integrationConfigs.js

@@ -0,0 +1,79 @@
+export const CIELO_CONFIG_KEY = 'CIELO';
+export const NEW_RELIC_CONFIG_KEY = 'NEW_RELIC';
+export const SPOTIFY_CONFIG_KEY = 'SPOTIFY';
+
+export const DEFAULT_CIELO_CONFIG = {
+  ACCESS_TOKEN: '',
+  CLIENT_ID: '',
+  EMAIL: '',
+};
+
+export const DEFAULT_NEW_RELIC_CONFIG = {
+  LICENSE_KEY: '',
+  APPLICATION_ID: '',
+  ACCOUNT_ID: '',
+  TRUST_KEY: '',
+  BEACON: 'bam.nr-data.net',
+  ERROR_BEACON: 'bam.nr-data.net',
+};
+
+export const DEFAULT_SPOTIFY_CONFIG = {
+  CLIENT_ID: '',
+  CLIENT_SECRET: '',
+};
+
+const isConfigMap = value =>
+  value && typeof value === 'object' && !Array.isArray(value);
+
+const parseJsonValue = (value, fallback) => {
+  if (value === null || value === undefined || value === '') {
+    return fallback;
+  }
+
+  if (typeof value === 'string') {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return fallback;
+    }
+  }
+
+  return value;
+};
+
+const normalizeTextValue = value => String(value || '').trim();
+
+export const resolveIntegrationConfig = (configs, configKey, defaults) => {
+  if (!isConfigMap(defaults)) {
+    return {};
+  }
+
+  const rawConfig = isConfigMap(configs)
+    ? parseJsonValue(configs[configKey], {})
+    : {};
+  const source = isConfigMap(rawConfig) ? rawConfig : {};
+
+  return Object.keys(defaults).reduce((accumulator, fieldKey) => {
+    accumulator[fieldKey] = normalizeTextValue(
+      source[fieldKey] !== undefined ? source[fieldKey] : defaults[fieldKey],
+    );
+    return accumulator;
+  }, {});
+};
+
+export const resolveCieloConfig = configs =>
+  resolveIntegrationConfig(configs, CIELO_CONFIG_KEY, DEFAULT_CIELO_CONFIG);
+
+export const resolveNewRelicConfig = configs =>
+  resolveIntegrationConfig(
+    configs,
+    NEW_RELIC_CONFIG_KEY,
+    DEFAULT_NEW_RELIC_CONFIG,
+  );
+
+export const resolveSpotifyConfig = configs =>
+  resolveIntegrationConfig(
+    configs,
+    SPOTIFY_CONFIG_KEY,
+    DEFAULT_SPOTIFY_CONFIG,
+  );

package/src/utils/methods.js

@@ -0,0 +1,23 @@
+export function copyObject(obj) {
+  if (obj === null || !(obj instanceof Object)) {
+    return obj;
+  }
+
+  if (Array.isArray(obj)) {
+    const newArray = obj.map((item) => copyObject(item));
+    return newArray;
+  }
+
+  if (obj instanceof Function) {
+    return obj;
+  }
+
+  const newObj = {};
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      newObj[key] = copyObject(obj[key]);
+    }
+  }
+
+  return newObj || {};
+}

package/src/utils/oauth.js

@@ -0,0 +1,42 @@
+export const OAUTH_GOOGLE_CLIENT_ID_CONFIG_KEY = 'OAUTH_GOOGLE_CLIENT_ID';
+
+const normalizeConfigTextValue = value => {
+  if (value === null || value === undefined) {
+    return '';
+  }
+
+  if (typeof value === 'string') {
+    const trimmedValue = value.trim();
+
+    if (!trimmedValue) {
+      return '';
+    }
+
+    try {
+      const parsedValue = JSON.parse(trimmedValue);
+      if (typeof parsedValue === 'string') {
+        return parsedValue.trim();
+      }
+    } catch {}
+
+    return trimmedValue;
+  }
+
+  return String(value).trim();
+};
+
+const isConfigMap = value =>
+  value && typeof value === 'object' && !Array.isArray(value);
+
+export const resolveGoogleOauthClientId = configs => {
+  if (!isConfigMap(configs)) {
+    return '';
+  }
+
+  return normalizeConfigTextValue(
+    configs[OAUTH_GOOGLE_CLIENT_ID_CONFIG_KEY],
+  );
+};
+
+export const resolveCompanyGoogleOauthClientId = company =>
+  resolveGoogleOauthClientId(company?.configs);