@bookr-cl/widget 0.0.1

package/dist/index.cjs

@@ -0,0 +1,728 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DAY_NAMES: () => DAY_NAMES,
+  DAY_NAMES_FULL: () => DAY_NAMES_FULL,
+  DEFAULT_PROVIDER_COLORS: () => DEFAULT_PROVIDER_COLORS,
+  clearClientToken: () => clearClientToken,
+  createBooking: () => createBooking,
+  createClient: () => createClient,
+  dateStr: () => dateStr,
+  fetchMe: () => fetchMe,
+  formatMonthRange: () => formatMonthRange,
+  getAvailableSlots: () => getAvailableSlots,
+  getClientToken: () => getClientToken,
+  getMe: () => getMe,
+  getMondayOf: () => getMondayOf,
+  getMyBookings: () => getMyBookings,
+  getMyPackages: () => getMyPackages,
+  listLocations: () => listLocations,
+  listProviders: () => listProviders,
+  listServices: () => listServices,
+  loginWithGoogle: () => loginWithGoogle,
+  register: () => register,
+  sendMagicLink: () => sendMagicLink,
+  setClientToken: () => setClientToken,
+  useBookingFlow: () => useBookingFlow,
+  useClassSchedule: () => useClassSchedule,
+  useClientAccount: () => useClientAccount,
+  useMagicLinkAuth: () => useMagicLinkAuth,
+  useRegisterForm: () => useRegisterForm,
+  verifyMagicLink: () => verifyMagicLink
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/api.ts
+function headers(cfg, withJson = false) {
+  const h = { "X-API-Key": cfg.apiKey };
+  if (withJson) h["Content-Type"] = "application/json";
+  return h;
+}
+function authHeaders(token, withJson = false) {
+  const h = { Authorization: `Bearer ${token}` };
+  if (withJson) h["Content-Type"] = "application/json";
+  return h;
+}
+async function listLocations(cfg) {
+  const res = await fetch(`${cfg.apiBase}/v1/locations`, { headers: headers(cfg) });
+  const data = await res.json();
+  return data.data || [];
+}
+async function listServices(cfg, perPage = 100) {
+  const res = await fetch(`${cfg.apiBase}/v1/services?per_page=${perPage}`, { headers: headers(cfg) });
+  const data = await res.json();
+  return data.data || [];
+}
+async function listProviders(cfg, perPage = 100) {
+  const res = await fetch(`${cfg.apiBase}/v1/providers?per_page=${perPage}`, { headers: headers(cfg) });
+  const data = await res.json();
+  return data.data || [];
+}
+async function getAvailableSlots(cfg, params) {
+  const q = new URLSearchParams({ location_id: params.locationId, start_date: params.startDate });
+  if (params.serviceId) q.set("service_id", params.serviceId);
+  if (params.providerId) q.set("provider_id", params.providerId);
+  const res = await fetch(`${cfg.apiBase}/v1/available-slots?${q.toString()}`, { headers: headers(cfg) });
+  const data = await res.json();
+  return data.data?.slots || [];
+}
+async function createClient(cfg, form) {
+  const res = await fetch(`${cfg.apiBase}/v1/clients`, {
+    method: "POST",
+    headers: headers(cfg, true),
+    body: JSON.stringify({
+      first_name: form.firstName,
+      last_name: form.lastName,
+      email: form.email,
+      phone: form.phone,
+      rut: form.rut || void 0
+    })
+  });
+  if (!res.ok) throw new Error("Error registrando datos");
+  return res.json();
+}
+async function createBooking(cfg, input, clientToken) {
+  const reqHeaders = headers(cfg, true);
+  if (clientToken) reqHeaders.Authorization = `Bearer ${clientToken}`;
+  const res = await fetch(`${cfg.apiBase}/v1/bookings`, {
+    method: "POST",
+    headers: reqHeaders,
+    body: JSON.stringify(input)
+  });
+  if (res.status === 409) {
+    const data = await res.json().catch(() => ({}));
+    return { ok: false, conflict: true, message: data.detail || "Ese horario ya no est\xE1 disponible." };
+  }
+  if (!res.ok) {
+    return { ok: false, conflict: false, message: "Error creando la reserva. Por favor intenta nuevamente." };
+  }
+  return { ok: true, booking: await res.json() };
+}
+async function sendMagicLink(cfg, email, frontendUrl, profile) {
+  const res = await fetch(`${cfg.apiBase}/v1/client-auth/magic-link`, {
+    method: "POST",
+    headers: headers(cfg, true),
+    body: JSON.stringify({
+      email: email.trim().toLowerCase(),
+      frontend_url: frontendUrl,
+      first_name: profile?.firstName,
+      last_name: profile?.lastName,
+      phone: profile?.phone,
+      rut: profile?.rut
+    })
+  });
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.detail || "Error enviando el link.");
+}
+async function verifyMagicLink(cfg, token) {
+  const res = await fetch(`${cfg.apiBase}/v1/client-auth/magic-link/verify`, {
+    method: "POST",
+    headers: headers(cfg, true),
+    body: JSON.stringify({ token })
+  });
+  const data = await res.json();
+  if (!data.access_token) throw new Error(data.detail || "Link inv\xE1lido.");
+  return data;
+}
+async function loginWithGoogle(cfg, credential) {
+  const res = await fetch(`${cfg.apiBase}/v1/client-auth/google`, {
+    method: "POST",
+    headers: headers(cfg, true),
+    body: JSON.stringify({ credential })
+  });
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.detail || "Error con Google.");
+  return data;
+}
+async function register(cfg, form) {
+  const res = await fetch(`${cfg.apiBase}/v1/client-auth/register`, {
+    method: "POST",
+    headers: headers(cfg, true),
+    body: JSON.stringify({
+      first_name: form.firstName,
+      last_name: form.lastName,
+      email: form.email,
+      phone: form.phone || void 0,
+      password: form.password
+    })
+  });
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.detail || "Error al registrarse.");
+  return data;
+}
+async function getMe(apiBase, token) {
+  const res = await fetch(`${apiBase}/v1/me`, { headers: authHeaders(token) });
+  return res.json();
+}
+async function getMyBookings(apiBase, token, params) {
+  const q = new URLSearchParams();
+  if (params?.upcoming) q.set("upcoming", "true");
+  q.set("per_page", String(params?.perPage ?? 20));
+  const res = await fetch(`${apiBase}/v1/me/bookings?${q.toString()}`, { headers: authHeaders(token) });
+  const data = await res.json();
+  return data.data || [];
+}
+async function getMyPackages(apiBase, token) {
+  const res = await fetch(`${apiBase}/v1/me/packages`, { headers: authHeaders(token) });
+  const data = await res.json();
+  return data.data || [];
+}
+
+// src/clientAuth.ts
+var TOKEN_KEY = "client_token";
+function getClientToken() {
+  if (typeof window === "undefined") return null;
+  return localStorage.getItem(TOKEN_KEY);
+}
+function setClientToken(token) {
+  if (typeof window === "undefined") return;
+  localStorage.setItem(TOKEN_KEY, token);
+}
+function clearClientToken() {
+  if (typeof window === "undefined") return;
+  localStorage.removeItem(TOKEN_KEY);
+}
+async function fetchMe(apiBase, token) {
+  try {
+    return await getMe(apiBase, token);
+  } catch {
+    return null;
+  }
+}
+
+// src/dateUtils.ts
+function getMondayOf(date) {
+  const d = new Date(date);
+  const day = (d.getDay() + 6) % 7;
+  d.setDate(d.getDate() - day);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+function dateStr(d) {
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+function formatMonthRange(monday) {
+  const sunday = new Date(monday);
+  sunday.setDate(monday.getDate() + 6);
+  const opts = { day: "numeric", month: "long" };
+  const start = monday.toLocaleDateString("es-CL", opts);
+  const end = sunday.toLocaleDateString("es-CL", opts);
+  return `${start} \u2013 ${end}`;
+}
+var DAY_NAMES = ["Lun", "Mar", "Mi\xE9", "Jue", "Vie", "S\xE1b", "Dom"];
+var DAY_NAMES_FULL = ["Lunes", "Martes", "Mi\xE9rcoles", "Jueves", "Viernes", "S\xE1bado", "Domingo"];
+var DEFAULT_PROVIDER_COLORS = [
+  { bg: "#e8f5f0", border: "#2bbf8e", text: "#1a7a5a" },
+  { bg: "#eef0fb", border: "#6b7de8", text: "#3d4fa8" },
+  { bg: "#fdf3e8", border: "#e8a24b", text: "#a0600a" },
+  { bg: "#fdeef4", border: "#e86b9a", text: "#a03060" }
+];
+
+// src/hooks/useBookingFlow.ts
+var import_react = require("react");
+var EMPTY_FORM = { firstName: "", lastName: "", email: "", phone: "", rut: "" };
+function validateClientForm(form) {
+  if (!form.firstName.trim()) return "Por favor ingresa tu nombre.";
+  if (!form.lastName.trim()) return "Por favor ingresa tu apellido.";
+  if (!form.email.trim() || !/\S+@\S+\.\S+/.test(form.email)) return "Por favor ingresa un email v\xE1lido.";
+  if (!form.phone.trim()) return "Por favor ingresa tu tel\xE9fono.";
+  if (!form.rut.trim()) return "Por favor ingresa tu RUT.";
+  return null;
+}
+function buildBookingPayload(args) {
+  const { form, client, selectedDate, selectedSlot, selectedSvc, selectedLoc } = args;
+  const price = args.overrides?.price ?? args.svcPrice ?? "0";
+  const notes = args.overrides?.notes ?? args.defaultNotes;
+  return {
+    start_time: `${selectedDate}T${selectedSlot.start_time}:00-04:00`,
+    end_time: `${selectedDate}T${selectedSlot.end_time}:00-04:00`,
+    service_id: selectedSvc,
+    service_provider_id: selectedSlot.provider_id,
+    location_id: selectedLoc,
+    price,
+    notes,
+    // Ignored server-side unless a client/staff auth token proves the caller's
+    // identity; for a logged-in client it's redundant but harmless to include.
+    client_id: client?.id,
+    client_first_name: form.firstName,
+    client_last_name: form.lastName,
+    client_email: form.email,
+    client_phone: form.phone,
+    client_rut: form.rut || void 0
+  };
+}
+function useBookingFlow(opts) {
+  const [locations, setLocations] = (0, import_react.useState)([]);
+  const [services, setServices] = (0, import_react.useState)([]);
+  const [providers, setProviders] = (0, import_react.useState)([]);
+  const [slots, setSlots] = (0, import_react.useState)([]);
+  const [selectedLoc, setSelectedLoc] = (0, import_react.useState)("");
+  const [selectedSvc, setSelectedSvc] = (0, import_react.useState)("");
+  const [selectedProv, setSelectedProv] = (0, import_react.useState)("");
+  const [selectedDate, setSelectedDate] = (0, import_react.useState)("");
+  const [selectedSlot, setSelectedSlot] = (0, import_react.useState)(null);
+  const [form, setForm] = (0, import_react.useState)(EMPTY_FORM);
+  const [loading, setLoading] = (0, import_react.useState)(false);
+  const [error, setError] = (0, import_react.useState)("");
+  const [client, setClient] = (0, import_react.useState)(null);
+  (0, import_react.useEffect)(() => {
+    const token = getClientToken();
+    if (!token) return;
+    fetchMe(opts.apiBase, token).then((profile) => {
+      if (!profile) return;
+      setClient(profile);
+      setForm((f) => ({
+        ...f,
+        firstName: profile.first_name || f.firstName,
+        lastName: profile.last_name || f.lastName,
+        email: profile.email || f.email,
+        phone: profile.phone || f.phone
+      }));
+    });
+  }, []);
+  (0, import_react.useEffect)(() => {
+    listLocations(opts).then(setLocations).catch(() => setError("Error cargando sucursales"));
+  }, []);
+  (0, import_react.useEffect)(() => {
+    if (!selectedLoc) return;
+    listServices(opts).then(setServices).catch(() => setError("Error cargando servicios"));
+  }, [selectedLoc]);
+  (0, import_react.useEffect)(() => {
+    if (!selectedSvc) return;
+    listProviders(opts).then(setProviders).catch(() => setError("Error cargando profesionales"));
+  }, [selectedSvc]);
+  (0, import_react.useEffect)(() => {
+    if (!selectedLoc || !selectedDate) return;
+    setLoading(true);
+    getAvailableSlots(opts, {
+      locationId: selectedLoc,
+      startDate: selectedDate,
+      serviceId: selectedSvc || void 0,
+      providerId: selectedProv || void 0
+    }).then((s) => {
+      setSlots(s);
+      setLoading(false);
+    }).catch(() => {
+      setError("Error cargando horarios");
+      setLoading(false);
+    });
+  }, [selectedLoc, selectedSvc, selectedProv, selectedDate]);
+  const updateForm = (fields) => setForm((f) => ({ ...f, ...fields }));
+  const submitBooking = async (overrides) => {
+    if (!selectedSlot) return;
+    const validationError = validateClientForm(form);
+    if (validationError) {
+      setError(validationError);
+      return;
+    }
+    setLoading(true);
+    setError("");
+    try {
+      const svc = services.find((s) => s.id === selectedSvc);
+      const token = getClientToken();
+      const payload = buildBookingPayload({
+        form,
+        client,
+        selectedDate,
+        selectedSlot,
+        selectedSvc,
+        selectedLoc,
+        overrides,
+        svcPrice: svc?.price,
+        defaultNotes: opts.defaultNotes
+      });
+      const result = await createBooking(opts, payload, token || void 0);
+      handleSubmitResult(result);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Error al procesar la reserva");
+      setLoading(false);
+    }
+  };
+  function handleSubmitResult(result) {
+    if (!result.ok) {
+      setError(result.message);
+      if (result.conflict) setSelectedSlot(null);
+      setLoading(false);
+      return;
+    }
+    opts.onBookingComplete(result.booking);
+  }
+  return {
+    locations,
+    services,
+    providers,
+    slots,
+    selectedLoc,
+    setSelectedLoc,
+    selectedSvc,
+    setSelectedSvc,
+    selectedProv,
+    setSelectedProv,
+    selectedDate,
+    setSelectedDate,
+    selectedSlot,
+    setSelectedSlot,
+    form,
+    updateForm,
+    loading,
+    error,
+    setError,
+    client,
+    submitBooking
+  };
+}
+
+// src/hooks/useClassSchedule.ts
+var import_react2 = require("react");
+var EMPTY_FORM2 = { firstName: "", lastName: "", email: "", phone: "", rut: "" };
+function validateClassForm(form) {
+  if (!form.firstName.trim()) return "Por favor ingresa tu nombre.";
+  if (!form.lastName.trim()) return "Por favor ingresa tu apellido.";
+  if (!form.email.trim() || !/\S+@\S+\.\S+/.test(form.email)) return "Por favor ingresa un email v\xE1lido.";
+  if (!form.phone.trim()) return "Por favor ingresa tu tel\xE9fono.";
+  return null;
+}
+function buildClassBookingPayload(form, client, selectedSlot, svc, locationId) {
+  return {
+    start_time: `${selectedSlot.date}T${selectedSlot.slot.start_time}:00-04:00`,
+    end_time: `${selectedSlot.date}T${selectedSlot.slot.end_time}:00-04:00`,
+    service_id: svc?.id ?? "",
+    service_provider_id: selectedSlot.slot.provider_id,
+    location_id: locationId,
+    price: svc?.price || "0",
+    client_id: client?.id,
+    client_first_name: form.firstName,
+    client_last_name: form.lastName,
+    client_email: form.email,
+    client_phone: form.phone,
+    client_rut: form.rut || void 0
+  };
+}
+function resolveConflictMessage(result) {
+  return result.conflict ? "Ese cupo ya fue tomado por otra persona. Cierra esta ventana y elige otro horario." : result.message;
+}
+function useClassSchedule(opts) {
+  const colors = opts.colors ?? DEFAULT_PROVIDER_COLORS;
+  const [monday, setMonday] = (0, import_react2.useState)(() => getMondayOf(/* @__PURE__ */ new Date()));
+  const [slotsByDay, setSlotsByDay] = (0, import_react2.useState)({});
+  const [services, setServices] = (0, import_react2.useState)([]);
+  const [locationId, setLocationId] = (0, import_react2.useState)("");
+  const [loading, setLoading] = (0, import_react2.useState)(true);
+  const [selectedSlot, setSelectedSlot] = (0, import_react2.useState)(null);
+  const [providerColorMap, setProviderColorMap] = (0, import_react2.useState)({});
+  const [form, setForm] = (0, import_react2.useState)(EMPTY_FORM2);
+  const [submitting, setSubmitting] = (0, import_react2.useState)(false);
+  const [error, setError] = (0, import_react2.useState)("");
+  const [client, setClient] = (0, import_react2.useState)(null);
+  (0, import_react2.useEffect)(() => {
+    Promise.all([listLocations(opts), listServices(opts, 50)]).then(([locs, svcs]) => {
+      if (locs.length) setLocationId(locs[0].id);
+      setServices(svcs);
+    }).catch(() => setError("Error cargando datos"));
+  }, []);
+  (0, import_react2.useEffect)(() => {
+    const token = getClientToken();
+    if (!token) return;
+    fetchMe(opts.apiBase, token).then((profile) => {
+      if (!profile) return;
+      setClient(profile);
+      setForm((f) => ({
+        ...f,
+        firstName: profile.first_name || f.firstName,
+        lastName: profile.last_name || f.lastName,
+        email: profile.email || f.email,
+        phone: profile.phone || f.phone
+      }));
+    });
+  }, []);
+  const loadWeek = (0, import_react2.useCallback)(async (mon, locId) => {
+    if (!locId) return;
+    setLoading(true);
+    const days = Array.from({ length: 7 }, (_, i) => {
+      const d = new Date(mon);
+      d.setDate(mon.getDate() + i);
+      return d;
+    });
+    const results = await Promise.all(
+      days.map(async (d) => {
+        const ds = dateStr(d);
+        try {
+          const slots = await getAvailableSlots(opts, { locationId: locId, startDate: ds });
+          return { date: ds, slots };
+        } catch {
+          return { date: ds, slots: [] };
+        }
+      })
+    );
+    const map = {};
+    const colorMap = {};
+    let colorIdx = 0;
+    results.forEach(({ date, slots }) => {
+      map[date] = slots;
+      slots.forEach((s) => {
+        if (!colorMap[s.provider_id]) {
+          colorMap[s.provider_id] = colors[colorIdx % colors.length];
+          colorIdx++;
+        }
+      });
+    });
+    setSlotsByDay(map);
+    setProviderColorMap((prev) => ({ ...prev, ...colorMap }));
+    setLoading(false);
+  }, []);
+  (0, import_react2.useEffect)(() => {
+    if (locationId) loadWeek(monday, locationId);
+  }, [monday, locationId, loadWeek]);
+  const updateForm = (fields) => setForm((f) => ({ ...f, ...fields }));
+  const submitBooking = async (e) => {
+    e.preventDefault();
+    if (!selectedSlot) return;
+    const validationError = validateClassForm(form);
+    if (validationError) {
+      setError(validationError);
+      return;
+    }
+    setSubmitting(true);
+    setError("");
+    try {
+      const svc = services.find((s) => s.name === selectedSlot.slot.service_name);
+      const token = getClientToken();
+      const payload = buildClassBookingPayload(form, client, selectedSlot, svc, locationId);
+      const result = await createBooking(opts, payload, token || void 0);
+      handleSubmitResult(result);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Error al procesar");
+      setSubmitting(false);
+    }
+  };
+  function handleSubmitResult(result) {
+    if (!result.ok) {
+      setError(resolveConflictMessage(result));
+      setSubmitting(false);
+      return;
+    }
+    opts.onBookingComplete();
+  }
+  return {
+    monday,
+    setMonday,
+    slotsByDay,
+    loading,
+    providerColorMap,
+    selectedSlot,
+    setSelectedSlot,
+    form,
+    updateForm,
+    submitting,
+    error,
+    setError,
+    client,
+    submitBooking
+  };
+}
+
+// src/hooks/useMagicLinkAuth.ts
+var import_react3 = require("react");
+function useMagicLinkAuth(opts) {
+  const [email, setEmail] = (0, import_react3.useState)("");
+  const [firstName, setFirstName] = (0, import_react3.useState)("");
+  const [lastName, setLastName] = (0, import_react3.useState)("");
+  const [phone, setPhone] = (0, import_react3.useState)("");
+  const [rut, setRut] = (0, import_react3.useState)("");
+  const [step, setStep] = (0, import_react3.useState)("email");
+  const [error, setError] = (0, import_react3.useState)("");
+  const [loading, setLoading] = (0, import_react3.useState)(false);
+  const handleMagicLink = async (e) => {
+    e.preventDefault();
+    if (!email.trim() || !/\S+@\S+\.\S+/.test(email)) {
+      setError("Ingresa un email v\xE1lido.");
+      return;
+    }
+    setLoading(true);
+    setError("");
+    try {
+      await sendMagicLink(opts, email, opts.frontendUrl, {
+        firstName: firstName || void 0,
+        lastName: lastName || void 0,
+        phone: phone || void 0,
+        rut: rut || void 0
+      });
+      setStep("sent");
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Error enviando el link.");
+    } finally {
+      setLoading(false);
+    }
+  };
+  const handleGoogle = () => {
+    if (!opts.googleClientId || typeof window === "undefined" || !window.google) return;
+    window.google.accounts.id.initialize({
+      client_id: opts.googleClientId,
+      callback: async (response) => {
+        setLoading(true);
+        try {
+          const data = await loginWithGoogle(opts, response.credential);
+          setClientToken(data.access_token);
+          opts.onGoogleLoggedIn();
+        } catch (err) {
+          setError(err instanceof Error ? err.message : "Error con Google.");
+          setLoading(false);
+        }
+      }
+    });
+    window.google.accounts.id.prompt();
+  };
+  const reset = () => {
+    setStep("email");
+    setError("");
+  };
+  return {
+    email,
+    setEmail,
+    firstName,
+    setFirstName,
+    lastName,
+    setLastName,
+    phone,
+    setPhone,
+    rut,
+    setRut,
+    step,
+    error,
+    loading,
+    handleMagicLink,
+    handleGoogle,
+    reset
+  };
+}
+
+// src/hooks/useRegisterForm.ts
+var import_react4 = require("react");
+var EMPTY = { firstName: "", lastName: "", email: "", phone: "", password: "", confirm: "" };
+function useRegisterForm(opts) {
+  const [form, setForm] = (0, import_react4.useState)(EMPTY);
+  const [error, setError] = (0, import_react4.useState)("");
+  const [loading, setLoading] = (0, import_react4.useState)(false);
+  const updateField = (fields) => setForm((f) => ({ ...f, ...fields }));
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    if (!form.firstName.trim()) {
+      setError("Ingresa tu nombre.");
+      return;
+    }
+    if (!form.lastName.trim()) {
+      setError("Ingresa tu apellido.");
+      return;
+    }
+    if (!form.email.trim()) {
+      setError("Ingresa tu email.");
+      return;
+    }
+    if (form.password.length < 6) {
+      setError("La contrase\xF1a debe tener al menos 6 caracteres.");
+      return;
+    }
+    if (form.password !== form.confirm) {
+      setError("Las contrase\xF1as no coinciden.");
+      return;
+    }
+    setLoading(true);
+    setError("");
+    try {
+      const data = await register(opts, form);
+      setClientToken(data.access_token);
+      opts.onRegistered();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Error al registrarse.");
+    } finally {
+      setLoading(false);
+    }
+  };
+  return { form, updateField, error, loading, handleSubmit };
+}
+
+// src/hooks/useClientAccount.ts
+var import_react5 = require("react");
+function useClientAccount(opts) {
+  const [profile, setProfile] = (0, import_react5.useState)(null);
+  const [upcoming, setUpcoming] = (0, import_react5.useState)([]);
+  const [history, setHistory] = (0, import_react5.useState)([]);
+  const [packages, setPackages] = (0, import_react5.useState)([]);
+  const [loading, setLoading] = (0, import_react5.useState)(true);
+  (0, import_react5.useEffect)(() => {
+    const token = getClientToken();
+    if (!token) {
+      opts.onUnauthenticated();
+      return;
+    }
+    Promise.all([
+      getMe(opts.apiBase, token),
+      getMyBookings(opts.apiBase, token, { upcoming: true, perPage: 10 }),
+      getMyBookings(opts.apiBase, token, { perPage: 20 }),
+      getMyPackages(opts.apiBase, token)
+    ]).then(([prof, up, hist, pkgs]) => {
+      setProfile(prof);
+      setUpcoming(up);
+      setHistory(hist);
+      setPackages(pkgs);
+      setLoading(false);
+    }).catch(() => opts.onUnauthenticated());
+  }, []);
+  const handleLogout = () => {
+    clearClientToken();
+    opts.onLoggedOut();
+  };
+  const totalCredits = packages.reduce((s, p) => s + p.remaining_credits, 0);
+  return { profile, upcoming, history, packages, loading, totalCredits, handleLogout };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DAY_NAMES,
+  DAY_NAMES_FULL,
+  DEFAULT_PROVIDER_COLORS,
+  clearClientToken,
+  createBooking,
+  createClient,
+  dateStr,
+  fetchMe,
+  formatMonthRange,
+  getAvailableSlots,
+  getClientToken,
+  getMe,
+  getMondayOf,
+  getMyBookings,
+  getMyPackages,
+  listLocations,
+  listProviders,
+  listServices,
+  loginWithGoogle,
+  register,
+  sendMagicLink,
+  setClientToken,
+  useBookingFlow,
+  useClassSchedule,
+  useClientAccount,
+  useMagicLinkAuth,
+  useRegisterForm,
+  verifyMagicLink
+});
+//# sourceMappingURL=index.cjs.map