arky-sdk 0.7.124 → 0.7.125

package/dist/storefront-store.cjs

@@ -1596,6 +1596,105 @@ function formFieldsFromBlocks(blocks) {
     value: block.value
   }));
 }
+function getFormBlockType(field) {
+  if (field.key === "email") return "email";
+  if (field.key === "phone") return "phone";
+  if (field.type === "geo_location") return "address";
+  return field.type;
+}
+function getFormBlockValue(field) {
+  if (field.type === "boolean") return false;
+  if (field.type === "number") return field.min ?? 0;
+  if (field.type === "geo_location") return {};
+  return "";
+}
+function formSchemaToBlock(field) {
+  return {
+    id: field.id,
+    key: field.key,
+    type: getFormBlockType(field),
+    properties: {
+      isRequired: field.required,
+      minValues: field.required ? 1 : 0,
+      min: field.min,
+      max: field.max,
+      options: field.options,
+      pattern: field.key === "email" ? "^.+@.+\\..+$" : field.key === "phone" ? "^.{6,20}$" : void 0
+    },
+    value: getFormBlockValue(field)
+  };
+}
+function formatBookingTime(ts, tz) {
+  return new Date(ts * 1e3).toLocaleTimeString([], {
+    hour: "2-digit",
+    minute: "2-digit",
+    timeZone: tz
+  });
+}
+function formatBookingSlotTime(from, to, tz) {
+  return `${formatBookingTime(from, tz)} - ${formatBookingTime(to, tz)}`;
+}
+function getSlotsForDate(availability, dateStr, providerId) {
+  if (!availability) return [];
+  const slots = [];
+  for (const provider of availability.providers) {
+    if (providerId && provider.provider_id !== providerId) continue;
+    const day = provider.days.find((candidate) => candidate.date === dateStr);
+    if (!day) continue;
+    for (const slot of day.slots) {
+      if (slot.spots > 0) slots.push({ from: slot.from, to: slot.to, providerId: provider.provider_id });
+    }
+  }
+  return slots.sort((a, b) => a.from - b.from);
+}
+function hasAvailableSlotsForDate(availability, dateStr, providerId) {
+  if (!availability) return false;
+  return availability.providers.some((provider) => {
+    if (providerId && provider.provider_id !== providerId) return false;
+    const day = provider.days.find((candidate) => candidate.date === dateStr);
+    return !!day?.slots.some((slot) => slot.spots > 0);
+  });
+}
+var BOOKING_WEEKDAYS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+function createBookingInitialState() {
+  return {
+    service: null,
+    availability: null,
+    providers: [],
+    selectedProviderId: null,
+    currentMonth: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth(), 1),
+    calendar: [],
+    selectedDate: null,
+    startDate: null,
+    endDate: null,
+    slots: [],
+    selectedSlot: null,
+    cart: [],
+    timezone: typeof window !== "undefined" ? Intl.DateTimeFormat().resolvedOptions().timeZone : "UTC",
+    tzGroups: {},
+    loading: false,
+    weekdays: BOOKING_WEEKDAYS,
+    quote: null,
+    fetchingQuote: false,
+    quoteError: null,
+    currency: null,
+    dateTimeConfirmed: false,
+    isMultiDay: false,
+    availablePaymentMethods: [],
+    cartId: null,
+    promoCode: null
+  };
+}
+function normalizeTimezoneGroups(groups) {
+  const normalized = {};
+  for (const group of groups) {
+    normalized[group.label] = group.zones.map((zone) => ({
+      zone: zone.value,
+      name: zone.label
+    }));
+  }
+  return normalized;
+}
 function createArkyStore(config) {
   const client = createStorefront(config);
   const session = nanostores.atom(client.session);
@@ -1659,9 +1758,19 @@ function createArkyStore(config) {
     loading_availability: false,
     error: null
   });
