@fayz-ai/plugin-agenda 0.9.0 → 0.10.0

package/src/public/context.tsx

@@ -1,103 +0,0 @@
-import { createContext, useContext, useEffect, useMemo, useState, type ReactNode } from 'react'
-import type { PaymentProvider } from '@fayz-ai/core'
-import type { PublicBookingDataProvider } from './data'
-import type {
-  BookingComponents,
-  BookingWindow,
-  PhoneVerificationMode,
-  PublicBookingLabels,
-  PublicService,
-  ResolvedBookingBrand,
-  ResolvedPayment,
-  WorkingHours,
-} from './types'
-
-/** Emitted when the customer's phone is verified / identity captured, for the
- *  host to bridge to auth (booking stays decoupled — data-only, optional). */
-export type OnIdentityVerified = (identity: { name: string; phone: string; email?: string }) => void
-
-export interface PublicBookingContextValue {
-  provider: PublicBookingDataProvider
-  /** The professional/resource bookings are created against; null → any. */
-  professionalId: string | null
-  professionalName: string
-  /** Resolved catalog: static `services` option, or fetched from the provider. */
-  services: PublicService[]
-  servicesLoading: boolean
-  /** Business opening hours, shown on the overview "Sobre" section. */
-  businessHours: WorkingHours
-  /** 'otp' shows the code modal; 'none' trusts the typed number (default). */
-  phoneVerification: PhoneVerificationMode
-  /** Payment step config, or null when the flow ends at confirmation. */
-  payment: ResolvedPayment | null
-  /** Injected charge provider (Pix). When absent, the payment step self-mocks. */
-  paymentProvider: PaymentProvider | null
-  /** Fired on phone-verify / details submit so the host can sign the user in. */
-  onIdentityVerified: OnIdentityVerified | null
-  window: BookingWindow
-  labels: PublicBookingLabels
-  /** Brand personalization (resolved with defaults). */
-  brand: ResolvedBookingBrand
-  /** Host-overridable subcomponents (resolved with defaults). */
-  components: BookingComponents
-  /** Currency code for price formatting (e.g. 'BRL'). */
-  currency: string
-  locale: string
-}
-
-const PublicBookingContext = createContext<PublicBookingContextValue | null>(null)
-
-export interface BookingProviderProps {
-  /** Everything but the (possibly async) service catalog. */
-  base: Omit<PublicBookingContextValue, 'services' | 'servicesLoading'>
-  /** Static catalog from options — wins over the provider fetch when present. */
-  staticServices: PublicService[] | null
-  children: ReactNode
-}
-
-/**
- * Owns the service-catalog resolution: static services pass through untouched;
- * otherwise the provider is queried once (e.g. Supabase v_public_services).
- */
-export function BookingProvider({ base, staticServices, children }: BookingProviderProps) {
-  const [fetched, setFetched] = useState<PublicService[] | null>(null)
-  const [loading, setLoading] = useState(staticServices === null)
-
-  useEffect(() => {
-    if (staticServices !== null) return
-    let active = true
-    setLoading(true)
-    base.provider
-      .getServices()
-      .then((result) => {
-        if (active) setFetched(result)
-      })
-      .catch((err) => {
-        // Surface in dev; the overview renders its empty state.
-        console.error('[plugin-agenda/public] failed to load services:', err)
-        if (active) setFetched([])
-      })
-      .finally(() => {
-        if (active) setLoading(false)
-      })
-    return () => {
-      active = false
-    }
-    // base.provider is stable (created once by the plugin factory).
-  }, [base.provider, staticServices])
-
-  const value = useMemo<PublicBookingContextValue>(
-    () => ({ ...base, services: staticServices ?? fetched ?? [], servicesLoading: loading }),
-    [base, staticServices, fetched, loading],
-  )
-
-  return <PublicBookingContext.Provider value={value}>{children}</PublicBookingContext.Provider>
-}
-
-export function useBooking(): PublicBookingContextValue {
-  const ctx = useContext(PublicBookingContext)
-  if (!ctx) {
-    throw new Error('[plugin-agenda] useBooking must be used within <BookingProvider>.')
-  }
-  return ctx
-}

package/src/public/createPublicBookingPlugin.ts

