@greatapps/common 1.1.789 → 1.1.791

package/src/store/useSubscriptionFlows.ts

@@ -0,0 +1,176 @@
+'use client';
+
+import { create } from 'zustand';
+import type { Charge } from '../modules/charges/types/charge.type';
+import type { CouponStripeData } from '../modules/coupons/types/coupon.type';
+import type { UiPlan } from '../modules/plans/types/plan.type';
+import type { BillingPeriod } from '../modules/subscriptions/types/billing-period.type';
+import type { Subscription } from '../modules/subscriptions/types/subscription.type';
+
+type PendingChange = NonNullable<Subscription['pending_change']>;
+
+export type PayChargeState = { charge: Charge } | null;
+
+/** Contexto da troca de plano: sem `targetPlan` é só gerenciamento dos adicionais do plano atual. */
+export type ChangePlanState = {
+  targetPlan?: UiPlan;
+  billingPeriod?: BillingPeriod;
+  isDowngrade?: boolean;
+  isReactivation?: boolean;
+  selectedCreditIndex?: number;
+} | null;
+
+export type PlansCatalogState = { appliedCouponStripeData?: CouponStripeData | null } | null;
+
+/**
+ * Payload compartilhado do downgrade: vitrine → motivo → ajuste de limites (quando o plano
+ * alvo não comporta o que a conta usa) ou direto para a troca de plano.
+ */
+export type DowngradeFlowState = {
+  targetPlan: UiPlan;
+  planName: string;
+  billingPeriod: BillingPeriod;
+  /** Limite que vale no downgrade: domínios inclusos no plano alvo, sem os extras pagos. */
+  planIncludedDomains: number;
+  /** null = páginas ilimitadas no plano alvo. */
+  planIncludedPages: number | null;
+  registeredDomains: number;
+  /**
+   * Recursos que estouraram o limite e ganham etapa no roteiro. Ficam no payload para a etapa
+   * não sumir quando o usuário resolve o excedente — resolvida, ela vira check.
+   */
+  domainsExceeded?: boolean;
+  pagesExceeded?: boolean;
+} | null;
+
+export type PixPaymentState = {
+  qrCode: string | null;
+  expiresAt: string | null;
+  correlationId: string;
+  /** Pró-rata em centavos quando o QR cobra só o delta do upgrade. */
+  payNowCents: number | null;
+} | null;
+
+/** Boleto recém-gerado na contratação: o dialog busca a cobrança da assinatura criada. */
+export type BoletoGeneratedState = { subscriptionId: string | number } | null;
+
+export type PaymentConfirmationState = {
+  planName?: string;
+  total: number;
+  periodLabel: string;
+  immediateChargeTotal: number | null;
+} | null;
+
+interface SubscriptionFlowsState {
+  /** Cobrança aberta no sheet de detalhes/recibo. */
+  receiptCharge: Charge | null;
+  /** Cobrança aberta no pagamento de fatura. */
+  payCharge: PayChargeState;
+  isBillingAddressOpen: boolean;
+  isPlanDetailsOpen: boolean;
+  isUsageReportOpen: boolean;
+  isCancelPlanOpen: boolean;
+  changePlan: ChangePlanState;
+  plansCatalog: PlansCatalogState;
+  downgradeReason: DowngradeFlowState;
+  cannotDowngrade: DowngradeFlowState;
+  pixPayment: PixPaymentState;
+  boletoGenerated: BoletoGeneratedState;
+  paymentConfirmation: PaymentConfirmationState;
+  pendingChange: PendingChange | null;
+  isOverdueReceiptRequested: boolean;
+
+  openReceipt: (charge: Charge) => void;
+  closeReceipt: () => void;
+  openPayCharge: (charge: Charge) => void;
+  closePayCharge: () => void;
+  openBillingAddress: () => void;
+  closeBillingAddress: () => void;
+  openPlanDetails: () => void;
+  closePlanDetails: () => void;
+  openUsageReport: () => void;
+  closeUsageReport: () => void;
+  openCancelPlan: () => void;
+  closeCancelPlan: () => void;
+  openChangePlan: (state?: NonNullable<ChangePlanState>) => void;
+  closeChangePlan: () => void;
+  openPlansCatalog: (state?: NonNullable<PlansCatalogState>) => void;
+  closePlansCatalog: () => void;
+  openDowngradeReason: (state: NonNullable<DowngradeFlowState>) => void;
+  closeDowngradeReason: () => void;
+  openCannotDowngrade: (state: NonNullable<DowngradeFlowState>) => void;
+  /** Promove a etapa de um excedente descoberto com o roteiro já aberto. */
+  updateCannotDowngrade: (patch: Partial<NonNullable<DowngradeFlowState>>) => void;
+  closeCannotDowngrade: () => void;
+  openPixPayment: (state: NonNullable<PixPaymentState>) => void;
+  closePixPayment: () => void;
+  openBoletoGenerated: (state: NonNullable<BoletoGeneratedState>) => void;
+  closeBoletoGenerated: () => void;
+  openPaymentConfirmation: (state: NonNullable<PaymentConfirmationState>) => void;
+  closePaymentConfirmation: () => void;
+  openPendingChange: (pendingChange: PendingChange) => void;
+  closePendingChange: () => void;
+  requestOverdueReceipt: () => void;
+  clearOverdueReceiptRequest: () => void;
+}
+
+/**
+ * Fluxos da aba Assinatura do modal Minha conta (recibo, pagamento, plano, relatório e catálogo).
+ * Ficam em store porque quem dispara são os cartões e a lista, e quem renderiza é
+ * `SubscriptionFlows`, montado uma única vez na seção.
+ */
+export const useSubscriptionFlows = create<SubscriptionFlowsState>((set) => ({
+  receiptCharge: null,
+  payCharge: null,
+  isBillingAddressOpen: false,
+  isPlanDetailsOpen: false,
+  isUsageReportOpen: false,
+  isCancelPlanOpen: false,
+  changePlan: null,
+  plansCatalog: null,
+  downgradeReason: null,
+  cannotDowngrade: null,
+  pixPayment: null,
+  boletoGenerated: null,
+  paymentConfirmation: null,
+  pendingChange: null,
+  isOverdueReceiptRequested: false,
+
+  openReceipt: (charge) => set({ receiptCharge: charge }),
+  closeReceipt: () => set({ receiptCharge: null }),
+  // Pagar sai do recibo: fecha um e abre o outro para não empilhar dois sheets da mesma cobrança.
+  openPayCharge: (charge) => set({ payCharge: { charge }, receiptCharge: null }),
+  closePayCharge: () => set({ payCharge: null }),
+  openBillingAddress: () => set({ isBillingAddressOpen: true }),
+  closeBillingAddress: () => set({ isBillingAddressOpen: false }),
+  openPlanDetails: () => set({ isPlanDetailsOpen: true }),
+  closePlanDetails: () => set({ isPlanDetailsOpen: false }),
+  openUsageReport: () => set({ isUsageReportOpen: true }),
+  closeUsageReport: () => set({ isUsageReportOpen: false }),
+  openCancelPlan: () => set({ isCancelPlanOpen: true }),
+  closeCancelPlan: () => set({ isCancelPlanOpen: false }),
+  openChangePlan: (state = {}) =>
+    set({ changePlan: state, plansCatalog: null, downgradeReason: null, cannotDowngrade: null }),
+  closeChangePlan: () => set({ changePlan: null }),
+  openPlansCatalog: (state = {}) => set({ plansCatalog: state }),
+  closePlansCatalog: () => set({ plansCatalog: null }),
+  openDowngradeReason: (state) => set({ downgradeReason: state }),
+  closeDowngradeReason: () => set({ downgradeReason: null }),
+  // Sair do roteiro encerra o downgrade inteiro: o motivo embaixo também fecha.
+  openCannotDowngrade: (state) => set({ cannotDowngrade: state, downgradeReason: null }),
+  updateCannotDowngrade: (patch) =>
+    set((current) =>
+      current.cannotDowngrade ? { cannotDowngrade: { ...current.cannotDowngrade, ...patch } } : {}
+    ),
+  closeCannotDowngrade: () => set({ cannotDowngrade: null }),
+  openPixPayment: (state) => set({ pixPayment: state }),
+  closePixPayment: () => set({ pixPayment: null }),
+  openBoletoGenerated: (state) => set({ boletoGenerated: state }),
+  closeBoletoGenerated: () => set({ boletoGenerated: null }),
+  openPaymentConfirmation: (state) => set({ paymentConfirmation: state }),
+  closePaymentConfirmation: () => set({ paymentConfirmation: null }),
+  openPendingChange: (pendingChange) => set({ pendingChange }),
+  closePendingChange: () => set({ pendingChange: null }),
+  requestOverdueReceipt: () => set({ isOverdueReceiptRequested: true }),
+  clearOverdueReceiptRequest: () => set({ isOverdueReceiptRequested: false }),
+}));

