_comuns/dist/index.mjs

import z from 'zod';
import dayjs from 'dayjs';
import duration from 'dayjs/plugin/duration.js';
import isSameOrAfter from 'dayjs/plugin/isSameOrAfter.js';
import isSameOrBefore from 'dayjs/plugin/isSameOrBefore.js';
import minMax from 'dayjs/plugin/minMax.js';
import relativeTime from 'dayjs/plugin/relativeTime.js';
import timezone from 'dayjs/plugin/timezone.js';
import utc from 'dayjs/plugin/utc.js';
import weekOfYear from 'dayjs/plugin/weekOfYear.js';
import 'dayjs/locale/pt-br.js';
import crossFetch from 'cross-fetch';
import { v4, v3, NIL } from 'uuid';

const alfabeto = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("");
const aleatorio = (tamanho) => `eli-${Array.from({ length: tamanho || 8 }).map(() => alfabeto[(999 * Math.random() | 0) % alfabeto.length]).join("")}`;

const _cache = {};
globalThis.cacheMemoria_cache = _cache;
const cacheM = (chave, valor, validadeSeg) => {
  const txChave = typeof chave == "string" ? chave : typeof chave == "number" ? String(chave) : encodeURIComponent(JSON.stringify(chave));
  const validade = validadeSeg && (/* @__PURE__ */ new Date()).getTime() + validadeSeg * 1e3;
  if (valor !== void 0) {
    _cache[txChave] = {
      valor,
      validade
    };
  }
  const busca = _cache[txChave];
  if (busca?.validade && busca.validade < (/* @__PURE__ */ new Date()).getTime()) {
    return void 0;
  }
  return busca?.valor;
};
const verCacheM = () => _cache;
const cacheMemoria = cacheM;
const cacheMFixo = (chave) => (valor) => cacheM(chave, valor);

const uuid_null = "00000000-0000-0000-0000-000000000000";
var camposComuns = /* @__PURE__ */ ((camposComuns2) => {
  camposComuns2["codigo"] = "codigo";
  camposComuns2["excluido"] = "excluido";
  camposComuns2["data_hora_criacao"] = "data_hora_criacao";
  camposComuns2["data_hora_atualizacao"] = "data_hora_atualizacao";
  camposComuns2["codigo_usuario_criacao"] = "codigo_usuario_criacao";
  camposComuns2["codigo_usuario_atualizacao"] = "codigo_usuario_atualizacao";
  camposComuns2["versao"] = "versao";
  return camposComuns2;
})(camposComuns || {});
var tx = /* @__PURE__ */ ((tx2) => {
  tx2["token"] = "token";
  return tx2;
})(tx || {});
var tipoUsuarioResiduos = /* @__PURE__ */ ((tipoUsuarioResiduos2) => {
  tipoUsuarioResiduos2["Usuario"] = "usuario";
  tipoUsuarioResiduos2["Fornecedor"] = "fornecedor";
  return tipoUsuarioResiduos2;
})(tipoUsuarioResiduos || {});

var operadores = /* @__PURE__ */ ((operadores2) => {
  operadores2["="] = "=";
  operadores2["!="] = "!=";
  operadores2[">"] = ">";
  operadores2[">="] = ">=";
  operadores2["<"] = "<";
  operadores2["<="] = "<=";
  operadores2["like"] = "like";
  operadores2["in"] = "in";
  return operadores2;
})(operadores || {});
const zOperadores = z.enum([
  "=",
  "!=",
  ">",
  ">=",
  "<",
  "<=",
  "like",
  "in"
]);
const zFiltro = z.object({
  coluna: z.string(),
  valor: z.any(),
  operador: zOperadores,
  ou: z.boolean().optional()
});

dayjs.locale("pt-br");
dayjs.extend(utc);
dayjs.extend(timezone);
dayjs.extend(weekOfYear);
dayjs.extend(isSameOrBefore);
dayjs.extend(isSameOrAfter);
dayjs.extend(minMax);
dayjs.extend(relativeTime);
dayjs.extend(duration);
const dayjsbr = dayjs;

const cdn_carro_de_boi = "https://carro-de-boi-idz-one.b-cdn.net";