@@ -1,281 +0,0 @@
-import { createElement, type FC, type ReactNode } from 'react'
-import { CalendarCheck, ShieldCheck, Video } from 'lucide-react'
-import type { PluginManifest, PluginScope, VerticalId, PaymentProvider } from '@fayz-ai/core'
-import type { Professional, Schedule } from '../types'
-import type { MockAgendaSeed } from '../data/mock'
-import { createMockPublicBookingProvider, type PublicBookingDataProvider } from './data'
-import { createSupabasePublicBookingProvider } from './data.supabase'
-import { BookingProvider, type PublicBookingContextValue, type OnIdentityVerified } from './context'
-import { BookingWidget } from './BookingWidget'
-import { DEFAULT_BOOKING_COMPONENTS } from './components/defaults'
-import type {
-  BookingBrand,
-  BookingComponents,
-  BookingWindow,
-  PaymentConfig,
-  PhoneVerificationMode,
-  PublicBookingLabels,
-  PublicService,
-  ResolvedBookingBrand,
-  ResolvedPayment,
-  WorkingHours,
-} from './types'
-
-export interface PublicBookingOptions {
-  /** Mount path for the public booking route. Default '/agendar'. */
-  basePath?: string
-  /**
-   * Tenant this public page books against. REQUIRED when a Supabase client is
-   * configured (setGlobalSupabaseClient) — it scopes services/slots/bookings.
-   */
-  tenantId?: string
-  /**
-   * The single professional/resource bookings target. With Supabase this must
-   * be the staff person UUID; omit → any active professional (RPC unions
-   * schedules across staff).
-   */
-  professional?: { id?: string; name?: string }
-  /**
-   * Bookable services. Optional: when omitted, the widget fetches the catalog
-   * from the provider (Supabase v_public_services). Static wins when provided.
-   */
-  services?: PublicService[]
-  /** Working hours used to seed mock availability + the overview "Sobre" card. */
-  workingHours?: WorkingHours
-  /** Booking-window bounds for the date/slot picker. */
-  window?: Partial<BookingWindow>
-  /** Every user-visible string (all defaulted, pt-BR). */
-  labels?: Partial<PublicBookingLabels>
-  /** Brand personalization: name/logo/tagline/icons/badges/highlights. */
-  brand?: BookingBrand
-  /** Swap whole subcomponents when structure must change (defaults exported). */
-  components?: Partial<BookingComponents>
-  /**
-   * Phone verification before the details sub-step. Default 'none' — the typed
-   * number is trusted. Set 'otp' only where a real code sender is wired: the
-   * built-in modal is a POC that accepts the literal '0000' and sends nothing.
-   */
-  phoneVerification?: PhoneVerificationMode
-  /** Adds a final Pagamento (Pix) step. Omit/disable to end the flow at confirmation. */
-  payment?: PaymentConfig
-  /** Charge provider (from a payments plugin) used by the Pagamento step. Optional. */
-  paymentProvider?: PaymentProvider
-  /** Host bridge: fired when the customer's phone is verified / details submitted. */
-  onIdentityVerified?: OnIdentityVerified
-  currency?: string
-  locale?: string
-  /** Inject a custom provider (overrides the mock/Supabase safe resolver). */
-  dataProvider?: PublicBookingDataProvider
-  /** Override the full mock seed (advanced). */
-  seed?: MockAgendaSeed
-  scope?: PluginScope
-  verticalId?: VerticalId
-}
-
-export interface PublicBookingPlugin {
-  manifest: PluginManifest
-  Provider: FC<{ children: ReactNode }>
-  dataProvider: PublicBookingDataProvider
-}
-
-const DEFAULT_LABELS: PublicBookingLabels = {
-  title: 'Agende sua consulta',
-  serviceStep: 'Escolha o serviço',
-  dateStep: 'Escolha a data',
-  contactStep: 'Seus dados',
-  confirmCta: 'Confirmar agendamento',
-  successTitle: 'Agendamento confirmado!',
-  successBody: 'Você receberá os detalhes em breve. Até logo!',
-  // overview
-  servicesHeading: 'Serviços',
-  aboutHeading: 'Sobre',
-  openingHoursHeading: 'Horário de funcionamento',
-  closedLabel: 'Fechado',
-  bookNowCta: 'Agendar agora',
-  // datetime
-  timezoneNote: 'Fuso: Horário de Brasília',
-  slotsHeading: 'Horários disponíveis',
-  noSlots: 'Nenhum horário disponível neste dia. Tente outra data.',
-  continueCta: 'Continuar',
-  backToServices: 'Serviços',
-  back: 'Voltar',
-  prevWeek: 'Semana anterior',
-  nextWeek: 'Próxima semana',
-  // contact
-  contactIntro: 'Preencha as informações abaixo para que seu agendamento seja identificado.',
-  phoneLabel: 'Celular',
-  phoneHint:
-    'Enviaremos um código para confirmar que o número de telefone é seu. Usaremos este número para associar as suas informações à sua conta.',
-  sendCodeCta: 'Enviar código via WhatsApp',
-  phoneHintNoVerification: 'Usaremos este número para confirmar seu agendamento pelo WhatsApp.',
-  phoneContinueCta: 'Continuar',
-  codeTitle: 'Insira o código',
-  codeBody: 'Enviamos um código via WhatsApp para você confirmar seu número.',
-  codeInvalid: 'Código inválido. Para testar, use 0000.',
-  codeConfirmCta: 'Confirmar',
-  codeResendHint: 'Reenviar código via WhatsApp em 28 segundos.',
-  phoneVerified: 'Celular verificado',
-  changePhone: 'Trocar telefone',
-  nameLabel: 'Nome completo *',
-  namePlaceholder: 'Seu nome',
-  emailLabel: 'E-mail',
-  emailPlaceholder: 'voce@email.com',
-  emailHint: 'Enviaremos uma confirmação e um lembrete antes do agendamento.',
-  notesLabel: 'Observação',
-  notesPlaceholder: 'Use esse espaço para deixar uma observação sobre este agendamento',
-  saveAndContinueCta: 'Salvar e continuar',
-  submitError: 'Não foi possível concluir o agendamento. Tente novamente.',
-  // Rendered ONLY when the payment step is off — so it must not promise a
-  // payment method the flow never shows.
-  noChargeNote: 'Sem cobrança agora · o pagamento é feito no atendimento',
-  // right rail
-  railTitle: 'Passos para agendar',
-  railWaitingPayment: 'Aguardando pagamento',
-  railService: 'Serviço',
-  railProfessional: 'Profissional',
-  railDatetime: 'Data e horário',
-  railContact: 'Informações pessoais',
-  railPayment: 'Pagamento',
-}
-
-const DEFAULT_WINDOW: BookingWindow = { minAdvanceHours: 2, maxAdvanceDays: 21, slotInterval: 30 }
-
-const DEFAULT_HOURS: WorkingHours = { daysOfWeek: [1, 2, 3, 4, 5, 6], start: '09:00', end: '18:00' }
-
-function resolveBrand(brand: BookingBrand | undefined, labels: PublicBookingLabels): ResolvedBookingBrand {
-  const name = brand?.name ?? labels.title
-  return {
-    name,
-    initials: brand?.initials ?? name.charAt(0).toUpperCase(),
-    logoUrl: brand?.logoUrl,
-    tagline: brand?.tagline === undefined ? 'Agendamento online seguro' : brand.tagline,
-    serviceIcon: brand?.serviceIcon ?? Video,
-    serviceMeta: brand?.serviceMeta === undefined ? 'Online' : brand.serviceMeta,
-    featuredBadge: brand?.featuredBadge === undefined ? 'Mais procurado' : brand.featuredBadge,
-    highlights: brand?.highlights ?? [
-      { icon: CalendarCheck, text: 'Confirmação imediata' },
-      { icon: ShieldCheck, text: 'Agendamento seguro' },
-    ],
-  }
-}
-
-let scheduleId = 0
-
-function buildSchedules(professionalId: string, hours: WorkingHours): Schedule[] {
-  return hours.daysOfWeek.map((day) => ({
-    id: `sched-${professionalId}-${day}-${scheduleId++}`,
-    tenantId: 'public',
-    kind: 'working_hours',
-    assigneeId: professionalId,
-    locationId: null,
-    dayOfWeek: day,
-    specificDate: null,
-    startsAt: hours.start,
-    endsAt: hours.end,
-    isActive: true,
-    metadata: {},
-  }))
-}
-
-export function createPublicBookingPlugin(options: PublicBookingOptions): PublicBookingPlugin {
-  const basePath = options.basePath ?? '/agendar'
-  // Mock needs a concrete seed professional; Supabase can target any (null).
-  const mockProfessionalId = options.professional?.id ?? 'pro-1'
-  const professionalId = options.professional?.id ?? null
-  const professionalName = options.professional?.name ?? 'Especialista'
-  const window: BookingWindow = { ...DEFAULT_WINDOW, ...options.window }
-  const labels: PublicBookingLabels = { ...DEFAULT_LABELS, ...options.labels }
-  const brand = resolveBrand(options.brand, labels)
-  const components: BookingComponents = { ...DEFAULT_BOOKING_COMPONENTS, ...options.components }
-  const currency = options.currency ?? 'BRL'
-  const locale = options.locale ?? 'pt-BR'
-  const hours = options.workingHours ?? DEFAULT_HOURS
-  const staticServices = options.services ?? null
-  const phoneVerification: PhoneVerificationMode = options.phoneVerification ?? 'none'
-  const payment: ResolvedPayment | null = options.payment?.enabled
-    ? {
-        reservationFeePercent: options.payment.reservationFeePercent ?? 100,
-        method: options.payment.method ?? 'pix',
-      }
-    : null
-
-  const professional: Professional = {
-    id: mockProfessionalId,
-    name: professionalName,
-    avatarUrl: null,
-    locationId: null,
-    locationName: null,
-    isActive: true,
-  }
-  const mockSeed: MockAgendaSeed = options.seed ?? {
-    professionals: [professional],
-    schedules: buildSchedules(mockProfessionalId, hours),
-    bookings: [],
-  }
-
-  // Resolution: explicit dataProvider → Supabase whenever a tenantId is
-  // declared (the app's global client if registered, else Fayz Cloud — the
-  // shared hosted backend) → seeded mock. The mock fallback is LOUD on
-  // purpose: the old silent fallback hid missing-env bugs as empty catalogs.
-  let provider: PublicBookingDataProvider
-  if (options.dataProvider) {
-    provider = options.dataProvider
-  } else if (options.tenantId) {
-    provider = createSupabasePublicBookingProvider({ tenantId: options.tenantId })
-  } else {
-    if (typeof console !== 'undefined') {
-      console.warn(
-        '[plugin-agenda/public] no `tenantId` and no `dataProvider` — falling back to the seeded MOCK provider. ' +
-          'Pass `tenantId` to book against Fayz Cloud, or inject a dataProvider.',
-      )
-    }
-    provider = createMockPublicBookingProvider({
-      seed: mockSeed,
-      services: staticServices ?? [],
-      professionalId: mockProfessionalId,
-    })
-  }
-
-  const base: Omit<PublicBookingContextValue, 'services' | 'servicesLoading'> = {
-    provider,
-    professionalId,
-    professionalName,
-    businessHours: hours,
-    phoneVerification,
-    payment,
-    paymentProvider: options.paymentProvider ?? null,
-    onIdentityVerified: options.onIdentityVerified ?? null,
-    window,
-    labels,
-    brand,
-    components,
-    currency,
-    locale,
-  }
-  const Provider: FC<{ children: ReactNode }> = ({ children }) =>
-    createElement(BookingProvider, { base, staticServices, children })
-  Provider.displayName = 'PublicBookingProvider'
-
-  const BookingScreen: FC<unknown> = () =>
-    createElement('section', { className: 'py-16 bg-background' },
-      createElement('div', { className: 'container mx-auto px-6' },
-        createElement(BookingWidget)))
-  BookingScreen.displayName = 'BookingScreen'
-
-  const manifest: PluginManifest = {
-    id: 'booking',
-    name: 'Agendamento',
-    icon: 'CalendarCheck',
-    version: '0.4.0',
-    scope: options.scope ?? 'universal',
-    verticalId: options.verticalId,
-    scaffolds: ['website', 'landing_page'],
-    defaultEnabled: true,
-    dependencies: [],
-    navigation: [],
-    routes: [{ path: basePath, component: BookingScreen, guard: 'public' }],
-    widgets: [],
-  }
-
-  return { manifest, Provider, dataProvider: provider }
-}