package/src/store/useTeamFlows.ts

@@ -0,0 +1,34 @@
+'use client';
+
+import { create } from 'zustand';
+import type { User } from '../modules/users/schema';
+
+/** Sheet de usuário: cadastro, ou edição/detalhes de um usuário já existente. */
+export type UserSheetState = { mode: 'add' } | { mode: 'edit'; user: User } | null;
+
+interface TeamFlowsState {
+  sheet: UserSheetState;
+  userToDelete: User | null;
+
+  openAddUser: () => void;
+  openEditUser: (user: User) => void;
+  closeUserSheet: () => void;
+  openDeleteUser: (user: User) => void;
+  closeDeleteUser: () => void;
+}
+
+/**
+ * Fluxos da aba Minha equipe do modal Minha conta (sheet de usuário e exclusão). Ficam em store
+ * porque quem dispara é a lista e quem renderiza é `TeamFlows`, montado uma única vez na seção.
+ */
+export const useTeamFlows = create<TeamFlowsState>((set) => ({
+  sheet: null,
+  userToDelete: null,
+
+  openAddUser: () => set({ sheet: { mode: 'add' } }),
+  openEditUser: (user) => set({ sheet: { mode: 'edit', user } }),
+  closeUserSheet: () => set({ sheet: null }),
+
+  openDeleteUser: (user) => set({ userToDelete: user }),
+  closeDeleteUser: () => set({ userToDelete: null }),
+}));

