@greatapps/common 1.1.675 → 1.1.677

package/src/modules/accounts/hooks/use-currency-formatter.hook.tsx

@@ -0,0 +1,32 @@
+'use client';
+
+import { useCurrentAccount } from './current-account.hook';
+import {
+  formatCurrency as formatCurrencyBase,
+  formatCurrencyNumber as formatCurrencyNumberBase,
+  getCurrencyForGateway,
+  type CurrencyCode,
+} from '../../../utils/format/currency';
+
+/**
+ * Formatadores de moeda já amarrados à moeda da conta atual (derivada de account.gateway).
+ *
+ * Use em componentes client para exibir preços sem passar a moeda manualmente — a moeda é
+ * determinada pelo backend (roteamento de gateway) e é read-only para o usuário.
+ *
+ * Conta stripe_usd → USD ('$1,234.56'); demais → BRL ('R$ 1.234,56').
+ */
+export function useCurrencyFormatter(): {
+  currency: CurrencyCode;
+  formatCurrency: (value: string | number) => string;
+  formatCurrencyNumber: (value?: number | null, decimals?: number) => string;
+} {
+  const { data: account } = useCurrentAccount();
+  const currency = getCurrencyForGateway(account?.gateway);
+
+  return {
+    currency,
+    formatCurrency: (value) => formatCurrencyBase(value, currency),
+    formatCurrencyNumber: (value, decimals = 2) => formatCurrencyNumberBase(value, decimals, currency),
+  };
+}

package/src/modules/cards/hooks/handle-delete-card.hook.ts

@@ -3,6 +3,7 @@
 import { useCallback } from 'react';
 import { useModalManager } from '../../../store/useModalManager';
 import { useActiveSubscription } from '../../subscriptions/hooks/find-active-subscription.hook';