const extensoes = [
  {
    ext: "gif",
    tipo: "imagem",
    mime: "image/gif"
  },
  {
    ext: "jpg",
    tipo: "imagem",
    mime: "image/jpeg"
  },
  {
    ext: "jpeg",
    tipo: "imagem",
    mime: "image/jpeg"
  },
  {
    ext: "png",
    tipo: "imagem",
    mime: "image/png"
  },
  {
    ext: "bmp",
    tipo: "imagem",
    mime: "image/bmp"
  },
  {
    ext: "webp",
    tipo: "imagem",
    mime: "image/webp"
  },
  {
    ext: "tiff",
    tipo: "imagem",
    mime: "image/tiff"
  },
  {
    ext: "svg",
    tipo: "imagem",
    mime: "image/svg+xml"
  },
  {
    ext: "ico",
    tipo: "imagem",
    mime: "image/x-icon"
  },
  {
    ext: "pdf",
    tipo: "documento",
    mime: "application/pdf"
  },
  {
    ext: "doc",
    tipo: "documento",
    mime: "application/msword"
  },
  {
    ext: "docx",
    tipo: "documento",
    mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
  },
  {
    ext: "xls",
    tipo: "documento",
    mime: "application/vnd.ms-excel"
  },
  {
    ext: "xlsx",
    tipo: "documento",
    mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
  },
  {
    ext: "ppt",
    tipo: "documento",
    mime: "application/vnd.ms-powerpoint"
  },
  {
    ext: "pptx",
    tipo: "documento",
    mime: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
  },
  {
    ext: "txt",
    tipo: "documento",
    mime: "text/plain"
  },
  {
    ext: "odt",
    tipo: "documento",
    mime: "application/vnd.oasis.opendocument.text"
  },
  {
    ext: "ods",
    tipo: "documento",
    mime: "application/vnd.oasis.opendocument.spreadsheet"
  },
  {
    ext: "rtf",
    tipo: "documento",
    mime: "application/rtf"
  },
  {
    ext: "csv",
    tipo: "documento",
    mime: "text/csv"
  },
  {
    ext: "mp4",
    tipo: "v\xEDdeo",
    mime: "video/mp4"
  },
  {
    ext: "avi",
    tipo: "v\xEDdeo",
    mime: "video/x-msvideo"
  },
  {
    ext: "mkv",
    tipo: "v\xEDdeo",
    mime: "video/x-matroska"
  },
  {
    ext: "mov",
    tipo: "v\xEDdeo",
    mime: "video/quicktime"
  },
  {
    ext: "wmv",
    tipo: "v\xEDdeo",
    mime: "video/x-ms-wmv"
  },
  {
    ext: "flv",
    tipo: "v\xEDdeo",
    mime: "video/x-flv"
  },
  {
    ext: "webm",
    tipo: "v\xEDdeo",
    mime: "video/webm"
  },
  {
    ext: "3gp",
    tipo: "v\xEDdeo",
    mime: "video/3gpp"
  },
  {
    ext: "mpeg",
    tipo: "v\xEDdeo",
    mime: "video/mpeg"
  }
];
const tipoArquivo = (nomeArquivo) => {
  const extArquivo = String(nomeArquivo || "").toLocaleLowerCase().split(".").pop();
  const extensao = extensoes.find((extensao2) => extensao2.ext === extArquivo);
  return extensao?.tipo || "outros";
};

const graficos_pilao = {
  Condicionantes: {
    grafico: "condicionantes-criadas",
    titulo: "Condicionantes Criadas"
  },
  Licen\u00E7as: {
    grafico: "licencas-criadas",
    titulo: "Licen\xE7as Criadas"
  }
};

const localValor = (chave_, valor) => {
  const localStorage = globalThis.localStorage;
  if (typeof localStorage == "undefined") return null;
  const chave = typeof chave_ === "string" ? chave_ : encodeURIComponent(JSON.stringify(chave_));
  try {
    if (valor !== void 0) {
      localStorage.setItem(chave, JSON.stringify(valor));
    }
    const v2 = localStorage.getItem(chave);
    if (v2 === null) return null;
    try {
      return JSON.parse(v2);
    } catch {
      return v2;
    }
  } catch {
    return null;
  }
};

const esperar = (ms) => new Promise(
  (resolve) => setTimeout(() => resolve(true), ms)
);
const nomeVariavel = (v) => Object.keys(v).join("/");