package/src/testing/factories/coupon.factory.ts

@@ -0,0 +1,17 @@
+import { faker } from '@faker-js/faker';
+import type { Coupon } from '../../modules/coupons/types/coupon.type';
+import { TEST_IDS } from '../constants';
+import { createMock } from './create-mock';
+
+export const createCouponMock = createMock<Coupon, Partial<Coupon>>((overrides) => ({
+  id: overrides?.id ?? 1,
+  id_wl: overrides?.id_wl ?? TEST_IDS.wl,
+  id_affiliate: overrides?.id_affiliate ?? null,
+  title: overrides?.title || faker.commerce.productName(),
+  code: overrides?.code || faker.string.alphanumeric(8).toUpperCase(),
+  discount: overrides?.discount ?? 10,
+  discount_type: overrides?.discount_type ?? 1,
+  active: overrides?.active ?? true,
+  deleted: overrides?.deleted ?? false,
+  stripe_data: overrides?.stripe_data ?? null,
+}));

package/src/testing/factories/index.ts

@@ -5,3 +5,6 @@ export { createAccountMock } from './account.factory';
 export { createWhitelabelMock, createWhitelabelTokenMock } from './whitelabel.factory';
 export { createSubscriptionMock, createSubscriptionItemMock } from './subscription.factory';
 export { createPlanMock, createPlanItemMock } from './plan.factory';
+export { createProjectMock } from './project.factory';
+export { createProjectUserMock } from './project-user.factory';
+export { createCouponMock } from './coupon.factory';

package/src/testing/factories/project-user.factory.ts

@@ -0,0 +1,15 @@
+import { faker } from '@faker-js/faker';
+import type { ProjectUser } from '../../modules/projects/types';
+import { UserProfile } from '../../modules/users/schema';
+import { TEST_IDS } from '../constants';
+import { createMock } from './create-mock';
+
+export const createProjectUserMock = createMock<ProjectUser, Partial<ProjectUser>>((overrides) => ({
+  id_user: overrides?.id_user ?? TEST_IDS.user,
+  id_account: overrides?.id_account ?? TEST_IDS.account,
+  id_project: overrides?.id_project ?? 1,
+  name: overrides?.name || faker.person.fullName(),
+  email: overrides?.email || faker.internet.email().toLowerCase(),
+  profile: overrides?.profile ?? UserProfile.viewer,
+  photo: overrides?.photo ?? null,
+}));

package/src/testing/factories/project.factory.ts

@@ -0,0 +1,19 @@
+import { faker } from '@faker-js/faker';
+import type { Project } from '../../modules/projects/types';
+import { TEST_IDS } from '../constants';
+import { createMock } from './create-mock';
+
+export const createProjectMock = createMock<Project, Partial<Project>>((overrides) => ({
+  id: overrides?.id ?? 1,
+  id_wl: overrides?.id_wl ?? TEST_IDS.wl,
+  id_account: overrides?.id_account ?? TEST_IDS.account,
+  title: overrides?.title || faker.company.name(),
+  photo: overrides?.photo ?? null,
+  id_api: overrides?.id_api ?? 1,
+  id_form_integration: overrides?.id_form_integration ?? null,
+  total_users: overrides?.total_users ?? 1,
+  deleted: overrides?.deleted ?? false,
+  datetime_add: overrides?.datetime_add || '2025-01-01 00:00:00',
+  datetime_alt: overrides?.datetime_alt || '2025-01-01 00:00:00',
+  datetime_del: overrides?.datetime_del ?? null,
+}));