+import { hasSubscriptionExpired } from '../../subscriptions/utils/has-subscription-expired';
 import type { Card } from '../types';
 
 type UseHandleDeleteCardOptions = {
@@ -18,11 +19,15 @@ export function useHandleDeleteCard({
 
   return useCallback(
     (card: Card) => {
+      // Só bloqueia a exclusão quando o cartão é o método de pagamento de uma
+      // assinatura REALMENTE ativa (mesma definição de ConfigurationsMyAccountModal).
+      // Se a assinatura foi cancelada ou já expirou, ela não está mais ativa —
+      // pula a verificação e segue direto pra exclusão do cartão.
       const isCardLinkedToSubscription =
         !!activeSubscription &&
-        !!activeSubscription.date_cancellation &&
-        (!activeSubscription.date_due ||
-          activeSubscription.date_due < new Date()) &&
+        activeSubscription.active === true &&
+        !activeSubscription.date_cancellation &&
+        !hasSubscriptionExpired(activeSubscription.date_due) &&
         card.id.toString() === activeSubscription.id_card?.toString();
 
       if (isCardLinkedToSubscription) {

package/src/modules/images/utils/validate-image.ts

@@ -3,17 +3,24 @@ import {
   MAX_FILE_SIZE_MB,
 } from '../constants/image.constants'
 
+type TranslateFn = (key: any, values?: Record<string, string | number>) => string;
+
 export interface ImageValidationResult {
   valid: boolean
   error?: string
 }
 
-export function validateImageFormat(file: File): ImageValidationResult {
+export function validateImageFormat(
+  file: File,
+  translate?: TranslateFn
+): ImageValidationResult {
   // Bloqueia SVG explicitamente (segurança + não funciona com crop)
   if (file.type === 'image/svg+xml' || file.name.toLowerCase().endsWith('.svg')) {
     return {
       valid: false,
-      error: 'Formato SVG não é suportado. Use PNG, JPEG, WebP ou GIF.',
+      error: translate
+        ? translate('common.imageUpload.errorSvg')
+        : 'Formato SVG não é suportado. Use PNG, JPEG, WebP ou GIF.',
     }
   }
 
@@ -24,7 +31,9 @@ export function validateImageFormat(file: File): ImageValidationResult {
   ) {
     return {
       valid: false,
-      error: 'Formato não suportado. Use PNG, JPEG, WebP ou GIF.',
+      error: translate
+        ? translate('common.imageUpload.errorFormat')
+        : 'Formato não suportado. Use PNG, JPEG, WebP ou GIF.',
     }
   }
   return { valid: true }
@@ -32,22 +41,28 @@ export function validateImageFormat(file: File): ImageValidationResult {
 
 export function validateImageSize(
   file: File,
-  maxSizeMB: number = MAX_FILE_SIZE_MB
+  maxSizeMB: number = MAX_FILE_SIZE_MB,
+  translate?: TranslateFn
 ): ImageValidationResult {
   if (file.size > maxSizeMB * 1024 * 1024) {
     return {
       valid: false,
-      error: `Arquivo muito grande. Máximo ${maxSizeMB}MB.`,
+      error: translate
+        ? translate('common.imageUpload.errorTooLarge', { maxSize: maxSizeMB })
+        : `Arquivo muito grande. Máximo ${maxSizeMB}MB.`,
     }
   }
   return { valid: true }
 }
 
-export function validateImage(file: File): ImageValidationResult {
-  const formatValidation = validateImageFormat(file)
+export function validateImage(
+  file: File,
+  translate?: TranslateFn
+): ImageValidationResult {
+  const formatValidation = validateImageFormat(file, translate)
   if (!formatValidation.valid) return formatValidation
 
-  const sizeValidation = validateImageSize(file)
+  const sizeValidation = validateImageSize(file, MAX_FILE_SIZE_MB, translate)
   if (!sizeValidation.valid) return sizeValidation
 
   return { valid: true }

package/src/modules/plans/hooks/list-plans.hook.ts

@@ -13,11 +13,11 @@ export function usePlans() {
   return useQuery<Plan[]>({
     queryKey,
     queryFn: ({ signal }) => apiFetch<Plan[]>('/api/plans', { signal }),
-    staleTime: Infinity,
+    staleTime: 60 * 1000,
     gcTime: Infinity,
     refetchOnWindowFocus: false,
     refetchOnReconnect: false,
-    refetchOnMount: false,
+    refetchOnMount: true,
     retry: 1,
   });
 }

package/src/modules/plans/types/plan.type.ts

@@ -5,6 +5,7 @@ export const PlanItemSchema = z.object({
   id_addon: z.number(),
   quantity: z.number(),
   value: z.number(),
+  value_usd: z.coerce.number().nullish(),
 });
 
 export type PlanItem = z.infer<typeof PlanItemSchema>;
@@ -14,6 +15,9 @@ export const PlanSchema = z.object({
   id_plan: z.number().optional(),
   name: z.string(),
   value: z.number().default(0),
+  // Preço em USD (conta stripe_usd). Operador cadastra no backend; ausente em planos
+  // sem suporte internacional. Espelha a coluna value_usd de gapps-r3-api.
+  value_usd: z.coerce.number().nullish(),
   type: z.string().optional(),
   discount_semester: z.number().default(0),
   discount_annual: z.number().default(0),

package/src/modules/plans/utils/map-api-plan-to-ui.ts

@@ -6,45 +6,85 @@ import type {
   UiPlan,
 } from "../types/plan.type";
 import { ADDON_IDS } from "../../subscriptions/constants/addons.constants";
-import { formatCurrencyNumber } from "../../../utils/format/currency";
+import {
+  formatCurrencyNumber,
+  type CurrencyCode,
+} from "../../../utils/format/currency";
 
 export type PlanBillingPeriod = "monthly" | "semiannual" | "annual";
 
-const BASE_FEATURES: PlanFeature[] = [
-  { icon: "check", text: "Visitas ilimitadas" },
-  { icon: "check", text: "Leads ilimitadas" },
-  { icon: "check", text: "Compartilhar páginas", tooltip: "sharePages" },
-  { icon: "check", text: "Hospedagem inclusa" },
-  { icon: "check", text: "SSL (HTTPS) + CDN" },
-  { icon: "check", text: "Templates gratuitos" },
-];
+type TranslateFn = (key: any, values?: Record<string, string | number>) => string;
 
-function buildMainFeaturesFromItems(items: Plan["items"]): PlanMainFeatures {
+const BASE_FEATURES_KEYS = [
+  { icon: "check", key: "plans.features.unlimitedVisits",  fallback: "Visitas ilimitadas" },
+  { icon: "check", key: "plans.features.unlimitedLeads",   fallback: "Leads ilimitadas" },
+  { icon: "check", key: "plans.features.sharePages",        fallback: "Compartilhar páginas", tooltip: "sharePages" },
+  { icon: "check", key: "plans.features.hosting",           fallback: "Hospedagem inclusa" },
+  // SSL (HTTPS) + CDN — brand/acronym: never translated
+  { icon: "check", key: null,                               fallback: "SSL (HTTPS) + CDN" },
+  { icon: "check", key: "plans.features.freeTemplates",     fallback: "Templates gratuitos" },
+] as const;
+
+function buildBaseFeatures(translate?: TranslateFn): PlanFeature[] {
+  return BASE_FEATURES_KEYS.map(({ icon, key, fallback, ...rest }) => {
+    const text = key && translate ? translate(`common.${key}`) : fallback;
+    const feature: PlanFeature = { icon, text };
+    if ("tooltip" in rest && rest.tooltip) feature.tooltip = rest.tooltip;
+    return feature;
+  });
+}
+
+function buildMainFeaturesFromItems(
+  items: Plan["items"],
+  translate?: TranslateFn
+): PlanMainFeatures {
   const pagesItem = items.find((i) => i.id_addon === ADDON_IDS.PAGES);
   const domainsItem = items.find((i) => i.id_addon === ADDON_IDS.DOMAINS);
 
   const pagesQty = pagesItem?.quantity ?? 0;
   const domainsQty = domainsItem?.quantity ?? 1;
 
-  return {
-    pages:
-      pagesQty === 0
-        ? "Páginas ilimitadas"
-        : pagesQty === 1
-          ? "1 página"
-          : `${pagesQty} páginas`,
-    domains:
-      domainsQty >= 999
-        ? "Domínios ilimitados"
-        : domainsQty === 1
-          ? "1 domínio externo"
-          : `${domainsQty} domínios externos`,
-    users: "Usuários ilimitados",
-  };
+  let pages: string;
+  if (pagesQty === 0) {
+    pages = translate
+      ? translate("common.plans.mainFeatures.pagesUnlimited")
+      : "Páginas ilimitadas";
+  } else if (pagesQty === 1) {
+    pages = translate
+      ? translate("common.plans.mainFeatures.pageSingular")
+      : "1 página";
+  } else {
+    pages = translate
+      ? translate("common.plans.mainFeatures.pagesPlural", { count: pagesQty })
+      : `${pagesQty} páginas`;
+  }
+
+  let domains: string;
+  if (domainsQty >= 999) {
+    domains = translate
+      ? translate("common.plans.mainFeatures.domainsUnlimited")
+      : "Domínios ilimitados";
+  } else if (domainsQty === 1) {
+    domains = translate
+      ? translate("common.plans.mainFeatures.domainSingular")
+      : "1 domínio externo";
+  } else {
+    domains = translate
+      ? translate("common.plans.mainFeatures.domainsPlural", { count: domainsQty })
+      : `${domainsQty} domínios externos`;
+  }
+
+  const users = translate
+    ? translate("common.plans.mainFeatures.usersUnlimited")
+    : "Usuários ilimitados";
+
+  return { pages, domains, users };
 }
 
-function computePricingByPeriod(apiPlan: Plan): PlanPricingByPeriod {
-  const monthly = apiPlan.value;
+function computePricingByPeriod(apiPlan: Plan, currency: CurrencyCode): PlanPricingByPeriod {
+  // Conta USD usa value_usd; fallback pro value (BRL) evita NaN quando o operador ainda
+  // não cadastrou o preço internacional. Os descontos por período são percentuais — aplicam igual.
+  const monthly = currency === "usd" ? (apiPlan.value_usd ?? apiPlan.value) : apiPlan.value;
   const round2 = (n: number) => Math.round(n * 100) / 100;
   return {
     monthly,
@@ -53,46 +93,68 @@ function computePricingByPeriod(apiPlan: Plan): PlanPricingByPeriod {
   };
 }
 
-export function mapApiPlanToUiPlan(plan: Plan): UiPlan {
+function buildUiPlan(plan: Plan, currency: CurrencyCode, translate?: TranslateFn): UiPlan {
   const popular = plan.id === 2 || plan.id_plan === 2;
   const buttonVariant = popular ? "brand" : "default";
 
-  const pricingByPeriod = computePricingByPeriod(plan);
+  const pricingByPeriod = computePricingByPeriod(plan, currency);
   const monthlyFinal = pricingByPeriod.monthly;
 
   const lowerName = plan.name.toLowerCase();
   const hasProjectAndOnboarding =
     lowerName.includes("agência") || lowerName.includes("agencia");
 
+  const onboardingText = translate
+    ? translate("common.plans.features.onboarding")
+    : "Reunião de Onboarding";
+  const projectMgmtText = translate
+    ? translate("common.plans.features.projectManagement")
+    : "Gestão de projetos";
+
   const features: PlanFeature[] = [
-    ...BASE_FEATURES,
+    ...buildBaseFeatures(translate),
     hasProjectAndOnboarding
-      ? { icon: "check", text: "Reunião de Onboarding" }
-      : { icon: "x", text: "Reunião de Onboarding", disabled: true },
+      ? { icon: "check", text: onboardingText }
+      : { icon: "x", text: onboardingText, disabled: true },
     hasProjectAndOnboarding
-      ? {
-          icon: "check",
-          text: "Gestão de projetos",
-          tooltip: "projectManagement",
-        }
-      : {
-          icon: "x",
-          text: "Gestão de projetos",
-          disabled: true,
-          tooltip: "projectManagement",
-        },
+      ? { icon: "check", text: projectMgmtText, tooltip: "projectManagement" }
+      : { icon: "x",     text: projectMgmtText, disabled: true, tooltip: "projectManagement" },
   ];
 
+  const currencyAwareItems = plan.items.map((item) => ({
+    ...item,
+    value: currency === "usd" ? (item.value_usd ?? item.value) : item.value,
+  }));
+
   return {
     planId: plan.id,
     name: plan.name,
     isPopular: popular,
     buttonVariant,
-    mainFeatures: buildMainFeaturesFromItems(plan.items),
+    mainFeatures: buildMainFeaturesFromItems(plan.items, translate),
     features,
-    originalPrice: formatCurrencyNumber(monthlyFinal),
-    price: formatCurrencyNumber(monthlyFinal),
+    originalPrice: formatCurrencyNumber(monthlyFinal, 2, currency),
+    price: formatCurrencyNumber(monthlyFinal, 2, currency),
     pricingByPeriod,
-    items: plan.items,
+    items: currencyAwareItems,
   };
 }
+
+/**
+ * Mapeia um plano da API para UiPlan em BRL.
+ * Assinatura de 1 argumento — seguro em `plans.map(mapApiPlanToUiPlan)`.
+ * Passa `translate` opcional para i18n; sem ele cai nos literais pt-br (back-compat).
+ */
+export function mapApiPlanToUiPlan(plan: Plan, translate?: TranslateFn): UiPlan {
+  return buildUiPlan(plan, "brl", translate);
+}
+
+/**
+ * Variante currency-aware: a moeda vem do gateway da conta (getCurrencyForGateway).
+ * Fábrica para uso ergonômico em `.map`: `plans.map(mapApiPlanToUiPlanForCurrency(currency, translate))`.
+ * Mantida separada de mapApiPlanToUiPlan para não quebrar callers que passam a fn direto pro `.map`.
+ */
+export const mapApiPlanToUiPlanForCurrency =
+  (currency: CurrencyCode, translate?: TranslateFn) =>
+  (plan: Plan): UiPlan =>
+    buildUiPlan(plan, currency, translate);

package/src/modules/projects/services/projects.service.ts

@@ -131,6 +131,18 @@ class ProjectsService {
       body: JSON.stringify({ id_project_to_move: moveToProjectId }),
     });
 
+    // Alguns backends respondem `null` no delete quando a exclusão foi bem-sucedida.
+    // Nesse caso não há payload para validar e o fluxo deve seguir sem erro.
+    if (response == null) {
+      console.warn('[ProjectsService.delete] null response treated as success', {
+        id_account,
+        id_user,
+        projectId,
+        moveToProjectId,
+      });
+      return;
+    }
+
     if (response.status === 0) {
       throw new ApiError(
         response.message || 'Erro ao deletar projeto',

package/src/modules/subscriptions/utils/periodicity.ts

@@ -1,6 +1,8 @@
 import type { BillingPeriod } from '../types/billing-period.type';
 import type { CalculateSubscriptionResponse } from '../types/calculate-subscription.type';
 
+type TranslateFn = (key: any, values?: Record<string, string | number>) => string;
+
 export function periodicityToBillingPeriod(
   periodicity: number | string | null | undefined
 ): BillingPeriod | null {
@@ -16,23 +18,38 @@ export function billingPeriodToNumeric(billingPeriod: BillingPeriod): 30 | 180 |
   return 30;
 }
 
-export function getPeriodicityLabel(periodicity: number | string | null | undefined): string {
+export function getPeriodicityLabel(
+  periodicity: number | string | null | undefined,
+  translate?: TranslateFn
+): string {
   const period = periodicityToBillingPeriod(periodicity);
-  if (period === 'semiannual') return 'Semestral';
-  if (period === 'annual') return 'Anual';
-  return 'Mensal';
+  if (period === 'semiannual')
+    return translate ? translate('common.periodicity.semiannual') : 'Semestral';
+  if (period === 'annual')
+    return translate ? translate('common.periodicity.annual') : 'Anual';
+  return translate ? translate('common.periodicity.monthly') : 'Mensal';
 }
 
-export function getBillingPeriodSuffix(billingPeriod: BillingPeriod): string {
-  if (billingPeriod === 'semiannual') return '/semestre';
-  if (billingPeriod === 'annual') return '/ano';
-  return '/mês';
+export function getBillingPeriodSuffix(
+  billingPeriod: BillingPeriod,
+  translate?: TranslateFn
+): string {
+  if (billingPeriod === 'semiannual')
+    return translate ? translate('common.periodicity.suffixSemiannual') : '/semestre';
+  if (billingPeriod === 'annual')
+    return translate ? translate('common.periodicity.suffixAnnual') : '/ano';
+  return translate ? translate('common.periodicity.suffixMonthly') : '/mês';
 }
 
-export function getBillingPeriodLabel(billingPeriod: BillingPeriod): string {
-  if (billingPeriod === 'semiannual') return 'semestral';
-  if (billingPeriod === 'annual') return 'anual';
-  return 'mensal';
+export function getBillingPeriodLabel(
+  billingPeriod: BillingPeriod,
+  translate?: TranslateFn
+): string {
+  if (billingPeriod === 'semiannual')
+    return translate ? translate('common.periodicity.labelSemiannual') : 'semestral';
+  if (billingPeriod === 'annual')
+    return translate ? translate('common.periodicity.labelAnnual') : 'anual';
+  return translate ? translate('common.periodicity.labelMonthly') : 'mensal';
 }
 
 export function getBillingPeriodMonths(billingPeriod: BillingPeriod): number {

package/src/providers/auth.provider.tsx

@@ -5,6 +5,7 @@ import {
   ReactNode,
   useCallback,
   useContext,
+  useEffect,
   useMemo,
 } from "react";
 import { useQueryClient } from "@tanstack/react-query";
@@ -41,8 +42,10 @@ import {
   useCurrentAccount,
   ACCOUNT_QUERY_KEY,
 } from "../modules/accounts/hooks/current-account.hook";
-import { useWhitelabelUrls } from "./whitelabel.provider";
+import { useWhitelabelUrls, useWhitelabel } from "./whitelabel.provider";
 import { useWlQueryKey } from "../hooks/useAuthQueryKey";
+import { normalizeLocale } from "../i18n/normalize";
+import { setLocaleCookie } from "../utils/intl/locale-cookie";
 
 interface AuthContextProps extends AuthState {
   login: (credentials: LoginRequest) => Promise<LoginResult>;
@@ -68,8 +71,17 @@ export function AuthProvider({ children }: AuthProviderProps) {
   const queryClient = useQueryClient();
   const setUserData = useSetUserData();
   const { accountsUrl, pagesUrl } = useWhitelabelUrls();
+  const { whitelabel } = useWhitelabel();
   const accountKey = useWlQueryKey([...ACCOUNT_QUERY_KEY]);
 
+  // Mantém o cookie NEXT_LOCALE alinhado à preferência da conta (login, sessão existente,
+  // atualização). Compartilhado entre subdomínios via domínio do whitelabel. A próxima
+  // navegação/requisição passa a resolver o locale pela preferência do usuário.
+  useEffect(() => {
+    const locale = normalizeLocale(user?.language);
+    if (locale) setLocaleCookie(locale, whitelabel?.domain);
+  }, [user?.language, whitelabel?.domain]);
+
   const { mutateAsync: loginMutate, isPending: isLogging } = useLogin();
   const { mutateAsync: registerMutate, isPending: isRegistering } =
     useRegister();

package/src/server.ts

@@ -74,6 +74,8 @@ export {
 // Server Utils
 export { getClientInfoFromRequest } from './infra/utils/client-info';
 export { getUserContext } from './modules/auth/utils/get-user-context';
+export { resolveLocale } from './i18n/resolve-locale';
+export type { ResolveLocaleOptions } from './i18n/resolve-locale';
 export { requireValidSession } from './modules/auth/utils/require-valid-session';
 export { requireTokenNotExpired } from './modules/auth/utils/require-token-not-expired';
 export { buildWlOverride, buildWlOverrideFromJwt } from './modules/auth/utils/build-wl-override';

package/src/utils/format/currency.ts

@@ -1,14 +1,69 @@
 /**
- * Formata um número (opcional) para moeda BRL
- * @param value - Número a ser formatado (pode ser undefined ou null)
- * @param decimals - Casas decimais (padrão: 2)
- * @returns String formatada como "R$ X.XXX,XX"
+ * Moeda de exibição. Espelha getCurrencyForGateway do backend (gapps-r3-api):
+ * 'stripe_usd' → USD; demais gateways → BRL.
  */
-export const formatCurrencyNumber = (value?: number | null, decimals = 2): string => {
+export type CurrencyCode = 'brl' | 'usd';
+
+const CURRENCY_FORMAT: Record<CurrencyCode, { locale: string; currency: string }> = {
+  brl: { locale: 'pt-BR', currency: 'BRL' },
+  usd: { locale: 'en-US', currency: 'USD' },
+};
+
+/**
+ * Deriva a moeda de exibição a partir do gateway da conta.
+ * A moeda é definida pelo backend no roteamento de gateway — read-only para o usuário.
+ * @param gateway - account.gateway ('stripe_usd' | 'stripe_brl' | 'vindi' | ...)
+ */
+export const getCurrencyForGateway = (gateway?: string | null): CurrencyCode =>
+  gateway === 'stripe_usd' ? 'usd' : 'brl';
+
+/**
+ * Formata um valor (string ou número) como moeda.
+ * String: assume centavos (remove não-dígitos e divide por 100) — comportamento legado.
+ * @param value - valor a formatar
+ * @param currency - moeda de exibição (padrão 'brl' por retrocompatibilidade)
+ * @returns String formatada (ex: "R$ 1.234,56" ou "$1,234.56")
+ */
+export const formatCurrency = (value: string | number, currency: CurrencyCode = 'brl'): string => {
+  const fmt = CURRENCY_FORMAT[currency];
+  if (typeof value === 'number') {
+    return value.toLocaleString(fmt.locale, {
+      style: 'currency',
+      currency: fmt.currency,
+    });
+  }
+
+  const numericValue = value.replace(/\D/g, '');
+  const numberValue = parseFloat(numericValue) / 100;
+  return numberValue.toLocaleString(fmt.locale, {
+    style: 'currency',
+    currency: fmt.currency,
+  });
+};
+
+/**
+ * Converte uma string de moeda para número (centavos / 100). Independente de moeda.
+ * @param value - String com valor de moeda
+ * @returns Número decimal
+ */
+export const parseCurrencyToNumber = (value: string): number => {
+  const numericValue = value.replace(/\D/g, '');
+  return parseFloat(numericValue) / 100;
+};
+
+/**
+ * Formata um número (opcional) como moeda.
+ * @param value - Número a formatar (pode ser undefined/null → 0)
+ * @param decimals - Casas decimais (padrão 2)
+ * @param currency - Moeda de exibição (padrão 'brl' por retrocompatibilidade)
+ * @returns String formatada (ex: "R$ 1.234,56" ou "$1,234.56")
+ */
+export const formatCurrencyNumber = (value?: number | null, decimals = 2, currency: CurrencyCode = 'brl'): string => {
   const safeValue = value ?? 0;
-  return safeValue.toLocaleString('pt-BR', {
+  const fmt = CURRENCY_FORMAT[currency];
+  return safeValue.toLocaleString(fmt.locale, {
     style: 'currency',
-    currency: 'BRL',
+    currency: fmt.currency,
     minimumFractionDigits: decimals,
     maximumFractionDigits: decimals,
   });

package/src/utils/intl/cookie-domain.ts

@@ -0,0 +1,29 @@
+/**
+ * Deriva o domínio de cookie compartilhável entre subdomínios a partir do domínio do
+ * whitelabel (ex.: `https://app.greatpages.com.br` → `.app.greatpages.com.br`).
+ *
+ * Mesma normalização usada pelo cookie de auth `greatapps` (auth.service.normalizeCookieDomain),
+ * para que o cookie de locale acompanhe o mesmo escopo. Pura (sem APIs de servidor) → client+server.
+ * Retorna `undefined` para localhost/host inválido (cookie fica host-scoped).
+ */
+export function cookieDomainFromDomain(domain?: string | null): string | undefined {
+  if (!domain) return undefined;
+
+  const normalized = domain.trim();
+  if (!normalized) return undefined;
+
+  let rawHost: string;
+  try {
+    rawHost = new URL(normalized).hostname;
+  } catch {
+    rawHost = normalized
+      .replace(/^https?:\/\//i, '')
+      .replace(/^www\./i, '')
+      .split('/')[0]
+      .split(':')[0];
+  }
+
+  if (!rawHost || rawHost === 'localhost') return undefined;
+
+  return rawHost.startsWith('.') ? rawHost : `.${rawHost}`;
+}

package/src/utils/intl/locale-cookie.ts

@@ -0,0 +1,18 @@
+import { LOCALE_COOKIE } from '../../i18n/config';
+import { cookieDomainFromDomain } from './cookie-domain';
+
+const ONE_YEAR = 60 * 60 * 24 * 365;
+
+/**
+ * Persiste o locale escolhido no cookie `NEXT_LOCALE` (lido por `resolveLocale` no servidor).
+ *
+ * Passe `whitelabelDomain` (de `useWhitelabel().whitelabel?.domain`) para o cookie ser
+ * compartilhado entre subdomínios (accounts. → pages. → apps.), no mesmo escopo do cookie
+ * de auth. Sem ele, o cookie fica host-scoped.
+ */
+export function setLocaleCookie(locale: string, whitelabelDomain?: string | null): void {
+  if (typeof document === 'undefined') return;
+  const domain = cookieDomainFromDomain(whitelabelDomain);
+  const domainAttr = domain ? `; domain=${domain}` : '';
+  document.cookie = `${LOCALE_COOKIE}=${locale}; path=/; max-age=${ONE_YEAR}; samesite=lax${domainAttr}`;
+}

package/src/utils/intl/locales.ts

@@ -6,8 +6,9 @@ export type LocaleOption = {
 };
 
 export const LANGUAGE_OPTIONS: LocaleOption[] = [
-  { value: 'pt-BR', label: 'Português (Brasil)', displayValue: 'Português (Brasil)', apiValue: 'pt-br' },
-  { value: 'en-US', label: 'Inglês (EUA)', displayValue: 'Inglês (EUA)', apiValue: 'en' },
+  { value: 'pt-br', label: 'Português (Brasil)', displayValue: 'Português (Brasil)', apiValue: 'pt-br' },
+  { value: 'en-us', label: 'Inglês (EUA)', displayValue: 'Inglês (EUA)', apiValue: 'en' },
+  { value: 'es-es', label: 'Espanhol', displayValue: 'Espanhol', apiValue: 'es' },
 ];
 
 export function buildLocaleOptions(): LocaleOption[] {