const LOKI_BASE_URL = "https://log.idz.one";
const LOKI_ENDPOINT = "/loki/api/v1/push";
const postLogger = async ({
  objeto
}) => {
  const response = await crossFetch(`${LOKI_BASE_URL}${LOKI_ENDPOINT}`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(objeto)
  }).catch((a) => a);
  if (!response.ok) {
    return [objeto, `Erro ${response.status}: ${await response?.text?.()}`];
  }
  return [objeto];
};
let cwd = "";
const defineCwd = (novoCwd) => {
  cwd = novoCwd;
};
const logger = ({ app: app_e, eProducao, parametros: parametrosAmbiente }) => ({ inquilino, usuario, parametros: parametrosSessao }) => async (level, mensagem, op_tipoLog) => {
  let {
    __filename,
    detalhes,
    local,
    parametros: parametrosLog
  } = op_tipoLog || {};
  const app = `${eProducao ? "" : "DEV-"}${app_e}`;
  if (cwd && __filename) {
    __filename = __filename.replace(cwd, "");
  }
  if (local) {
    detalhes = [`${nomeVariavel({ local })}="${local}"`, ...detalhes || []];
  }
  if (__filename) {
    detalhes = [
      `${nomeVariavel({ __filename })}="${__filename}"`,
      ...detalhes || []
    ];
  }
  const timestamp = `${Date.now()}000000`;
  const mainLog = detalhes?.length ? `${mensagem} | ${detalhes.map((d) => JSON.stringify(d)).join(" | ")}` : mensagem;
  const payload = {
    stream: {
      app,
      inquilino,
      usuario,
      level,
      ...parametrosAmbiente || {},
      ...parametrosSessao || {},
      ...parametrosLog || {}
    },
    values: [
      [
        timestamp,
        mainLog
        // Linha de log direta
      ]
    ]
  };
  const objeto = { streams: [payload] };
  const response = await postLogger({ objeto });
  return response;
};

const paraObjetoRegistroPg = (entrada) => {
  try {
    return Object.fromEntries(
      Object.entries(entrada).map(([k, v]) => [
        k,
        v === void 0 || v == null ? v : typeof v == "string" || typeof v == "number" || typeof v == "boolean" ? v : JSON.stringify(v, null, 2)
      ])
    );
  } catch (error) {
    throw new Error(
      `Erro na fun\xE7\xE3o paraObjetoRegistroPg: ${error.message} ${error.stack}`
    );
  }
};
const pgObjeto = paraObjetoRegistroPg;
const objetoPg = paraObjetoRegistroPg;

const umaFuncao = () => "Ol\xE1 Mundo! (fun\xE7\xE3o)";

const umaVariavel = "Ol\xE1 Mundo! (vari\xE1vel)";

const texto_busca = (...texto) => texto.map(
  (txt) => txt === null || txt === void 0 ? "" : String(txt).normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/\s+/g, " ").toLowerCase()
).join(" ");

class TipagemRotas {
  _partesCaminho = [];
  _acaoIr;
  rotulo;
  /** Ao criar novo obijeto de tipagem de rota é necessário passar o caminho parcial
   ** export const mCaminho = new TipagemRotas<{q:string}>("aplicacao","funcionalidade")
   */
  constructor({
    caminho,
    acaoIr,
    rotulo
  }) {
    this._acaoIr = acaoIr;
    this._partesCaminho = (Array.isArray(caminho) ? caminho : [caminho]).filter(Boolean).map((a) => String(a)).flatMap((a) => a.split("/")).filter(Boolean);
    this.rotulo = rotulo;
  }
  /** Retorna o caminho completo da rota
   ** console.log(mCaminho.caminho)
   ** "/caminho"
   */
  get caminho() {
    const ret = `/${this._partesCaminho.join("/")}`;
    return ret;
  }
  /** Define o caminho completo da rota
   ** mCaminho.caminho = "/novoCaminho"
   ** console.log(mCaminho.caminho)
   ** "/novoCaminho"
   ** */
  set caminho(caminhoParcial) {
    this._partesCaminho = caminhoParcial.split("/").filter((parte) => parte);
  }
  /** Retorna o caminho completo da rota com a query
   ** console.log(mCaminho.resolve({q:"query"}))
   ** "http://localhost:3000/caminho?q=query"
   */
  endereco(query, usarComoHash) {
    const url = new URL(
      typeof window !== "undefined" ? window.location.href : "http://localhost"
    );
    url.pathname = this.caminho;
    url.search = "";
    const queryKeys = Object.entries(query);
    for (const [key, value] of queryKeys) {
      url.searchParams.set(String(key), JSON.stringify(value));
    }
    url.hash = "";
    if (usarComoHash) {
      url.hash = `#${url.search}`;
      url.search = "";
    }
    return url.href;
  }
  /** Vai para a url
   ** mCaminho.ir({q:"query"})
   ** window.location.href = "http://localhost:3000/caminho?q=query"
   */
  ir(query) {
    if (this._acaoIr) {
      this._acaoIr(this.endereco({ ...query }));
    } else {
      if (typeof window != "undefined") {
        window.location.href = this.endereco({ ...query });
      }
    }
  }
  /** Retorna os parametros da url
   ** console.log(mCaminho.parametros())
   ** {q:"query"}
   */
  parametros(urlEntrada) {
    const url = urlEntrada ? new URL(urlEntrada) : new URL(
      typeof window !== "undefined" ? window.location.href : "http://localhost"
    );
    const query = url.searchParams;
    let queryObj = Object.fromEntries(query.entries());
    const hash = url.hash;
    if (hash) {
      const hashObj = Object.fromEntries(
        new URLSearchParams(hash.slice(1)).entries()
      );
      queryObj = { ...queryObj, ...hashObj };
    }
    for (const chave in queryObj) {
      try {
        queryObj[chave] = JSON.parse(queryObj[chave]);
      } catch {
        console.log(`[${chave}|${queryObj[chave]}] n\xE3o \xE9 um json v\xE1lido.`);
      }
    }
    return queryObj;
  }
}