package/src/public/data.supabase.ts

@@ -1,97 +0,0 @@
-// ---------------------------------------------------------------------------
-// Supabase implementation of PublicBookingDataProvider — anon-safe.
-//
-// Public booking pages run with the publishable (anon) key and NO user session,
-// so the canonical tenant RLS (`tenant_id IN user_tenant_ids()`) yields nothing.
-// This provider therefore only touches objects designed for anon access:
-//   - public.v_public_services   (column-whitelisted view of active services)
-//   - public.get_available_slots (SECURITY DEFINER RPC, mirrors the mock algo)
-//   - public.create_public_booking (SECURITY DEFINER RPC: validates the slot,
-//     upserts the customer person, writes order+booking+order_item atomically)
-// Shipped by plugins/plugin-agenda/src/migrations/001_public_booking.sql.
-// ---------------------------------------------------------------------------
-
-import { getSupabaseClientOptional } from '@fayz-ai/core'
-import type { TimeSlot } from '../types'
-import type { PublicService } from './types'
-import type { PublicBookingDataProvider } from './data'
-
-export interface SupabasePublicBookingOptions {
-  /** The tenant this public page books against (RPC arg — required). */
-  tenantId: string
-}
-
-interface SupabaseLikeClient {
-  from(table: string): any
-  rpc(fn: string, args: Record<string, unknown>): PromiseLike<{ data: unknown; error: { message: string } | null }>
-}
-
-function getClient(): SupabaseLikeClient {
-  const client = getSupabaseClientOptional()
-  if (!client) throw new Error('No Supabase client registered — call setGlobalSupabaseClient() at app startup.')
-  return client as SupabaseLikeClient
-}
-
-/** Digits-only phone (RPC normalizes again server-side; keep the dial code). */
-function toPhoneDigits(phone: string | undefined): string {
-  return (phone ?? '').replace(/\D/g, '')
-}
-
-export function createSupabasePublicBookingProvider(options: SupabasePublicBookingOptions): PublicBookingDataProvider {
-  const { tenantId } = options
-
-  return {
-    async getServices(): Promise<PublicService[]> {
-      const { data, error } = await getClient()
-        .from('v_public_services')
-        .select('id, name, description, price, currency, duration_minutes, sort_order')
-        .eq('tenant_id', tenantId)
-        .order('sort_order', { ascending: true })
-      if (error) throw new Error(`[plugin-agenda/public] getServices: ${error.message}`)
-      return ((data ?? []) as Array<Record<string, unknown>>).map((row) => ({
-        id: String(row.id),
-        name: String(row.name),
-        description: (row.description as string | null) ?? undefined,
-        price: Number(row.price ?? 0),
-        durationMinutes: Number(row.duration_minutes ?? 30),
-      }))
-    },
-
-    async getAvailableSlots(query): Promise<TimeSlot[]> {
-      const { data, error } = await getClient().rpc('get_available_slots', {
-        p_tenant_id: tenantId,
-        p_assignee_id: query.assigneeId,
-        p_date: query.date,
-        p_duration_minutes: query.durationMinutes,
-        p_slot_interval: query.slotInterval,
-      })
-      if (error) throw new Error(`[plugin-agenda/public] getAvailableSlots: ${error.message}`)
-      return ((data ?? []) as Array<{ slot_start: string; slot_end: string }>).map((row) => ({
-        start: row.slot_start,
-        end: row.slot_end,
-      }))
-    },
-
-    async createBooking(input) {
-      const phone = toPhoneDigits(input.contact.phone)
-      const { data, error } = await getClient().rpc('create_public_booking', {
-        p_tenant_id: tenantId,
-        p_service_id: input.serviceId,
-        p_starts_at: input.startsAt,
-        p_name: input.contact.name.trim(),
-        p_phone: phone,
-        p_email: input.contact.email?.trim() || null,
-        p_notes: input.contact.notes?.trim() || null,
-        // Only sent when pinned — keeps compatibility with pools still running
-        // the pre-004 7-arg function (unknown named arg would 404 on PostgREST).
-        ...(input.assigneeId ? { p_assignee_id: input.assigneeId } : {}),
-      })
-      if (error) throw new Error(`[plugin-agenda/public] createBooking: ${error.message}`)
-      const row = (Array.isArray(data) ? data[0] : data) as
-        | { booking_id: string; starts_at: string; ends_at: string }
-        | undefined
-      if (!row) throw new Error('[plugin-agenda/public] createBooking: empty RPC response')
-      return { bookingId: row.booking_id, startsAt: row.starts_at, endsAt: row.ends_at }
-    },
-  }
-}