package/src/testing/react/providers.tsx

@@ -23,6 +23,7 @@ export interface TestProvidersOptions {
   user?: User | null;
   account?: Account | null;
   whitelabel?: WhitelabelData | null;
+  isLoading?: boolean;
 }
 
 export function TestProviders({
@@ -38,7 +39,7 @@ export function TestProviders({
     user,
     account,
     isAuthenticated: !!user,
-    isLoading: false,
+    isLoading: opts.isLoading ?? false,
     login: notImpl,
     register: notImpl,
     logout: notImpl,

package/src/utils/browser/chart-custom-tooltip.ts

@@ -0,0 +1,85 @@
+const TOOLTIP_ID = 'chartjs-custom-tooltip';
+/** Acima dos overlays da lib (bandas z-1000..1070): o gráfico também é usado dentro de modais. */
+const TOOLTIP_Z_INDEX = '1100';
+
+type TooltipDataPoint = { datasetIndex: number; raw: unknown };
+type TooltipDataset = { label?: string; pointBackgroundColor?: unknown; backgroundColor?: unknown; borderColor?: unknown };
+type TooltipContext = {
+  chart: { canvas: HTMLCanvasElement; data: { datasets: TooltipDataset[] } };
+  tooltip: { opacity: number; body?: unknown; title: string[]; dataPoints: TooltipDataPoint[]; caretX: number; caretY: number };
+};
+
+/** Tooltip HTML do Chart.js (plugin `tooltip.external`), no mesmo visual dos gráficos dos apps. */
+export function chartCustomTooltip() {
+  return function external({ chart, tooltip }: TooltipContext) {
+    let tooltipEl = document.getElementById(TOOLTIP_ID);
+
+    if (!tooltipEl) {
+      tooltipEl = document.createElement('div');
+      tooltipEl.id = TOOLTIP_ID;
+      tooltipEl.className = 'pointer-events-none';
+      tooltipEl.style.zIndex = TOOLTIP_Z_INDEX;
+      tooltipEl.innerHTML = '<div></div>';
+      document.body.appendChild(tooltipEl);
+    }
+
+    if (tooltip.opacity === 0) {
+      tooltipEl.style.opacity = '0';
+      return;
+    }
+
+    if (tooltip.body) {
+      const title = tooltip.title[0] || '';
+      let innerHtml = `
+        <div class="flex flex-col gap-2 bg-white border border-zinc-200 shadow-lg p-3 rounded-lg">
+          <span class="paragraph-xsmall-medium text-zinc-600">${title}</span>
+          <div class="w-full h-px bg-zinc-200"></div>
+          <div class="flex items-center gap-3">
+      `;
+
+      tooltip.dataPoints.forEach((dataPoint) => {
+        const dataset = chart.data.datasets[dataPoint.datasetIndex];
+        const color = dataset.pointBackgroundColor || dataset.backgroundColor || dataset.borderColor || 'var(--color-zinc-950)';
+        const value = typeof dataPoint.raw === 'number' ? dataPoint.raw.toLocaleString('pt-BR') : String(dataPoint.raw);
+
+        innerHtml += `
+          <div class="flex flex-col gap-1.5">
+            <div class="flex items-center gap-1">
+              <div class="w-1.5 h-1.5 rounded-full shrink-0" style="background-color: ${String(color)}"></div>
+              <span class="paragraph-xsmall-medium text-zinc-950 truncate">${dataset.label || ''}</span>
+            </div>
+            <span class="paragraph-small-semibold text-zinc-950 truncate">${value}</span>
+          </div>
+        `;
+      });
+
+      innerHtml += '</div></div>';
+      tooltipEl.querySelector('div')!.innerHTML = innerHtml;
+    }
+
+    const canvasRect = chart.canvas.getBoundingClientRect();
+    const tooltipWidth = tooltipEl.offsetWidth || 200;
+    const tooltipHeight = tooltipEl.offsetHeight || 100;
+    const padding = 8;
+
+    let left = canvasRect.left + tooltip.caretX;
+    let top = canvasRect.top + tooltip.caretY - tooltipHeight - 10;
+
+    if (left - tooltipWidth / 2 < padding) left = padding + tooltipWidth / 2;
+    if (left + tooltipWidth / 2 > window.innerWidth - padding) left = window.innerWidth - padding - tooltipWidth / 2;
+    if (top < padding) top = canvasRect.top + tooltip.caretY + 10;
+    if (top + tooltipHeight > window.innerHeight - padding) top = window.innerHeight - padding - tooltipHeight;
+
+    tooltipEl.style.opacity = '1';
+    tooltipEl.style.position = 'fixed';
+    tooltipEl.style.left = `${left}px`;
+    tooltipEl.style.top = `${top}px`;
+    tooltipEl.style.transform = 'translateX(-50%)';
+    tooltipEl.style.transition = 'all 0.2s ease';
+  };
+}
+
+export function hideChartTooltip() {
+  const tooltipEl = document.getElementById(TOOLTIP_ID);
+  if (tooltipEl) tooltipEl.style.opacity = '0';
+}

package/src/utils/browser/get-css-variable.ts

@@ -0,0 +1,6 @@
+/** Valor computado de uma variável CSS (ex.: `--color-cyan-300`), com fallback quando o tema não a define. */
+export function getCSSVariable(variableName: string, fallback = ''): string {
+  if (typeof window === 'undefined') return fallback;
+  const value = getComputedStyle(document.documentElement).getPropertyValue(variableName).trim();
+  return value || fallback;
+}

package/src/utils/constants/scrollbar.ts

@@ -0,0 +1,10 @@
+/**
+ * Barra de rolagem fina e sempre visível.
+ *
+ * No macOS a barra padrão é flutuante e some quando a rolagem para, então a área rolável fica
+ * sem nenhuma pista de que rola. `scrollbar-width: auto` é o que devolve o controle aos
+ * pseudo-elementos `::-webkit-scrollbar` no Chrome — com `thin` ele ignora esses estilos e volta
+ * à barra que some.
+ */
+export const VISIBLE_SCROLLBAR =
+  '[scrollbar-width:auto] [&::-webkit-scrollbar]:w-1.5 [&::-webkit-scrollbar-track]:bg-transparent [&::-webkit-scrollbar-thumb]:rounded-full [&::-webkit-scrollbar-thumb]:bg-zinc-300';

package/src/utils/date-filter-period.ts

@@ -0,0 +1,34 @@
+import { DateFilterPeriod } from '../enums/DateFilterPeriod';
+
+/** Intervalo `YYYY-MM-DD` dos relatórios para um período do filtro de datas. */
+export function getReportDateRangeFromPeriod(period: DateFilterPeriod): { date_start: string; date_end: string } {
+  const end = new Date();
+  const start = new Date();
+  const toISO = (date: Date) => date.toISOString().slice(0, 10);
+
+  switch (period) {
+    case DateFilterPeriod.TODAY:
+      start.setTime(end.getTime());
+      break;
+    case DateFilterPeriod.YESTERDAY:
+      start.setDate(end.getDate() - 1);
+      end.setDate(end.getDate() - 1);
+      break;
+    case DateFilterPeriod.LAST_7_DAYS:
+      start.setDate(end.getDate() - 6);
+      break;
+    case DateFilterPeriod.LAST_30_DAYS:
+      start.setDate(end.getDate() - 29);
+      break;
+    case DateFilterPeriod.LAST_MONTH:
+      start.setMonth(end.getMonth() - 1);
+      start.setDate(1);
+      end.setDate(0);
+      break;
+    case DateFilterPeriod.ALL_TIME:
+      start.setFullYear(end.getFullYear() - 10);
+      break;
+  }
+
+  return { date_start: toISO(start), date_end: toISO(end) };
+}

package/src/utils/file/index.ts

@@ -3,3 +3,16 @@ export const fileToBase64 = async (file: File): Promise<string> => {
   const mimeType = file.type || 'application/octet-stream';
   return `data:${mimeType};base64,${buffer.toString('base64')}`;
 };
+
+export const isPDFFile = (file: File): boolean => file.type === 'application/pdf';
+
+/** Tamanho de arquivo legível: "1.2 MB". */
+export const formatFileSize = (bytes: number): string => {
+  if (bytes === 0) return '0 Bytes';
+
+  const k = 1024;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+};

package/src/utils/format/initials.ts

@@ -0,0 +1,10 @@
+/** Iniciais de um nome ("Projeto Vendas" → "PV"), ignorando pontuação ("(corpus" conta como "c"). */
+export function getInitials(name?: string | null, maxLength = 2): string {
+  if (!name) return '';
+  return name
+    .split(/\s+/)
+    .map((word) => word.match(/[\p{L}\p{N}]/u)?.[0] ?? '')
+    .join('')
+    .slice(0, maxLength)
+    .toUpperCase();
+}

package/src/utils/format/masks.ts

@@ -61,3 +61,44 @@ export function formatTimer(seconds: number): string {
   const s = seconds % 60;
   return `${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}`;
 }
+
+export function formatCPFCNPJ(value: string): string {
+  const numbers = value.replace(/\D/g, '');
+  if (numbers.length <= 11) {
+    return formatCPF(value);
+  }
+  // CNPJ: 00.000.000/0000-00
+  if (numbers.length <= 2) return numbers;
+  if (numbers.length <= 5) return `${numbers.slice(0, 2)}.${numbers.slice(2)}`;
+  if (numbers.length <= 8)
+    return `${numbers.slice(0, 2)}.${numbers.slice(2, 5)}.${numbers.slice(5)}`;
+  if (numbers.length <= 12)
+    return `${numbers.slice(0, 2)}.${numbers.slice(2, 5)}.${numbers.slice(5, 8)}/${numbers.slice(8)}`;
+  return `${numbers.slice(0, 2)}.${numbers.slice(2, 5)}.${numbers.slice(5, 8)}/${numbers.slice(8, 12)}-${numbers.slice(12, 14)}`;
+}
+
+/**
+ * Só mascara quando o valor é puramente dígitos (e possivelmente pontuação de documento) com 11 ou
+ * 14 dígitos. Documento legado fora desse formato volta como veio, em vez de mascarar algo que não
+ * é documento.
+ */
+function formatIfCpfCnpjShaped(value: string): string {
+  if (!/^[\d.\-/]+$/.test(value)) return value;
+  const digits = value.replace(/\D/g, '');
+  if (digits.length !== 11 && digits.length !== 14) return value;
+  return formatCPFCNPJ(value);
+}
+
+/** Documento do titular: CPF/CNPJ mascarado; qualquer outro conteúdo volta intacto. */
+export const formatDocument = formatIfCpfCnpjShaped;
+
+/** Chave PIX: só mascara quando a chave é o próprio CPF/CNPJ; e-mail, telefone e aleatória saem como estão. */
+export const formatPixKey = formatIfCpfCnpjShaped;
+
+/** Tira a máscara antes de gravar; valor que não é CPF/CNPJ volta como veio. */
+export function normalizeCpfCnpjForStorage(value: string): string {
+  if (!/^[\d.\-/]+$/.test(value)) return value;
+  const digits = value.replace(/\D/g, '');
+  if (digits.length !== 11 && digits.length !== 14) return value;
+  return digits;
+}

package/src/utils/qrcode/to-data-url.ts

@@ -0,0 +1,23 @@
+'use client';
+
+/**
+ * Build de browser do `qrcode`: a entrada padrão do pacote puxa `pngjs`/`stream`, que o SSR do
+ * Next não resolve. O subpath não tem tipos próprios, então o `any` fica isolado aqui e quem
+ * chama recebe uma `Promise<string>` tipada.
+ */
+// @ts-expect-error — `qrcode/lib/browser.js` não publica declarações de tipo.
+import QRCode from 'qrcode/lib/browser.js';
+
+type QrCodeOptions = {
+  width?: number;
+  margin?: number;
+  errorCorrectionLevel?: 'L' | 'M' | 'Q' | 'H';
+  color?: { dark?: string; light?: string };
+};
+
+export function qrCodeToDataUrl(text: string, options?: QrCodeOptions): Promise<string> {
+  return (QRCode as { toDataURL: (t: string, o?: QrCodeOptions) => Promise<string> }).toDataURL(
+    text,
+    options
+  );
+}

package/src/utils/validators/account.ts

@@ -1,13 +1,5 @@
 import { z } from 'zod';
 
-export const myProfileSchema = z.object({
-  name: z.string().min(1, 'Nome é obrigatório'),
-  last_name: z.string().min(1, 'Sobrenome é obrigatório'),
-  gender: z.string().optional(),
-});
-
-export type MyProfileFormData = z.infer<typeof myProfileSchema>;
-
 export const changePasswordSchema = z.object({
   currentPassword: z.string().min(1, 'Senha atual é obrigatória'),
   newPassword: z