arky-sdk 0.3.76 → 0.3.78

package/dist/index.cjs

@@ -1,5 +1,7 @@
 'use strict';
 
+var nanostores = require('nanostores');
+
 // src/types/index.ts
 var PaymentMethodType = /* @__PURE__ */ ((PaymentMethodType2) => {
   PaymentMethodType2["Cash"] = "CASH";
@@ -980,7 +982,21 @@ var createEshopApi = (apiConfig) => {
 
 // src/api/reservation.ts
 var createReservationApi = (apiConfig) => {
+  let cart = [];
   return {
+    // ===== CART =====
+    addToCart(slot) {
+      cart.push(slot);
+    },
+    removeFromCart(slotId) {
+      cart = cart.filter((s) => s.id !== slotId);
+    },
+    getCart() {
+      return [...cart];
+    },
+    clearCart() {
+      cart = [];
+    },
     // ===== RESERVATIONS =====
     async createReservation(params, options) {
       const payload = {
@@ -999,16 +1015,25 @@ var createReservationApi = (apiConfig) => {
       );
     },
     async checkout(params, options) {
+      const items = params?.items || cart.map((s) => ({
+        serviceId: s.serviceId,
+        providerId: s.providerId,
+        from: s.from,
+        to: s.to
+      }));
       const payload = {
         businessId: apiConfig.businessId,
         market: apiConfig.market,
-        ...params
+        ...params,
+        items
       };
-      return apiConfig.httpClient.post(
+      const result = await apiConfig.httpClient.post(
         `/v1/reservations/checkout`,
         payload,
         options
       );
+      cart = [];
+      return result;
     },
     async getReservation(params, options) {
       return apiConfig.httpClient.get(`/v1/reservations/${params.id}`, {
@@ -1095,16 +1120,13 @@ var createReservationApi = (apiConfig) => {
         }
       );
     },
-    async getAvailableSlots(params, options) {
+    async getServiceProviders(params, options) {
       const { serviceId, ...queryParams } = params;
       return apiConfig.httpClient.get(
-        `/v1/businesses/${apiConfig.businessId}/services/${serviceId}/available-slots`,
+        `/v1/businesses/${apiConfig.businessId}/services/${serviceId}/providers`,
         {
           ...options,
-          params: {
-            ...queryParams,
-            limit: queryParams.limit || 1e3
-          }
+          params: queryParams
         }
       );
     },
@@ -1678,9 +1700,328 @@ async function injectSvgIntoElement(mediaObject, targetElement, className) {
     console.error("Error injecting SVG:", error);
   }
 }
+function formatTime(ts, tz) {
+  return new Date(ts * 1e3).toLocaleTimeString([], {
+    hour: "2-digit",
+    minute: "2-digit",
+    timeZone: tz
+  });
+}
+function formatSlotTime(from, to, tz) {
+  return `${formatTime(from, tz)} \u2013 ${formatTime(to, tz)}`;
+}
+function getTzOffset(date, tz) {
+  const utc = new Date(date.toLocaleString("en-US", { timeZone: "UTC" }));
+  const local = new Date(date.toLocaleString("en-US", { timeZone: tz }));
+  return (utc.getTime() - local.getTime()) / 6e4;
+}
+function toUtcTimestamp(year, month, day, mins, tz) {
+  const midnight = new Date(Date.UTC(year, month - 1, day));
+  const offset = getTzOffset(midnight, tz);
+  return Math.floor(midnight.getTime() / 1e3) + (mins + offset) * 60;
+}
+function isBlocked(from, to, timeline, limit) {
+  const before = timeline.filter((p) => p.timestamp <= from).sort((a, b) => b.timestamp - a.timestamp);
+  if (before.length > 0 && before[0].concurrent >= limit) return true;
+  for (const p of timeline) {
+    if (p.timestamp >= from && p.timestamp < to && p.concurrent >= limit) return true;
+  }
+  return false;
+}
+function getTotalDuration(durations) {
+  return durations.reduce((sum, d) => sum + d.duration, 0);
+}
+function getWorkingHoursForDate(wt, date, tz) {
+  if (!wt) return [];
+  const dayName = date.toLocaleDateString("en-US", { weekday: "long", timeZone: tz }).toLowerCase();
+  const m = date.getMonth() + 1;
+  const d = date.getDate();
+  const ts = Math.floor(date.getTime() / 1e3);
+  const specific = wt.specificDates?.find((s) => s.date === ts);
+  if (specific) return specific.workingHours || [];
+  const outcast = wt.outcastDates?.find((o) => o.month === m && o.day === d);
+  if (outcast) return outcast.workingHours || [];
+  return wt.workingDays?.find((w) => w.day === dayName)?.workingHours || [];
+}
+function computeSlotsForDate(opts) {
+  const { providers, date, durations, timezone, slotInterval } = opts;
+  const total = getTotalDuration(durations);
+  const interval = slotInterval || total;
+  const slots = [];
+  const nowTs = Math.floor(Date.now() / 1e3);
+  const today = /* @__PURE__ */ new Date();
+  today.setHours(0, 0, 0, 0);
+  if (date < today) return [];
+  const [year, month, day] = date.toLocaleDateString("en-CA", { timeZone: timezone }).split("-").map(Number);
+  for (const p of providers) {
+    for (const wh of getWorkingHoursForDate(p.workingTime, date, timezone)) {
+      for (let m = wh.from; m + total <= wh.to; m += interval) {
+        const from = toUtcTimestamp(year, month, day, m, timezone);
+        const to = from + total * 60;
+        if (from < nowTs) continue;
+        if (!isBlocked(from, to, p.timeline, p.concurrentLimit)) {
+          slots.push({ from, to, providerId: p.id });
+        }
+      }
+    }
+  }
+  return slots.sort((a, b) => a.from - b.from);
+}
+function hasAvailableSlots(opts) {
+  return computeSlotsForDate(opts).length > 0;
+}
+var createInitialState = (timezone) => ({
+  service: null,
+  providers: [],
+  selectedProvider: null,
+  selectedMethod: 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,
+  loading: false
+});
+var createReservationEngine = (api, config = {}) => {
+  const timezone = config.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const store = nanostores.map(createInitialState(timezone));
+  const getServiceDurations = () => {
+    const state = store.get();
+    if (!state.service?.durations?.length) return [{ duration: 60, isPause: false }];
+    return state.service.durations.map((d) => ({
+      duration: d.duration,
+      isPause: d.isPause || d.is_pause || false
+    }));
+  };
+  const buildCalendar = () => {
+    const state = store.get();
+    const { currentMonth, selectedDate, startDate, endDate, providers, selectedProvider, timezone: timezone2 } = state;
+    const year = currentMonth.getFullYear();
+    const month = currentMonth.getMonth();
+    const first = new Date(year, month, 1);
+    const last = new Date(year, month + 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 });
+    }
+    const activeProviders = selectedProvider ? providers.filter((p) => p.id === selectedProvider.id) : providers;
+    const durations = getServiceDurations();
+    for (let d = 1; d <= last.getDate(); d++) {
+      const date = new Date(year, month, d);
+      const iso = `${year}-${String(month + 1).padStart(2, "0")}-${String(d).padStart(2, "0")}`;
+      const available = activeProviders.length > 0 && hasAvailableSlots({ providers: activeProviders, date, durations, timezone: timezone2 });
+      const isToday = date.getTime() === today.getTime();
+      const isSelected = iso === selectedDate || iso === startDate || iso === endDate;
+      let isInRange = false;
+      if (startDate && endDate) {
+        const t = date.getTime();
+        isInRange = t > new Date(startDate).getTime() && t < new Date(endDate).getTime();
+      }
+      cells.push({ date, iso, available, isSelected, isInRange, isToday, 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;
+  };
+  const computeSlots = (dateStr) => {
+    const state = store.get();
+    const { providers, selectedProvider, timezone: timezone2, service } = state;
+    const date = /* @__PURE__ */ new Date(dateStr + "T00:00:00");
+    const activeProviders = selectedProvider ? providers.filter((p) => p.id === selectedProvider.id) : providers;
+    const raw = computeSlotsForDate({ providers: activeProviders, date, durations: getServiceDurations(), timezone: timezone2 });
+    return raw.map((s, i) => ({
+      id: `${service?.id}-${s.from}-${i}`,
+      serviceId: service?.id || "",
+      providerId: s.providerId,
+      from: s.from,
+      to: s.to,
+      timeText: formatSlotTime(s.from, s.to, timezone2),
+      dateText: new Date(s.from * 1e3).toLocaleDateString([], { weekday: "short", month: "short", day: "numeric", timeZone: timezone2 })
+    }));
+  };
+  const actions = {
+    setTimezone(tz) {
+      store.setKey("timezone", tz);
+      store.setKey("calendar", buildCalendar());
+      const state = store.get();
+      if (state.selectedDate) {
+        store.setKey("slots", computeSlots(state.selectedDate));
+        store.setKey("selectedSlot", null);
+      }
+    },
+    async setService(serviceId) {
+      store.setKey("loading", true);
+      try {
+        const service = await api.getService({ id: serviceId });
+        store.set({
+          ...store.get(),
+          service,
+          selectedMethod: service.reservationMethods?.length === 1 ? service.reservationMethods[0] : null,
+          selectedProvider: null,
+          providers: [],
+          selectedDate: null,
+          startDate: null,
+          endDate: null,
+          slots: [],
+          selectedSlot: null,
+          currentMonth: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth(), 1),
+          loading: false
+        });
+        await actions.loadMonth();
+      } catch (e) {
+        store.setKey("loading", false);
+        throw e;
+      }
+    },
+    async loadMonth() {
+      const state = store.get();
+      if (!state.service) return;
+      store.setKey("loading", true);
+      try {
+        const { currentMonth, service } = state;
+        const year = currentMonth.getFullYear();
+        const month = currentMonth.getMonth();
+        const from = Math.floor(new Date(year, month, 1).getTime() / 1e3);
+        const to = Math.floor(new Date(year, month + 1, 0, 23, 59, 59).getTime() / 1e3);
+        const providers = await api.getServiceProviders({ serviceId: service.id, from, to });
+        store.setKey("providers", providers || []);
+        store.setKey("calendar", buildCalendar());
+      } finally {
+        store.setKey("loading", false);
+      }
+    },
+    prevMonth() {
+      const { currentMonth } = store.get();
+      store.setKey("currentMonth", new Date(currentMonth.getFullYear(), currentMonth.getMonth() - 1, 1));
+      actions.loadMonth();
+    },
+    nextMonth() {
+      const { currentMonth } = store.get();
+      store.setKey("currentMonth", new Date(currentMonth.getFullYear(), currentMonth.getMonth() + 1, 1));
+      actions.loadMonth();
+    },
+    selectMethod(method) {
+      store.set({
+        ...store.get(),
+        selectedMethod: method,
+        selectedProvider: null,
+        selectedDate: null,
+        startDate: null,
+        endDate: null,
+        slots: [],
+        selectedSlot: null
+      });
+      store.setKey("calendar", buildCalendar());
+    },
+    selectProvider(provider) {
+      store.set({
+        ...store.get(),
+        selectedProvider: provider,
+        selectedDate: null,
+        startDate: null,
+        endDate: null,
+        slots: [],
+        selectedSlot: null
+      });
+      store.setKey("calendar", buildCalendar());
+    },
+    selectDate(day) {
+      if (day.blank || !day.available) return;
+      const state = store.get();
+      const slots = computeSlots(day.iso);
+      store.set({ ...state, selectedDate: day.iso, slots, selectedSlot: null });
+      store.setKey("calendar", buildCalendar());
+    },
+    selectSlot(slot) {
+      store.setKey("selectedSlot", slot);
+    },
+    findFirstAvailable() {
+      const state = store.get();
+      for (const day of state.calendar) {
+        if (!day.blank && day.available) {
+          actions.selectDate(day);
+          return;
+        }
+      }
+    },
+    updateCalendar() {
+      store.setKey("calendar", buildCalendar());
+    },
+    addToCart() {
+      const state = store.get();
+      if (!state.selectedSlot) return;
+      store.set({
+        ...state,
+        cart: [...state.cart, state.selectedSlot],
+        selectedDate: null,
+        startDate: null,
+        endDate: null,
+        slots: [],
+        selectedSlot: null
+      });
+      store.setKey("calendar", buildCalendar());
+    },
+    removeFromCart(slotId) {
+      const state = store.get();
+      store.setKey("cart", state.cart.filter((s) => s.id !== slotId));
+    },
+    clearCart() {
+      store.setKey("cart", []);
+    },
+    async checkout(options = {}) {
+      const state = store.get();
+      if (!state.cart.length) throw new Error("Cart is empty");
+      store.setKey("loading", true);
+      try {
+        const result = await api.checkout({
+          items: state.cart.map((s) => ({
+            serviceId: s.serviceId,
+            providerId: s.providerId,
+            from: s.from,
+            to: s.to,
+            blocks: s.serviceBlocks || [],
+            reservationMethod: s.reservationMethod || state.selectedMethod || "STANDARD"
+          })),
+          paymentMethod: options.paymentMethod,
+          promoCode: options.promoCode ?? null,
+          blocks: options.blocks || []
+        });
+        store.setKey("cart", []);
+        return result;
+      } finally {
+        store.setKey("loading", false);
+      }
+    },
+    async getQuote(options = {}) {
+      const state = store.get();
+      if (!state.cart.length) return null;
+      return api.getQuote({
+        items: state.cart.map((s) => ({ serviceId: s.serviceId })),
+        paymentMethod: options.paymentMethod || "CASH",
+        promoCode: options.promoCode
+      });
+    },
+    async getProvidersList() {
+      const state = store.get();
+      if (!state.service) return [];
+      const response = await api.getProviders({ serviceId: state.service.id, limit: 100 });
+      return response?.items || [];
+    }
+  };
+  return { store, ...actions };
+};
 
 // src/index.ts
-var SDK_VERSION = "0.3.73";
+var SDK_VERSION = "0.3.78";
 var SUPPORTED_FRAMEWORKS = [
   "astro",
   "react",
@@ -1730,6 +2071,11 @@ async function createArkySDK(config) {
     reservation: createReservationApi(apiConfig),
     database: createDatabaseApi(apiConfig),
     featureFlags: createFeatureFlagsApi(apiConfig),
+    // High-level reservation engine
+    reservationEngine: (engineConfig) => {
+      const reservationApi = createReservationApi(apiConfig);
+      return createReservationEngine(reservationApi, engineConfig);
+    },
     setBusinessId: (businessId) => {
       apiConfig.businessId = businessId;
     },