arky-sdk 0.7.128 → 0.7.129

package/dist/storefront-store.cjs

@@ -134,8 +134,7 @@ var getImageUrl = (imageBlock, isBlock = true) => {
 function normalizeOrderCheckoutItems(items) {
   return items.map((item) => {
     if ("type" in item) {
-      const type = item.type;
-      return type === "booking" ? { ...item, type: "service" } : item;
+      return item;
     }
     if ("product_id" in item) {
       return { type: "product", ...item };
@@ -1607,15 +1606,15 @@ function formSchemaToBlock(field) {
     value: getFormBlockValue(field)
   };
 }
-function formatBookingTime(ts, tz) {
+function formatServiceOrderTime(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 formatServiceOrderSlotTime(from, to, tz) {
+  return `${formatServiceOrderTime(from, tz)} - ${formatServiceOrderTime(to, tz)}`;
 }
 function getSlotsForDate(availability, dateStr, providerId) {
   if (!availability) return [];
@@ -1638,8 +1637,8 @@ function hasAvailableSlotsForDate(availability, dateStr, providerId) {
     return !!day?.slots.some((slot) => slot.spots > 0);
   });
 }
-var BOOKING_WEEKDAYS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
-function createBookingInitialState() {
+var SERVICE_ORDER_WEEKDAYS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+function createServiceOrderInitialState() {
   return {
     service: null,
     availability: null,
@@ -1656,7 +1655,7 @@ function createBookingInitialState() {
     timezone: typeof window !== "undefined" ? Intl.DateTimeFormat().resolvedOptions().timeZone : "UTC",
     tzGroups: {},
     loading: false,
-    weekdays: BOOKING_WEEKDAYS,
+    weekdays: SERVICE_ORDER_WEEKDAYS,
     quote: null,
     fetchingQuote: false,
     quoteError: null,
@@ -1741,16 +1740,16 @@ 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 || []);
+  const service_order_state = nanostores.map(createServiceOrderInitialState());
+  const service_order_form_node = nanostores.atom(null);
+  const service_order_form_blocks = nanostores.computed(service_order_form_node, (node) => node?.blocks || []);
   client.onAuthStateChanged((value) => session.set(value));
   snapshot.subscribe((value) => config.onCartChange?.(value));
-  currency.subscribe((value) => booking_state.setKey("currency", value));
+  currency.subscribe((value) => service_order_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);
+    if (methods.length && service_order_state.get().availablePaymentMethods.length === 0) {
+      service_order_state.setKey("availablePaymentMethods", methods);
     }
   });
   function currentMarketKey() {
@@ -2014,8 +2013,8 @@ function createArkyStore(config) {
       cart_status.setKey("processing_checkout", false);
     }
   }
-  function bookingCalendar() {
-    const state = booking_state.get();
+  function serviceOrderCalendar() {
+    const state = service_order_state.get();
     const { currentMonth, selectedDate, startDate, endDate, availability, selectedProviderId } = state;
     const year = currentMonth.getFullYear();
     const monthIndex = currentMonth.getMonth();
@@ -2069,8 +2068,8 @@ function createArkyStore(config) {
     }
     return cells;
   }
-  function computeBookingSlots(dateStr) {
-    const state = booking_state.get();
+  function computeServiceOrderSlots(dateStr) {
+    const state = service_order_state.get();
     const { availability, selectedProviderId, timezone, service } = state;
     return getSlotsForDate(availability, dateStr, selectedProviderId).map((slot, index) => ({
       id: `${service?.id || "service"}-${slot.from}-${index}`,
@@ -2078,7 +2077,7 @@ function createArkyStore(config) {
       providerId: slot.providerId,
       from: slot.from,
       to: slot.to,
-      timeText: formatBookingSlotTime(slot.from, slot.to, timezone),
+      timeText: formatServiceOrderSlotTime(slot.from, slot.to, timezone),
       dateText: new Date(slot.from * 1e3).toLocaleDateString([], {
         weekday: "short",
         month: "short",
@@ -2111,63 +2110,63 @@ function createArkyStore(config) {
       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),
+      timeText: item.time_text || formatServiceOrderSlotTime(item.from, item.to, service_order_state.get().timezone),
       isMultiDay: item.is_multi_day
     };
   }
-  function setBookingCartFromServiceItems(items) {
+  function setServiceOrderCartFromServiceItems(items) {
     const next = items.map(fromServiceCartItem);
-    const current = booking_state.get().cart;
+    const current = service_order_state.get().cart;
     if (JSON.stringify(current) !== JSON.stringify(next)) {
-      booking_state.setKey("cart", next);
+      service_order_state.setKey("cart", next);
     }
   }
-  async function syncBookingCart(slots) {
+  async function syncServiceOrderCart(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."));
+      service_order_state.setKey("quoteError", readErrorMessage(error, "Failed to sync service order cart."));
       throw error;
     }
   }
-  function bookingCurrentStepName() {
-    const state = booking_state.get();
+  function serviceOrderCurrentStepName() {
+    const state = service_order_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();
+  const service_order_current_step_name = nanostores.computed(service_order_state, serviceOrderCurrentStepName);
+  const service_order_can_proceed = nanostores.computed(service_order_state, (state) => {
+    const step = serviceOrderCurrentStepName();
     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,
+  const service_order_month_year = nanostores.computed(
+    service_order_state,
     (state) => state.currentMonth.toLocaleString(void 0, { month: "long", year: "numeric" })
   );
-  const booking_chain_start = nanostores.computed(booking_state, (state) => {
+  const service_order_chain_start = nanostores.computed(service_order_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, () => ({
+  const service_order_total_steps = nanostores.computed(service_order_state, (state) => state.service ? 2 : 0);
+  const service_order_steps = nanostores.computed(service_order_state, () => ({
     1: { name: "datetime" },
     2: { name: "review" }
   }));
-  const booking_current_step = nanostores.computed([booking_current_step_name, booking_steps], (name, steps) => {
+  const service_order_current_step = nanostores.computed([service_order_current_step_name, service_order_steps], (name, steps) => {
     for (const [idx, step] of Object.entries(steps)) {
       if (step.name === name) return Number(idx);
     }
     return 1;
   });
-  function formatBookingDateDisplay(value) {
+  function formatServiceOrderDateDisplay(value) {
     if (!value) return "";
     return new Date(value).toLocaleDateString(void 0, { month: "short", day: "numeric" });
   }
@@ -2184,37 +2183,37 @@ function createArkyStore(config) {
     }
     return providers[0];
   }
-  async function loadBookingForm() {
+  async function loadServiceOrderForm() {
     try {
       const form = await loadForm({ key: "order-form" });
       const blocks = (form.schema || []).map(formSchemaToBlock);
-      booking_form_node.set({ blocks });
+      service_order_form_node.set({ blocks });
       return blocks;
     } catch {
-      booking_form_node.set({ blocks: [] });
+      service_order_form_node.set({ blocks: [] });
       return [];
     }
   }
-  const booking_actions = {
+  const service_order_actions = {
     async initialize() {
-      booking_state.setKey("tzGroups", normalizeTimezoneGroups(client.utils.tzGroups));
+      service_order_state.setKey("tzGroups", normalizeTimezoneGroups(client.utils.tzGroups));
       await ensureCart();
-      setBookingCartFromServiceItems(service_items.get());
+      setServiceOrderCartFromServiceItems(service_items.get());
       const methods = session.get()?.market?.payment_methods || [];
-      if (methods.length) booking_state.setKey("availablePaymentMethods", methods);
-      await loadBookingForm();
+      if (methods.length) service_order_state.setKey("availablePaymentMethods", methods);
+      await loadServiceOrderForm();
     },
     setTimezone(tz) {
-      booking_state.setKey("timezone", tz);
-      booking_state.setKey("calendar", bookingCalendar());
-      const state = booking_state.get();
+      service_order_state.setKey("timezone", tz);
+      service_order_state.setKey("calendar", serviceOrderCalendar());
+      const state = service_order_state.get();
       if (state.selectedDate) {
-        booking_state.setKey("slots", computeBookingSlots(state.selectedDate));
-        booking_state.setKey("selectedSlot", null);
+        service_order_state.setKey("slots", computeServiceOrderSlots(state.selectedDate));
+        service_order_state.setKey("selectedSlot", null);
       }
     },
     async setService(service) {
-      booking_state.setKey("loading", true);
+      service_order_state.setKey("loading", true);
       try {
         const isMultiDayBlock = service.blocks?.find((block) => block.key === "isMultiDay");
         const blockValue = isMultiDayBlock?.value;
@@ -2227,8 +2226,8 @@ function createArkyStore(config) {
         const providerResults = await Promise.all(
           providerIds.map((id) => client.eshop.provider.get({ id }).catch(() => null))
         );
-        booking_state.set({
-          ...booking_state.get(),
+        service_order_state.set({
+          ...service_order_state.get(),
           service: fullService,
           providers: providerResults.filter((provider) => provider !== null),
           selectedProviderId: null,
@@ -2242,18 +2241,18 @@ function createArkyStore(config) {
           loading: false,
           isMultiDay
         });
-        await booking_actions.loadMonth();
+        await service_order_actions.loadMonth();
       } catch (error) {
-        booking_state.setKey("loading", false);
+        service_order_state.setKey("loading", false);
         throw error;
       }
     },
     async loadMonth() {
-      const state = booking_state.get();
+      const state = service_order_state.get();
       if (!state.service) return;
-      booking_state.setKey("loading", true);
+      service_order_state.setKey("loading", true);
       try {
-        const chainedStart = booking_chain_start.get();
+        const chainedStart = service_order_chain_start.get();
         let from;
         let to;
         if (chainedStart) {
@@ -2269,25 +2268,25 @@ function createArkyStore(config) {
           from,
           to
         });
-        booking_state.setKey("availability", availability);
-        booking_state.setKey("calendar", bookingCalendar());
+        service_order_state.setKey("availability", availability);
+        service_order_state.setKey("calendar", serviceOrderCalendar());
       } finally {
-        booking_state.setKey("loading", false);
+        service_order_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();
+      const { currentMonth } = service_order_state.get();
+      service_order_state.setKey("currentMonth", new Date(currentMonth.getFullYear(), currentMonth.getMonth() - 1, 1));
+      void service_order_actions.loadMonth();
     },
     nextMonth() {
-      const { currentMonth } = booking_state.get();
-      booking_state.setKey("currentMonth", new Date(currentMonth.getFullYear(), currentMonth.getMonth() + 1, 1));
-      void booking_actions.loadMonth();
+      const { currentMonth } = service_order_state.get();
+      service_order_state.setKey("currentMonth", new Date(currentMonth.getFullYear(), currentMonth.getMonth() + 1, 1));
+      void service_order_actions.loadMonth();
     },
     selectProvider(providerId) {
-      booking_state.set({
-        ...booking_state.get(),
+      service_order_state.set({
+        ...service_order_state.get(),
         selectedProviderId: providerId,
         selectedDate: null,
         startDate: null,
@@ -2295,45 +2294,45 @@ function createArkyStore(config) {
         slots: [],
         selectedSlot: null
       });
-      void booking_actions.loadMonth();
+      void service_order_actions.loadMonth();
     },
     selectDate(cell) {
       if (cell.blank || !cell.available) return;
-      booking_state.setKey("dateTimeConfirmed", false);
-      const state = booking_state.get();
+      service_order_state.setKey("dateTimeConfirmed", false);
+      const state = service_order_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);
+          service_order_state.setKey("startDate", cell.iso);
+          service_order_state.setKey("selectedDate", cell.iso);
+          service_order_state.setKey("endDate", null);
+          service_order_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);
+            service_order_state.setKey("startDate", cell.iso);
+            service_order_state.setKey("endDate", state.startDate);
           } else {
-            booking_state.setKey("endDate", cell.iso);
+            service_order_state.setKey("endDate", cell.iso);
           }
-          booking_actions.createMultiDaySlots();
+          service_order_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);
+          service_order_state.setKey("startDate", cell.iso);
+          service_order_state.setKey("selectedDate", cell.iso);
+          service_order_state.setKey("endDate", null);
+          service_order_state.setKey("selectedSlot", null);
         }
-        booking_actions.updateCalendar();
+        service_order_actions.updateCalendar();
       } else {
-        booking_state.set({
+        service_order_state.set({
           ...state,
           selectedDate: cell.iso,
-          slots: computeBookingSlots(cell.iso),
+          slots: computeServiceOrderSlots(cell.iso),
           selectedSlot: null
         });
-        booking_state.setKey("calendar", bookingCalendar());
+        service_order_state.setKey("calendar", serviceOrderCalendar());
       }
     },
     createMultiDaySlots() {
-      const state = booking_state.get();
+      const state = service_order_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)) {
@@ -2345,7 +2344,7 @@ function createArkyStore(config) {
             providerId: slot.providerId,
             from: slot.from,
             to: slot.to,
-            timeText: formatBookingSlotTime(slot.from, slot.to, state.timezone),
+            timeText: formatServiceOrderSlotTime(slot.from, slot.to, state.timezone),
             dateText: new Date(slot.from * 1e3).toLocaleDateString([], {
               weekday: "short",
               month: "short",
@@ -2356,34 +2355,34 @@ function createArkyStore(config) {
           });
         }
       }
-      booking_state.setKey("slots", slots);
-      booking_state.setKey("selectedSlot", slots.length === 1 ? slots[0] : null);
+      service_order_state.setKey("slots", slots);
+      service_order_state.setKey("selectedSlot", slots.length === 1 ? slots[0] : null);
     },
     selectTimeSlot(slot) {
-      booking_state.setKey("dateTimeConfirmed", false);
-      booking_state.setKey("selectedSlot", slot);
+      service_order_state.setKey("dateTimeConfirmed", false);
+      service_order_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);
+      service_order_state.setKey("selectedDate", null);
+      service_order_state.setKey("startDate", null);
+      service_order_state.setKey("endDate", null);
+      service_order_state.setKey("slots", []);
+      service_order_state.setKey("selectedSlot", null);
+      service_order_state.setKey("dateTimeConfirmed", false);
     },
     updateCalendar() {
-      booking_state.setKey("calendar", bookingCalendar());
+      service_order_state.setKey("calendar", serviceOrderCalendar());
     },
     findFirstAvailable() {
-      for (const day of booking_state.get().calendar) {
+      for (const day of service_order_state.get().calendar) {
         if (!day.blank && day.available) {
-          booking_actions.selectDate(day);
+          service_order_actions.selectDate(day);
           return;
         }
       }
     },
     async addToCart() {
-      const state = booking_state.get();
+      const state = service_order_state.get();
       const serviceBlocks = state.service?.forms || [];
       const enrich = (slot) => ({
         ...slot,
@@ -2394,7 +2393,7 @@ function createArkyStore(config) {
       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({
+      service_order_state.set({
         ...state,
         cart: nextCart,
         selectedDate: null,
@@ -2403,22 +2402,22 @@ function createArkyStore(config) {
         slots: [],
         selectedSlot: null
       });
-      await syncBookingCart(nextCart);
-      booking_state.setKey("calendar", bookingCalendar());
+      await syncServiceOrderCart(nextCart);
+      service_order_state.setKey("calendar", serviceOrderCalendar());
     },
     async removeFromCart(slotId) {
-      const nextCart = booking_state.get().cart.filter((slot) => slot.id !== slotId);
-      booking_state.setKey("cart", nextCart);
-      await syncBookingCart(nextCart);
+      const nextCart = service_order_state.get().cart.filter((slot) => slot.id !== slotId);
+      service_order_state.setKey("cart", nextCart);
+      await syncServiceOrderCart(nextCart);
     },
     async clearCart() {
-      booking_state.setKey("cart", []);
-      await syncBookingCart([]);
+      service_order_state.setKey("cart", []);
+      await syncServiceOrderCart([]);
     },
     async checkout(paymentMethodId, forms = []) {
-      const state = booking_state.get();
+      const state = service_order_state.get();
       if (!state.cart.length) return { success: false, error: "Cart is empty" };
-      booking_state.setKey("loading", true);
+      service_order_state.setKey("loading", true);
       try {
         const result = await checkout({
           service_items: state.cart.map((slot) => ({
@@ -2429,70 +2428,70 @@ function createArkyStore(config) {
           promo_code: state.promoCode || void 0,
           forms
         });
-        booking_state.setKey("cartId", cart.get()?.id || null);
+        service_order_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);
+        service_order_state.setKey("loading", false);
       }
     },
     async fetchQuote(paymentMethodId, promoCode) {
-      const state = booking_state.get();
+      const state = service_order_state.get();
       if (!state.cart.length) return null;
-      booking_state.setKey("fetchingQuote", true);
-      booking_state.setKey("quoteError", null);
+      service_order_state.setKey("fetchingQuote", true);
+      service_order_state.setKey("quoteError", null);
       try {
-        booking_state.setKey("promoCode", promoCode || null);
+        service_order_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);
+        service_order_state.setKey("cartId", cart.get()?.id || null);
+        service_order_state.setKey("quote", response);
         const methods = response?.payment_methods || session.get()?.market?.payment_methods || [];
-        if (methods.length) booking_state.setKey("availablePaymentMethods", methods);
+        if (methods.length) service_order_state.setKey("availablePaymentMethods", methods);
         return response;
       } catch (error) {
-        booking_state.setKey("quoteError", readErrorMessage(error, "Failed to fetch quote."));
+        service_order_state.setKey("quoteError", readErrorMessage(error, "Failed to fetch quote."));
         return null;
       } finally {
-        booking_state.setKey("fetchingQuote", false);
+        service_order_state.setKey("fetchingQuote", false);
       }
     },
     getProvidersList() {
-      return booking_state.get().providers;
+      return service_order_state.get().providers;
     },
     prevStep() {
-      const current = bookingCurrentStepName();
+      const current = serviceOrderCurrentStepName();
       if (current === "review") {
-        booking_state.setKey("dateTimeConfirmed", false);
+        service_order_state.setKey("dateTimeConfirmed", false);
         return;
       }
       if (current === "datetime") {
-        booking_state.setKey("selectedSlot", null);
-        booking_state.setKey("dateTimeConfirmed", false);
+        service_order_state.setKey("selectedSlot", null);
+        service_order_state.setKey("dateTimeConfirmed", false);
       }
     },
     nextStep() {
-      if (bookingCurrentStepName() === "datetime" && booking_can_proceed.get()) {
-        booking_state.setKey("dateTimeConfirmed", true);
+      if (serviceOrderCurrentStepName() === "datetime" && service_order_can_proceed.get()) {
+        service_order_state.setKey("dateTimeConfirmed", true);
       }
     },
     getServicePrice() {
-      const state = booking_state.get();
+      const state = service_order_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,
+    formatDateDisplay: formatServiceOrderDateDisplay,
     serviceItemsFromSlots(slots) {
       return slots.map(toServiceCartItem);
     }
   };
-  service_items.subscribe((items) => setBookingCartFromServiceItems(items));
+  service_items.subscribe((items) => setServiceOrderCartFromServiceItems(items));
   async function loadNode(params, options) {
     cms_state.setKey("loading", true);
     cms_state.setKey("error", null);
@@ -2605,6 +2604,59 @@ function createArkyStore(config) {
     if (options.load_website) results.website_node = await loadWebsiteNode();
     return results;
   }
+  const cart_store = {
+    cart,
+    product_items,
+    service_items,
+    quote,
+    promo_code,
+    last_order,
+    status: cart_status,
+    product_item_count,
+    service_item_count,
+    item_count,
+    snapshot,
+    actions: {
+      ensure: ensureCart,
+      hydrate: hydrateCart,
+      sync: syncCart,
+      addProduct,
+      setProductQuantity,
+      removeProduct,
+      addServiceItem,
+      removeServiceItem,
+      clear: clearCart,
+      quote: fetchQuote,
+      checkout,
+      applyPromoCode(code, input = {}) {
+        promo_code.set(code);
+        return fetchQuote({ ...input, promo_code: code });
+      },
+      removePromoCode(input = {}) {
+        promo_code.set(null);
+        return fetchQuote({ ...input, promo_code: null });
+      },
+      selectShippingMethod(id) {
+        cart_status.setKey("selected_shipping_method_id", id);
+      },
+      locationToAddress,
+      buildItems: checkoutItems,
+      buildProductItems: toProductCheckoutItems,
+      buildServiceItems: toServiceCheckoutItems
+    }
+  };
+  const service_order_store = {
+    state: service_order_state,
+    form_blocks: service_order_form_blocks,
+    current_step_name: service_order_current_step_name,
+    can_proceed: service_order_can_proceed,
+    month_year: service_order_month_year,
+    chain_start: service_order_chain_start,
+    total_steps: service_order_total_steps,
+    steps: service_order_steps,
+    current_step: service_order_current_step,
+    actions: service_order_actions
+  };
   return {
     client,
     session,
@@ -2653,60 +2705,9 @@ function createArkyStore(config) {
         get: (params, options) => client.eshop.provider.get(params, options),
         find: loadProviders
       },
-      order: client.eshop.order
-    },
-    cart: {
-      cart,
-      product_items,
-      service_items,
-      quote,
-      promo_code,
-      last_order,
-      status: cart_status,
-      product_item_count,
-      service_item_count,
-      item_count,
-      snapshot,
-      actions: {
-        ensure: ensureCart,
-        hydrate: hydrateCart,
-        sync: syncCart,
-        addProduct,
-        setProductQuantity,
-        removeProduct,
-        addServiceItem,
-        removeServiceItem,
-        clear: clearCart,
-        quote: fetchQuote,
-        checkout,
-        applyPromoCode(code, input = {}) {
-          promo_code.set(code);
-          return fetchQuote({ ...input, promo_code: code });
-        },
-        removePromoCode(input = {}) {
-          promo_code.set(null);
-          return fetchQuote({ ...input, promo_code: null });
-        },
-        selectShippingMethod(id) {
-          cart_status.setKey("selected_shipping_method_id", id);
-        },
-        locationToAddress,
-        buildItems: checkoutItems,
-        buildProductItems: toProductCheckoutItems,
-        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
+      order: client.eshop.order,
+      cart: cart_store,
+      serviceOrder: service_order_store
     },
     crm: client.crm,
     activity: {