package/src/public/data.ts

@@ -1,105 +0,0 @@
-// ---------------------------------------------------------------------------
-// PublicBookingDataProvider — the narrow data seam the public booking surface
-// depends on. The admin calendar's 15-method AgendaDataProvider is deliberately
-// NOT used here: a public page needs exactly three capabilities, and the
-// Supabase implementation must be anon-safe (SECURITY DEFINER RPCs + whitelisted
-// views) rather than the authenticated table access the admin provider does.
-// ---------------------------------------------------------------------------
-
-import type { TimeSlot } from '../types'
-import { createMockAgendaProvider, type MockAgendaSeed } from '../data/mock'
-import type { PublicService, ContactInfo } from './types'
-
-export interface PublicSlotQuery {
-  /** Staff person id; null → any active professional for the tenant. */
-  assigneeId: string | null
-  /** 'YYYY-MM-DD' local calendar day. */
-  date: string
-  durationMinutes: number
-  slotInterval: number
-}
-
-export interface PublicCreateBookingInput {
-  serviceId: string
-  /** ISO datetime of the chosen slot start. */
-  startsAt: string
-  /** name required; phone should include the country dial for real backends. */
-  contact: ContactInfo
-  /**
-   * Staff person id the visitor saw availability for. When set, the backend
-   * books THAT professional (or fails if their hours don't cover the slot) —
-   * never silently reassigns. null/undefined → backend auto-picks.
-   */
-  assigneeId?: string | null
-}
-
-export interface PublicBookingResult {
-  bookingId: string
-  startsAt: string
-  endsAt: string
-}
-
-export interface PublicBookingDataProvider {
-  /** Bookable catalog. Used when the host doesn't pass static `services`. */
-  getServices(): Promise<PublicService[]>
-  getAvailableSlots(query: PublicSlotQuery): Promise<TimeSlot[]>
-  createBooking(input: PublicCreateBookingInput): Promise<PublicBookingResult>
-}
-
-// ---------------------------------------------------------------------------
-// Mock implementation — adapter over the admin mock provider (reuses its slot
-// algorithm + seed machinery, so mock and live behave identically).
-// ---------------------------------------------------------------------------
-
-export interface MockPublicBookingOptions {
-  seed: MockAgendaSeed
-  services: PublicService[]
-  /** The seed professional bookings are created against. */
-  professionalId: string
-}
-
-export function createMockPublicBookingProvider(options: MockPublicBookingOptions): PublicBookingDataProvider {
-  const inner = createMockAgendaProvider({ seed: options.seed })
-  const { services, professionalId } = options
-
-  return {
-    async getServices() {
-      return services
-    },
-    async getAvailableSlots(query) {
-      return inner.getAvailableSlots({
-        assigneeId: query.assigneeId ?? professionalId,
-        date: query.date,
-        durationMinutes: query.durationMinutes,
-        slotInterval: query.slotInterval,
-      })
-    },
-    async createBooking(input) {
-      const service = services.find((s) => s.id === input.serviceId)
-      if (!service) throw new Error('Serviço inválido')
-      const booking = await inner.createBooking({
-        kind: 'appointment',
-        // Mock: the customer is captured as the booking title; the Supabase
-        // path upserts a person record server-side instead.
-        clientId: 'public-guest',
-        professionalId,
-        startsAt: input.startsAt,
-        title: input.contact.name,
-        notes:
-          [input.contact.phone, input.contact.email, input.contact.notes].filter(Boolean).join(' · ') || undefined,
-        services: [
-          {
-            serviceId: service.id,
-            name: service.name,
-            durationMinutes: service.durationMinutes,
-            price: service.price,
-            assigneeId: professionalId,
-          },
-        ],
-      })
-      const endsAt =
-        booking.endsAt ?? new Date(new Date(input.startsAt).getTime() + service.durationMinutes * 60_000).toISOString()
-      return { bookingId: booking.id, startsAt: booking.startsAt, endsAt }
-    },
-  }
-}