+  const booking_state = nanostores.map(createBookingInitialState());
+  const booking_form_node = nanostores.atom(null);
+  const booking_form_blocks = nanostores.computed(booking_form_node, (node) => node?.blocks || []);
   client.onAuthStateChanged((value) => session.set(value));
   snapshot.subscribe((value) => config.onCartChange?.(value));
   last_order.subscribe((value) => writeStoredOrder(config.lastOrderStorageKey, value));
+  currency.subscribe((value) => booking_state.setKey("currency", value));
+  session.subscribe((value) => {
+    const methods = value?.market?.payment_methods || [];
+    if (methods.length && booking_state.get().availablePaymentMethods.length === 0) {
+      booking_state.setKey("availablePaymentMethods", methods);
+    }
+  });
   function currentMarketKey() {
     return market_key.get() || client.getMarket() || market.get()?.key || "";
   }
@@ -1923,6 +2032,485 @@ function createArkyStore(config) {
       cart_status.setKey("processing_checkout", false);
     }
   }
+  function bookingCalendar() {
+    const state = booking_state.get();
+    const { currentMonth, selectedDate, startDate, endDate, availability, selectedProviderId } = state;
+    const year = currentMonth.getFullYear();
+    const monthIndex = currentMonth.getMonth();
+    const first = new Date(year, monthIndex, 1);
+    const last = new Date(year, monthIndex + 1, 0);
+    const today = /* @__PURE__ */ new Date();
+    today.setHours(0, 0, 0, 0);
+    const cells = [];
+    const pad = (first.getDay() + 6) % 7;
+    for (let i = 0; i < pad; i++) {
+      cells.push({
+        date: /* @__PURE__ */ new Date(0),
+        iso: "",
+        available: false,
+        isSelected: false,
+        isInRange: false,
+        isToday: false,
+        blank: true
+      });
+    }
+    for (let day = 1; day <= last.getDate(); day++) {
+      const date = new Date(year, monthIndex, day);
+      const iso = `${year}-${String(monthIndex + 1).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+      const isSelected = iso === selectedDate || iso === startDate || iso === endDate;
+      let isInRange = false;
+      if (startDate && endDate) {
+        const time = date.getTime();
+        isInRange = time > new Date(startDate).getTime() && time < new Date(endDate).getTime();
+      }
+      cells.push({
+        date,
+        iso,
+        available: hasAvailableSlotsForDate(availability, iso, selectedProviderId),
+        isSelected,
+        isInRange,
+        isToday: date.getTime() === today.getTime(),
+        blank: false
+      });
+    }
+    const suffix = (7 - cells.length % 7) % 7;
+    for (let i = 0; i < suffix; i++) {
+      cells.push({
+        date: /* @__PURE__ */ new Date(0),
+        iso: "",
+        available: false,
+        isSelected: false,
+        isInRange: false,
+        isToday: false,
+        blank: true
+      });
+    }
+    return cells;
+  }
+  function computeBookingSlots(dateStr) {
+    const state = booking_state.get();
+    const { availability, selectedProviderId, timezone, service } = state;
+    return getSlotsForDate(availability, dateStr, selectedProviderId).map((slot, index) => ({
+      id: `${service?.id || "service"}-${slot.from}-${index}`,
+      serviceId: service?.id || "",
+      providerId: slot.providerId,
+      from: slot.from,
+      to: slot.to,
+      timeText: formatBookingSlotTime(slot.from, slot.to, timezone),
+      dateText: new Date(slot.from * 1e3).toLocaleDateString([], {
+        weekday: "short",
+        month: "short",
+        day: "numeric",
+        timeZone: timezone
+      })
+    }));
+  }
+  function toServiceCartItem(slot) {
+    return {
+      id: slot.id,
+      service_id: slot.serviceId,
+      provider_id: slot.providerId,
+      from: slot.from,
+      to: slot.to,
+      forms: [],
+      service_name: slot.serviceName,
+      date_text: slot.dateText,
+      time_text: slot.timeText,
+      is_multi_day: slot.isMultiDay
+    };
+  }
+  function fromServiceCartItem(item) {
+    return {
+      id: item.id,
+      serviceId: item.service_id,
+      providerId: item.provider_id,
+      from: item.from,
+      to: item.to,
+      serviceName: item.service_name || "",
+      date: item.date_text || "",
+      dateText: item.date_text || "",
+      timeText: item.time_text || formatBookingSlotTime(item.from, item.to, booking_state.get().timezone),
+      isMultiDay: item.is_multi_day
+    };
+  }
+  function setBookingCartFromServiceItems(items) {
+    const next = items.map(fromServiceCartItem);
+    const current = booking_state.get().cart;
+    if (JSON.stringify(current) !== JSON.stringify(next)) {
+      booking_state.setKey("cart", next);
+    }
+  }
+  async function syncBookingCart(slots) {
+    try {
+      return await syncCart({
+        product_items: product_items.get(),
+        service_items: slots.map(toServiceCartItem)
+      });
+    } catch (error) {
+      booking_state.setKey("quoteError", readErrorMessage(error, "Failed to sync booking cart."));
+      throw error;
+    }
+  }
+  function bookingCurrentStepName() {
+    const state = booking_state.get();
+    if (!state.service) return "";
+    if (!state.selectedSlot || !state.dateTimeConfirmed) return "datetime";
+    return "review";
+  }
+  const booking_current_step_name = nanostores.computed(booking_state, bookingCurrentStepName);
+  const booking_can_proceed = nanostores.computed(booking_state, (state) => {
+    const step = bookingCurrentStepName();
+    if (step === "datetime") {
+      return state.isMultiDay ? !!(state.startDate && state.endDate && state.selectedSlot) : !!(state.selectedDate && state.selectedSlot);
+    }
+    if (step === "review") return true;
+    return false;
+  });
+  const booking_month_year = nanostores.computed(
+    booking_state,
+    (state) => state.currentMonth.toLocaleString(void 0, { month: "long", year: "numeric" })
+  );
+  const booking_chain_start = nanostores.computed(booking_state, (state) => {
+    if (!state.cart.length) return null;
+    return Math.max(...state.cart.map((slot) => slot.to));
+  });
+  const booking_total_steps = nanostores.computed(booking_state, (state) => state.service ? 2 : 0);
+  const booking_steps = nanostores.computed(booking_state, () => ({
+    1: { name: "datetime" },
+    2: { name: "review" }
+  }));
+  const booking_current_step = nanostores.computed([booking_current_step_name, booking_steps], (name, steps) => {
+    for (const [idx, step] of Object.entries(steps)) {
+      if (step.name === name) return Number(idx);
+    }
+    return 1;
+  });
+  function formatBookingDateDisplay(value) {
+    if (!value) return "";
+    return new Date(value).toLocaleDateString(void 0, { month: "short", day: "numeric" });
+  }
+  function serviceProviderId(provider) {
+    return "provider_id" in provider ? provider.provider_id : provider.id;
+  }
+  function getFirstServiceProviderEntry(state) {
+    const serviceWithProviders = state.service;
+    const providers = serviceWithProviders?.providers;
+    if (!providers?.length) return null;
+    if (state.selectedProviderId) {
+      const match = providers.find((provider) => provider.provider_id === state.selectedProviderId);
+      if (match) return match;
+    }
+    return providers[0];
+  }
+  async function loadBookingForm() {
+    try {
+      const form = await loadForm({ key: config.serviceOrderFormKey || "order-form" });
+      const blocks = (form.schema || []).map(formSchemaToBlock);
+      booking_form_node.set({ blocks });
+      return blocks;
+    } catch {
+      booking_form_node.set({ blocks: [] });
+      return [];
+    }
+  }
+  const booking_actions = {
+    async initialize() {
+      booking_state.setKey("tzGroups", normalizeTimezoneGroups(client.utils.tzGroups));
+      await ensureCart();
+      setBookingCartFromServiceItems(service_items.get());
+      const methods = session.get()?.market?.payment_methods || [];
+      if (methods.length) booking_state.setKey("availablePaymentMethods", methods);
+      await loadBookingForm();
+    },
+    setTimezone(tz) {
+      booking_state.setKey("timezone", tz);
+      booking_state.setKey("calendar", bookingCalendar());
+      const state = booking_state.get();
+      if (state.selectedDate) {
+        booking_state.setKey("slots", computeBookingSlots(state.selectedDate));
+        booking_state.setKey("selectedSlot", null);
+      }
+    },
+    async setService(service) {
+      booking_state.setKey("loading", true);
+      try {
+        const isMultiDayBlock = service.blocks?.find((block) => block.key === "isMultiDay");
+        const blockValue = isMultiDayBlock?.value;
+        const isMultiDay = Array.isArray(blockValue) ? blockValue[0] === true : blockValue === true;
+        const [fullService, serviceProviders] = await Promise.all([
+          client.eshop.service.get({ id: service.id }),
+          client.eshop.service.findProviders({ service_id: service.id })
+        ]);
+        const providerIds = [...new Set(serviceProviders.map(serviceProviderId))];
+        const providerResults = await Promise.all(
+          providerIds.map((id) => client.eshop.provider.get({ id }).catch(() => null))
+        );
+        booking_state.set({
+          ...booking_state.get(),
+          service: fullService,
+          providers: providerResults.filter((provider) => provider !== null),
+          selectedProviderId: null,
+          availability: null,
+          selectedDate: null,
+          startDate: null,
+          endDate: null,
+          slots: [],
+          selectedSlot: null,
+          currentMonth: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth(), 1),
+          loading: false,
+          isMultiDay
+        });
+        await booking_actions.loadMonth();
+      } catch (error) {
+        booking_state.setKey("loading", false);
+        throw error;
+      }
+    },
+    async loadMonth() {
+      const state = booking_state.get();
+      if (!state.service) return;
+      booking_state.setKey("loading", true);
+      try {
+        const chainedStart = booking_chain_start.get();
+        let from;
+        let to;
+        if (chainedStart) {
+          from = chainedStart;
+          to = chainedStart;
+        } else {
+          const month = state.currentMonth;
+          from = Math.floor(Date.UTC(month.getFullYear(), month.getMonth(), 1) / 1e3);
+          to = Math.floor(Date.UTC(month.getFullYear(), month.getMonth() + 1, 1) / 1e3);
+        }
+        const availability = await loadAvailability({
+          service_id: state.service.id,
+          from,
+          to
+        });
+        booking_state.setKey("availability", availability);
+        booking_state.setKey("calendar", bookingCalendar());
+      } finally {
+        booking_state.setKey("loading", false);
+      }
+    },
+    prevMonth() {
+      const { currentMonth } = booking_state.get();
+      booking_state.setKey("currentMonth", new Date(currentMonth.getFullYear(), currentMonth.getMonth() - 1, 1));
+      void booking_actions.loadMonth();
+    },
+    nextMonth() {
+      const { currentMonth } = booking_state.get();
+      booking_state.setKey("currentMonth", new Date(currentMonth.getFullYear(), currentMonth.getMonth() + 1, 1));
+      void booking_actions.loadMonth();
+    },
+    selectProvider(providerId) {
+      booking_state.set({
+        ...booking_state.get(),
+        selectedProviderId: providerId,
+        selectedDate: null,
+        startDate: null,
+        endDate: null,
+        slots: [],
+        selectedSlot: null
+      });
+      void booking_actions.loadMonth();
+    },
+    selectDate(cell) {
+      if (cell.blank || !cell.available) return;
+      booking_state.setKey("dateTimeConfirmed", false);
+      const state = booking_state.get();
+      if (state.isMultiDay) {
+        if (!state.startDate) {
+          booking_state.setKey("startDate", cell.iso);
+          booking_state.setKey("selectedDate", cell.iso);
+          booking_state.setKey("endDate", null);
+          booking_state.setKey("selectedSlot", null);
+        } else if (!state.endDate) {
+          if (cell.date.getTime() < new Date(state.startDate).getTime()) {
+            booking_state.setKey("startDate", cell.iso);
+            booking_state.setKey("endDate", state.startDate);
+          } else {
+            booking_state.setKey("endDate", cell.iso);
+          }
+          booking_actions.createMultiDaySlots();
+        } else {
+          booking_state.setKey("startDate", cell.iso);
+          booking_state.setKey("selectedDate", cell.iso);
+          booking_state.setKey("endDate", null);
+          booking_state.setKey("selectedSlot", null);
+        }
+        booking_actions.updateCalendar();
+      } else {
+        booking_state.set({
+          ...state,
+          selectedDate: cell.iso,
+          slots: computeBookingSlots(cell.iso),
+          selectedSlot: null
+        });
+        booking_state.setKey("calendar", bookingCalendar());
+      }
+    },
+    createMultiDaySlots() {
+      const state = booking_state.get();
+      if (!state.startDate || !state.endDate || !state.availability) return;
+      const slots = [];
+      for (let day = new Date(state.startDate); day <= new Date(state.endDate); day.setDate(day.getDate() + 1)) {
+        const iso = day.toISOString().slice(0, 10);
+        for (const slot of getSlotsForDate(state.availability, iso, state.selectedProviderId)) {
+          slots.push({
+            id: `${state.service?.id || "service"}-${slot.from}-${slots.length}`,
+            serviceId: state.service?.id || "",
+            providerId: slot.providerId,
+            from: slot.from,
+            to: slot.to,
+            timeText: formatBookingSlotTime(slot.from, slot.to, state.timezone),
+            dateText: new Date(slot.from * 1e3).toLocaleDateString([], {
+              weekday: "short",
+              month: "short",
+              day: "numeric",
+              timeZone: state.timezone
+            }),
+            isMultiDay: true
+          });
+        }
+      }
+      booking_state.setKey("slots", slots);
+      booking_state.setKey("selectedSlot", slots.length === 1 ? slots[0] : null);
+    },
+    selectTimeSlot(slot) {
+      booking_state.setKey("dateTimeConfirmed", false);
+      booking_state.setKey("selectedSlot", slot);
+    },
+    resetDateSelection() {
+      booking_state.setKey("selectedDate", null);
+      booking_state.setKey("startDate", null);
+      booking_state.setKey("endDate", null);
+      booking_state.setKey("slots", []);
+      booking_state.setKey("selectedSlot", null);
+      booking_state.setKey("dateTimeConfirmed", false);
+    },
+    updateCalendar() {
+      booking_state.setKey("calendar", bookingCalendar());
+    },
+    findFirstAvailable() {
+      for (const day of booking_state.get().calendar) {
+        if (!day.blank && day.available) {
+          booking_actions.selectDate(day);
+          return;
+        }
+      }
+    },
+    async addToCart() {
+      const state = booking_state.get();
+      const serviceBlocks = state.service?.forms || [];
+      const enrich = (slot) => ({
+        ...slot,
+        serviceName: state.service ? serviceName(state.service, currentLocale()) : "",
+        date: slot.dateText,
+        serviceBlocks
+      });
+      const selected = state.isMultiDay && state.slots.length > 0 ? state.slots.map(enrich) : state.selectedSlot ? [enrich(state.selectedSlot)] : [];
+      if (!selected.length) return;
+      const nextCart = [...state.cart, ...selected];
+      booking_state.set({
+        ...state,
+        cart: nextCart,
+        selectedDate: null,
+        startDate: null,
+        endDate: null,
+        slots: [],
+        selectedSlot: null
+      });
+      await syncBookingCart(nextCart);
+      booking_state.setKey("calendar", bookingCalendar());
+    },
+    async removeFromCart(slotId) {
+      const nextCart = booking_state.get().cart.filter((slot) => slot.id !== slotId);
+      booking_state.setKey("cart", nextCart);
+      await syncBookingCart(nextCart);
+    },
+    async clearCart() {
+      booking_state.setKey("cart", []);
+      await syncBookingCart([]);
+    },
+    async checkout(paymentMethodId, forms = []) {
+      const state = booking_state.get();
+      if (!state.cart.length) return { success: false, error: "Cart is empty" };
+      booking_state.setKey("loading", true);
+      try {
+        const result = await checkout({
+          service_items: state.cart.map((slot) => ({
+            ...toServiceCartItem(slot),
+            forms: []
+          })),
+          payment_method_id: paymentMethodId,
+          promo_code: state.promoCode || void 0,
+          forms
+        });
+        booking_state.setKey("cartId", cart.get()?.id || null);
+        return { success: true, data: result };
+      } catch (error) {
+        return { success: false, error: readErrorMessage(error, "Checkout failed.") };
+      } finally {
+        booking_state.setKey("loading", false);
+      }
+    },
+    async fetchQuote(paymentMethodId, promoCode) {
+      const state = booking_state.get();
+      if (!state.cart.length) return null;
+      booking_state.setKey("fetchingQuote", true);
+      booking_state.setKey("quoteError", null);
+      try {
+        booking_state.setKey("promoCode", promoCode || null);
+        const response = await fetchQuote({
+          service_items: state.cart.map(toServiceCartItem),
+          payment_method_id: paymentMethodId,
+          promo_code: promoCode || void 0
+        });
+        booking_state.setKey("cartId", cart.get()?.id || null);
+        booking_state.setKey("quote", response);
+        const methods = response?.payment_methods || session.get()?.market?.payment_methods || [];
+        if (methods.length) booking_state.setKey("availablePaymentMethods", methods);
+        return response;
+      } catch (error) {
+        booking_state.setKey("quoteError", readErrorMessage(error, "Failed to fetch quote."));
+        return null;
+      } finally {
+        booking_state.setKey("fetchingQuote", false);
+      }
+    },
+    getProvidersList() {
+      return booking_state.get().providers;
+    },
+    prevStep() {
+      const current = bookingCurrentStepName();
+      if (current === "review") {
+        booking_state.setKey("dateTimeConfirmed", false);
+        return;
+      }
+      if (current === "datetime") {
+        booking_state.setKey("selectedSlot", null);
+        booking_state.setKey("dateTimeConfirmed", false);
+      }
+    },
+    nextStep() {
+      if (bookingCurrentStepName() === "datetime" && booking_can_proceed.get()) {
+        booking_state.setKey("dateTimeConfirmed", true);
+      }
+    },
+    getServicePrice() {
+      const state = booking_state.get();
+      if (state.quote?.total !== void 0) return String(state.quote.total);
+      const provider = getFirstServiceProviderEntry(state);
+      if (!provider?.prices) return "";
+      return client.utils.formatPrice(provider.prices) || "0";
+    },
+    formatDateDisplay: formatBookingDateDisplay,
+    serviceItemsFromSlots(slots) {
+      return slots.map(toServiceCartItem);
+    }
+  };
+  service_items.subscribe((items) => setBookingCartFromServiceItems(items));
   async function loadNode(params, options) {
     cms_state.setKey("loading", true);
     cms_state.setKey("error", null);
@@ -2126,6 +2714,18 @@ function createArkyStore(config) {
         buildServiceItems: toServiceCheckoutItems
       }
     },
+    booking: {
+      state: booking_state,
+      form_blocks: booking_form_blocks,
+      current_step_name: booking_current_step_name,
+      can_proceed: booking_can_proceed,
+      month_year: booking_month_year,
+      chain_start: booking_chain_start,
+      total_steps: booking_total_steps,
+      steps: booking_steps,
+      current_step: booking_current_step,
+      actions: booking_actions
+    },
     crm: client.crm,
     activity: {
       track(params) {