var siglas_unidades_medida = /* @__PURE__ */ ((siglas_unidades_medida2) => {
  siglas_unidades_medida2["UN"] = "UN";
  siglas_unidades_medida2["KG"] = "KG";
  siglas_unidades_medida2["TON"] = "TON";
  siglas_unidades_medida2["g"] = "g";
  siglas_unidades_medida2["M\xB3"] = "M\xB3";
  siglas_unidades_medida2["Lt"] = "Lt";
  return siglas_unidades_medida2;
})(siglas_unidades_medida || {});
const unidades_medida = [
  {
    sigla_unidade: "KG",
    nome: "Quilograma",
    sigla_normalizada: "KG",
    normalizar: (valor) => valor,
    tipo: "massa"
  },
  {
    sigla_unidade: "g",
    nome: "Grama",
    sigla_normalizada: "KG",
    normalizar: (valor) => valor / 1e3,
    tipo: "massa"
  },
  {
    sigla_unidade: "TON",
    nome: "Tonelada",
    sigla_normalizada: "KG",
    normalizar: (valor) => valor * 1e3,
    tipo: "massa"
  },
  {
    sigla_unidade: "Lt",
    nome: "Litro",
    sigla_normalizada: "Lt",
    normalizar: (valor) => valor,
    tipo: "volume"
  },
  {
    sigla_unidade: "M\xB3",
    nome: "Metro C\xFAbico",
    sigla_normalizada: "Lt",
    normalizar: (valor) => valor * 1e3,
    tipo: "volume"
  },
  {
    sigla_unidade: "UN",
    nome: "Unidade",
    sigla_normalizada: "UN",
    normalizar: (valor) => valor,
    tipo: "unidade"
  }
];

const erUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
const validarUuid = (uuid2) => {
  const retorno = erUuid.test(String(uuid2 || ""));
  return retorno;
};
const uuidV3 = (chave, grupo) => {
  return v3(
    // Converte a chave para string (de forma segura)
    typeof chave === "string" ? chave : typeof chave === "number" ? String(chave) : JSON.stringify(chave),
    // Se um grupo foi fornecido, gera um UUID v3 recursivamente com base nele, senão usa NIL
    grupo ? uuidV3(grupo) : NIL
  );
};
const uuidV4 = v4;
const uuid = uuidV4;

export { TipagemRotas, aleatorio, cacheM, cacheMFixo, cacheMemoria, camposComuns, cdn_carro_de_boi, dayjsbr, defineCwd, erUuid, esperar, extensoes, graficos_pilao, localValor, logger, nomeVariavel, objetoPg, operadores, paraObjetoRegistroPg, pgObjeto, postLogger, siglas_unidades_medida, texto_busca, tipoArquivo, tipoUsuarioResiduos, tx, umaFuncao, umaVariavel, unidades_medida, uuid, uuidV3, uuidV4, uuid_null, validarUuid, verCacheM, zFiltro, zOperadores };