package/src/public/format.ts

@@ -1,96 +0,0 @@
-// ---------------------------------------------------------------------------
-// Date/price formatting + calendar helpers shared by the booking widget and
-// its (host-overridable) subcomponents.
-// ---------------------------------------------------------------------------
-
-import { useMemo } from 'react'
-import type { BookingFormatters } from './types'
-
-export const DAY_NAMES = ['Domingo', 'Segunda-feira', 'Terça-feira', 'Quarta-feira', 'Quinta-feira', 'Sexta-feira', 'Sábado']
-export const WEEK_ORDER = [1, 2, 3, 4, 5, 6, 0] // Monday-first, like the reference
-
-export function useFormatters(locale: string, currency: string): BookingFormatters {
-  return useMemo(
-    () => ({
-      price: new Intl.NumberFormat(locale, { style: 'currency', currency }),
-      time: new Intl.DateTimeFormat(locale, { hour: '2-digit', minute: '2-digit' }),
-      weekday: new Intl.DateTimeFormat(locale, { weekday: 'short' }),
-      dayNum: new Intl.DateTimeFormat(locale, { day: '2-digit', month: '2-digit' }),
-      longDay: new Intl.DateTimeFormat(locale, { weekday: 'long', day: '2-digit', month: 'long' }),
-      dateShort: new Intl.DateTimeFormat(locale, { day: '2-digit', month: '2-digit', year: 'numeric' }),
-      month: new Intl.DateTimeFormat(locale, { month: 'long', year: 'numeric' }),
-    }),
-    [locale, currency],
-  )
-}
-
-/** Local 'YYYY-MM-DD' for a Date. */
-export function toIso(d: Date): string {
-  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`
-}
-
-/** Read a preselected service from the URL (?service=…), router-agnostic. */
-export function readServiceParam(): string | null {
-  if (typeof window === 'undefined') return null
-  return new URLSearchParams(window.location.search).get('service')
-}
-
-/**
- * Comparable form of a service name: lowercase, accent-free, non-alphanumerics
- * collapsed to single dashes.
- *
- * Exists because the marketing site and the catalog spell the same service
- * differently — the site writes "Peeling Químico" and "Drenagem Linfática", the
- * catalog stores "Peeling Quimico" and "Drenagem Linfatica". Matching on the
- * raw name would miss most of them, and making the site link raw UUIDs instead
- * would scatter database ids through page markup and break on every reseed.
- */
-export function serviceSlug(name: string): string {
-  return name
-    .normalize('NFD')
-    .replace(/[̀-ͯ]/g, '')
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-|-$/g, '')
-}
-
-/**
- * Resolve `?service=` against the catalog. Accepts the service id or its
- * slugified name, so a site can link `/agendar?service=limpeza-de-pele`
- * without knowing any ids. Unknown value ⇒ null, and the widget opens on the
- * overview as if no service had been asked for.
- */
-export function resolvePreselectedService<T extends { id: string; name: string }>(
-  param: string | null,
-  services: T[],
-): string | null {
-  if (!param) return null
-  if (services.some((s) => s.id === param)) return param
-  const wanted = serviceSlug(param)
-  return services.find((s) => serviceSlug(s.name) === wanted)?.id ?? null
-}
-
-export interface DayCell {
-  iso: string
-  date: Date
-  isToday: boolean
-}
-
-/** 7 consecutive days starting `weekOffset*7` days from today. */
-export function buildWeek(weekOffset: number): DayCell[] {
-  const base = new Date()
-  base.setHours(0, 0, 0, 0)
-  const cells: DayCell[] = []
-  for (let i = 0; i < 7; i++) {
-    const d = new Date(base.getFullYear(), base.getMonth(), base.getDate() + weekOffset * 7 + i)
-    cells.push({ iso: toIso(d), date: d, isToday: weekOffset === 0 && i === 0 })
-  }
-  return cells
-}
-
-/** "13/07/2026 – 21:30 até 22:00 (30min)" */
-export function formatSlotRange(startIso: string, durationMin: number, fmt: BookingFormatters): string {
-  const start = new Date(startIso)
-  const end = new Date(start.getTime() + durationMin * 60_000)
-  return `${fmt.dateShort.format(start)} – ${fmt.time.format(start)} até ${fmt.time.format(end)} (${durationMin}min)`
-}