arky-sdk 0.7.133 → 0.8.0

package/dist/storefront-store.cjs

@@ -1606,15 +1606,15 @@ function formSchemaToBlock(field) {
     value: getFormBlockValue(field)
   };
 }
-function formatServiceOrderTime(ts, tz) {
+function formatServiceTime(ts, tz) {
   return new Date(ts * 1e3).toLocaleTimeString([], {
     hour: "2-digit",
     minute: "2-digit",
     timeZone: tz
   });
 }
-function formatServiceOrderSlotTime(from, to, tz) {
-  return `${formatServiceOrderTime(from, tz)} - ${formatServiceOrderTime(to, tz)}`;
+function formatServiceSlotTime(from, to, tz) {
+  return `${formatServiceTime(from, tz)} - ${formatServiceTime(to, tz)}`;
 }
 function getSlotsForDate(availability, dateStr, providerId) {
   if (!availability) return [];
@@ -1637,8 +1637,8 @@ function hasAvailableSlotsForDate(availability, dateStr, providerId) {
     return !!day?.slots.some((slot) => slot.spots > 0);
   });
 }
-var SERVICE_ORDER_WEEKDAYS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
-function createServiceOrderInitialState() {
+var SERVICE_WEEKDAYS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+function createServiceInitialState() {
   return {
     service: null,
     availability: null,
@@ -1655,7 +1655,7 @@ function createServiceOrderInitialState() {
     timezone: typeof window !== "undefined" ? Intl.DateTimeFormat().resolvedOptions().timeZone : "UTC",
     tzGroups: {},
     loading: false,
-    weekdays: SERVICE_ORDER_WEEKDAYS,
+    weekdays: SERVICE_WEEKDAYS,
     quote: null,
     fetchingQuote: false,
     quoteError: null,
@@ -1722,7 +1722,6 @@ function createArkyStore(config) {
     item_count: count
   }));
   const cms_state = nanostores.map({
-    website_node: null,
     nodes: {},
     forms: {},
     loading: false,
@@ -1742,16 +1741,15 @@ function createArkyStore(config) {
     loading_availability: false,
     error: null
   });
-  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 || []);
+  const service_state = nanostores.map(createServiceInitialState());
+  const service_form_node = nanostores.atom(null);
+  const service_form_blocks = nanostores.computed(service_form_node, (node) => node?.blocks || []);
   client.onAuthStateChanged((value) => session.set(value));
-  snapshot.subscribe((value) => config.onCartChange?.(value));
-  currency.subscribe((value) => service_order_state.setKey("currency", value));
+  currency.subscribe((value) => service_state.setKey("currency", value));
   session.subscribe((value) => {
     const methods = value?.market?.payment_methods || [];
-    if (methods.length && service_order_state.get().availablePaymentMethods.length === 0) {
-      service_order_state.setKey("availablePaymentMethods", methods);
+    if (methods.length && service_state.get().availablePaymentMethods.length === 0) {
+      service_state.setKey("availablePaymentMethods", methods);
     }
   });
   function currentMarketKey() {
@@ -1763,6 +1761,15 @@ function createArkyStore(config) {
   function currentCurrency() {
     return currency.get() || market.get()?.currency || null;
   }
+  function marketForLocale(value) {
+    return config.marketForLocale?.(value) || null;
+  }
+  async function ensureSession() {
+    const current = session.get();
+    const marketKey = currentMarketKey();
+    if (current && (!marketKey || current.market?.key === marketKey)) return current;
+    return identify({ market: marketKey });
+  }
   async function identify(params = {}) {
     if (params.market) setMarket(params.market);
     const result = await client.identify({ ...params, market: params.market || currentMarketKey() });
@@ -1773,15 +1780,24 @@ function createArkyStore(config) {
     market_key.set(key);
     client.setMarket(key);
   }
-  function setLocale(value) {
+  function setLocale(value, options = {}) {
     locale.set(value);
     client.setLocale(value);
+    const nextMarket = options.market || marketForLocale(value);
+    if (nextMarket) setMarket(nextMarket);
+  }
+  function setContext(context) {
+    if (context.locale) {
+      setLocale(context.locale, { market: context.market });
+      return;
+    }
+    if (context.market) setMarket(context.market);
   }
   async function ensureCart() {
     cart_status.setKey("loading", true);
     cart_status.setKey("error", null);
     try {
-      await identify({ market: currentMarketKey() });
+      await ensureSession();
       const response = await client.cart.refresh({ market: currentMarketKey() });
       await hydrateCart(response);
       return response;
@@ -2023,8 +2039,8 @@ function createArkyStore(config) {
       cart_status.setKey("processing_checkout", false);
     }
   }
-  function serviceOrderCalendar() {
-    const state = service_order_state.get();
+  function serviceCalendar() {
+    const state = service_state.get();
     const { currentMonth, selectedDate, startDate, endDate, availability, selectedProviderId } = state;
     const year = currentMonth.getFullYear();
     const monthIndex = currentMonth.getMonth();
@@ -2078,8 +2094,8 @@ function createArkyStore(config) {
     }
     return cells;
   }
-  function computeServiceOrderSlots(dateStr) {
-    const state = service_order_state.get();
+  function computeServiceSlots(dateStr) {
+    const state = service_state.get();
     const { availability, selectedProviderId, timezone, service } = state;
     return getSlotsForDate(availability, dateStr, selectedProviderId).map((slot, index) => ({
       id: `${service?.id || "service"}-${slot.from}-${index}`,
@@ -2087,7 +2103,7 @@ function createArkyStore(config) {
       providerId: slot.providerId,
       from: slot.from,
       to: slot.to,
-      timeText: formatServiceOrderSlotTime(slot.from, slot.to, timezone),
+      timeText: formatServiceSlotTime(slot.from, slot.to, timezone),
       dateText: new Date(slot.from * 1e3).toLocaleDateString([], {
         weekday: "short",
         month: "short",
@@ -2120,63 +2136,63 @@ function createArkyStore(config) {
       serviceName: item.service_name || "",
       date: item.date_text || "",
       dateText: item.date_text || "",
-      timeText: item.time_text || formatServiceOrderSlotTime(item.from, item.to, service_order_state.get().timezone),
+      timeText: item.time_text || formatServiceSlotTime(item.from, item.to, service_state.get().timezone),
       isMultiDay: item.is_multi_day
     };
   }
-  function setServiceOrderCartFromServiceItems(items) {
+  function setServiceCartFromServiceItems(items) {
     const next = items.map(fromServiceCartItem);
-    const current = service_order_state.get().cart;
+    const current = service_state.get().cart;
     if (JSON.stringify(current) !== JSON.stringify(next)) {
-      service_order_state.setKey("cart", next);
+      service_state.setKey("cart", next);
     }
   }
-  async function syncServiceOrderCart(slots) {
+  async function syncServiceCart(slots) {
     try {
       return await syncCart({
         product_items: product_items.get(),
         service_items: slots.map(toServiceCartItem)
       });
     } catch (error) {
-      service_order_state.setKey("quoteError", readErrorMessage(error, "Failed to sync service order cart."));
+      service_state.setKey("quoteError", readErrorMessage(error, "Failed to sync service cart."));
       throw error;
     }
   }
-  function serviceOrderCurrentStepName() {
-    const state = service_order_state.get();
+  function serviceCurrentStepName() {
+    const state = service_state.get();
     if (!state.service) return "";
     if (!state.selectedSlot || !state.dateTimeConfirmed) return "datetime";
     return "review";
   }
-  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();
+  const service_current_step_name = nanostores.computed(service_state, serviceCurrentStepName);
+  const service_can_proceed = nanostores.computed(service_state, (state) => {
+    const step = serviceCurrentStepName();
     if (step === "datetime") {
       return state.isMultiDay ? !!(state.startDate && state.endDate && state.selectedSlot) : !!(state.selectedDate && state.selectedSlot);
     }
     if (step === "review") return true;
     return false;
   });
-  const service_order_month_year = nanostores.computed(
-    service_order_state,
+  const service_month_year = nanostores.computed(
+    service_state,
     (state) => state.currentMonth.toLocaleString(void 0, { month: "long", year: "numeric" })
   );
-  const service_order_chain_start = nanostores.computed(service_order_state, (state) => {
+  const service_chain_start = nanostores.computed(service_state, (state) => {
     if (!state.cart.length) return null;
     return Math.max(...state.cart.map((slot) => slot.to));
   });
-  const service_order_total_steps = nanostores.computed(service_order_state, (state) => state.service ? 2 : 0);
-  const service_order_steps = nanostores.computed(service_order_state, () => ({
+  const service_total_steps = nanostores.computed(service_state, (state) => state.service ? 2 : 0);
+  const service_steps = nanostores.computed(service_state, () => ({
     1: { name: "datetime" },
     2: { name: "review" }
   }));
-  const service_order_current_step = nanostores.computed([service_order_current_step_name, service_order_steps], (name, steps) => {
+  const service_current_step = nanostores.computed([service_current_step_name, service_steps], (name, steps) => {
     for (const [idx, step] of Object.entries(steps)) {
       if (step.name === name) return Number(idx);
     }
     return 1;
   });
-  function formatServiceOrderDateDisplay(value) {
+  function formatServiceDateDisplay(value) {
     if (!value) return "";
     return new Date(value).toLocaleDateString(void 0, { month: "short", day: "numeric" });
   }
@@ -2193,37 +2209,37 @@ function createArkyStore(config) {
     }
     return providers[0];
   }
-  async function loadServiceOrderForm() {
+  async function loadServiceForm() {
     try {
       const form = await loadForm({ key: "order-form" });
       const blocks = (form.schema || []).map(formSchemaToBlock);
-      service_order_form_node.set({ blocks });
+      service_form_node.set({ blocks });
       return blocks;
     } catch {
-      service_order_form_node.set({ blocks: [] });
+      service_form_node.set({ blocks: [] });
       return [];
     }
   }
-  const service_order_actions = {
+  const service_controller = {
     async initialize() {
-      service_order_state.setKey("tzGroups", normalizeTimezoneGroups(client.utils.tzGroups));
+      service_state.setKey("tzGroups", normalizeTimezoneGroups(client.utils.tzGroups));
       await ensureCart();
-      setServiceOrderCartFromServiceItems(service_items.get());
+      setServiceCartFromServiceItems(service_items.get());
       const methods = session.get()?.market?.payment_methods || [];
-      if (methods.length) service_order_state.setKey("availablePaymentMethods", methods);
-      await loadServiceOrderForm();
+      if (methods.length) service_state.setKey("availablePaymentMethods", methods);
+      await loadServiceForm();
     },
     setTimezone(tz) {
-      service_order_state.setKey("timezone", tz);
-      service_order_state.setKey("calendar", serviceOrderCalendar());
-      const state = service_order_state.get();
+      service_state.setKey("timezone", tz);
+      service_state.setKey("calendar", serviceCalendar());
+      const state = service_state.get();
       if (state.selectedDate) {
-        service_order_state.setKey("slots", computeServiceOrderSlots(state.selectedDate));
-        service_order_state.setKey("selectedSlot", null);
+        service_state.setKey("slots", computeServiceSlots(state.selectedDate));
+        service_state.setKey("selectedSlot", null);
       }
     },
-    async setService(service) {
-      service_order_state.setKey("loading", true);
+    async select(service) {
+      service_state.setKey("loading", true);
       try {
         const isMultiDayBlock = service.blocks?.find((block) => block.key === "isMultiDay");
         const blockValue = isMultiDayBlock?.value;
@@ -2236,8 +2252,8 @@ function createArkyStore(config) {
         const providerResults = await Promise.all(
           providerIds.map((id) => client.eshop.provider.get({ id }).catch(() => null))
         );
-        service_order_state.set({
-          ...service_order_state.get(),
+        service_state.set({
+          ...service_state.get(),
           service: fullService,
           providers: providerResults.filter((provider) => provider !== null),
           selectedProviderId: null,
@@ -2251,18 +2267,18 @@ function createArkyStore(config) {
           loading: false,
           isMultiDay
         });
-        await service_order_actions.loadMonth();
+        await service_controller.loadMonth();
       } catch (error) {
-        service_order_state.setKey("loading", false);
+        service_state.setKey("loading", false);
         throw error;
       }
     },
     async loadMonth() {
-      const state = service_order_state.get();
+      const state = service_state.get();
       if (!state.service) return;
-      service_order_state.setKey("loading", true);
+      service_state.setKey("loading", true);
       try {
-        const chainedStart = service_order_chain_start.get();
+        const chainedStart = service_chain_start.get();
         let from;
         let to;
         if (chainedStart) {
@@ -2278,25 +2294,25 @@ function createArkyStore(config) {
           from,
           to
         });
-        service_order_state.setKey("availability", availability);
-        service_order_state.setKey("calendar", serviceOrderCalendar());
+        service_state.setKey("availability", availability);
+        service_state.setKey("calendar", serviceCalendar());
       } finally {
-        service_order_state.setKey("loading", false);
+        service_state.setKey("loading", false);
       }
     },
     prevMonth() {
-      const { currentMonth } = service_order_state.get();
-      service_order_state.setKey("currentMonth", new Date(currentMonth.getFullYear(), currentMonth.getMonth() - 1, 1));
-      void service_order_actions.loadMonth();
+      const { currentMonth } = service_state.get();
+      service_state.setKey("currentMonth", new Date(currentMonth.getFullYear(), currentMonth.getMonth() - 1, 1));
+      void service_controller.loadMonth();
     },
     nextMonth() {
-      const { currentMonth } = service_order_state.get();
-      service_order_state.setKey("currentMonth", new Date(currentMonth.getFullYear(), currentMonth.getMonth() + 1, 1));
-      void service_order_actions.loadMonth();
+      const { currentMonth } = service_state.get();
+      service_state.setKey("currentMonth", new Date(currentMonth.getFullYear(), currentMonth.getMonth() + 1, 1));
+      void service_controller.loadMonth();
     },
     selectProvider(providerId) {
-      service_order_state.set({
-        ...service_order_state.get(),
+      service_state.set({
+        ...service_state.get(),
         selectedProviderId: providerId,
         selectedDate: null,
         startDate: null,
@@ -2304,45 +2320,45 @@ function createArkyStore(config) {
         slots: [],
         selectedSlot: null
       });
-      void service_order_actions.loadMonth();
+      void service_controller.loadMonth();
     },
     selectDate(cell) {
       if (cell.blank || !cell.available) return;
-      service_order_state.setKey("dateTimeConfirmed", false);
-      const state = service_order_state.get();
+      service_state.setKey("dateTimeConfirmed", false);
+      const state = service_state.get();
       if (state.isMultiDay) {
         if (!state.startDate) {
-          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);
+          service_state.setKey("startDate", cell.iso);
+          service_state.setKey("selectedDate", cell.iso);
+          service_state.setKey("endDate", null);
+          service_state.setKey("selectedSlot", null);
         } else if (!state.endDate) {
           if (cell.date.getTime() < new Date(state.startDate).getTime()) {
-            service_order_state.setKey("startDate", cell.iso);
-            service_order_state.setKey("endDate", state.startDate);
+            service_state.setKey("startDate", cell.iso);
+            service_state.setKey("endDate", state.startDate);
           } else {
-            service_order_state.setKey("endDate", cell.iso);
+            service_state.setKey("endDate", cell.iso);
           }
-          service_order_actions.createMultiDaySlots();
+          service_controller.createMultiDaySlots();
         } else {
-          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);
+          service_state.setKey("startDate", cell.iso);
+          service_state.setKey("selectedDate", cell.iso);
+          service_state.setKey("endDate", null);
+          service_state.setKey("selectedSlot", null);
         }
-        service_order_actions.updateCalendar();
+        service_controller.updateCalendar();
       } else {
-        service_order_state.set({
+        service_state.set({
           ...state,
           selectedDate: cell.iso,
-          slots: computeServiceOrderSlots(cell.iso),
+          slots: computeServiceSlots(cell.iso),
           selectedSlot: null
         });
-        service_order_state.setKey("calendar", serviceOrderCalendar());
+        service_state.setKey("calendar", serviceCalendar());
       }
     },
     createMultiDaySlots() {
-      const state = service_order_state.get();
+      const state = service_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)) {
@@ -2354,7 +2370,7 @@ function createArkyStore(config) {
             providerId: slot.providerId,
             from: slot.from,
             to: slot.to,
-            timeText: formatServiceOrderSlotTime(slot.from, slot.to, state.timezone),
+            timeText: formatServiceSlotTime(slot.from, slot.to, state.timezone),
             dateText: new Date(slot.from * 1e3).toLocaleDateString([], {
               weekday: "short",
               month: "short",
@@ -2365,34 +2381,34 @@ function createArkyStore(config) {
           });
         }
       }
-      service_order_state.setKey("slots", slots);
-      service_order_state.setKey("selectedSlot", slots.length === 1 ? slots[0] : null);
+      service_state.setKey("slots", slots);
+      service_state.setKey("selectedSlot", slots.length === 1 ? slots[0] : null);
     },
     selectTimeSlot(slot) {
-      service_order_state.setKey("dateTimeConfirmed", false);
-      service_order_state.setKey("selectedSlot", slot);
+      service_state.setKey("dateTimeConfirmed", false);
+      service_state.setKey("selectedSlot", slot);
     },
     resetDateSelection() {
-      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);
+      service_state.setKey("selectedDate", null);
+      service_state.setKey("startDate", null);
+      service_state.setKey("endDate", null);
+      service_state.setKey("slots", []);
+      service_state.setKey("selectedSlot", null);
+      service_state.setKey("dateTimeConfirmed", false);
     },
     updateCalendar() {
-      service_order_state.setKey("calendar", serviceOrderCalendar());
+      service_state.setKey("calendar", serviceCalendar());
     },
     findFirstAvailable() {
-      for (const day of service_order_state.get().calendar) {
+      for (const day of service_state.get().calendar) {
         if (!day.blank && day.available) {
-          service_order_actions.selectDate(day);
+          service_controller.selectDate(day);
           return;
         }
       }
     },
     async addToCart() {
-      const state = service_order_state.get();
+      const state = service_state.get();
       const serviceBlocks = state.service?.forms || [];
       const enrich = (slot) => ({
         ...slot,
@@ -2403,7 +2419,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];
-      service_order_state.set({
+      service_state.set({
         ...state,
         cart: nextCart,
         selectedDate: null,
@@ -2412,22 +2428,22 @@ function createArkyStore(config) {
         slots: [],
         selectedSlot: null
       });
-      await syncServiceOrderCart(nextCart);
-      service_order_state.setKey("calendar", serviceOrderCalendar());
+      await syncServiceCart(nextCart);
+      service_state.setKey("calendar", serviceCalendar());
     },
     async removeFromCart(slotId) {
-      const nextCart = service_order_state.get().cart.filter((slot) => slot.id !== slotId);
-      service_order_state.setKey("cart", nextCart);
-      await syncServiceOrderCart(nextCart);
+      const nextCart = service_state.get().cart.filter((slot) => slot.id !== slotId);
+      service_state.setKey("cart", nextCart);
+      await syncServiceCart(nextCart);
     },
     async clearCart() {
-      service_order_state.setKey("cart", []);
-      await syncServiceOrderCart([]);
+      service_state.setKey("cart", []);
+      await syncServiceCart([]);
     },
     async checkout(paymentMethodId, forms = []) {
-      const state = service_order_state.get();
+      const state = service_state.get();
       if (!state.cart.length) return { success: false, error: "Cart is empty" };
-      service_order_state.setKey("loading", true);
+      service_state.setKey("loading", true);
       try {
         const result = await checkout({
           service_items: state.cart.map((slot) => ({
@@ -2438,76 +2454,78 @@ function createArkyStore(config) {
           promo_code: state.promoCode || void 0,
           forms
         });
-        service_order_state.setKey("cartId", cart.get()?.id || null);
+        service_state.setKey("cartId", cart.get()?.id || null);
         return { success: true, data: result };
       } catch (error) {
         return { success: false, error: readErrorMessage(error, "Checkout failed.") };
       } finally {
-        service_order_state.setKey("loading", false);
+        service_state.setKey("loading", false);
       }
     },
     async fetchQuote(paymentMethodId, promoCode) {
-      const state = service_order_state.get();
+      const state = service_state.get();
       if (!state.cart.length) return null;
-      service_order_state.setKey("fetchingQuote", true);
-      service_order_state.setKey("quoteError", null);
+      service_state.setKey("fetchingQuote", true);
+      service_state.setKey("quoteError", null);
       try {
-        service_order_state.setKey("promoCode", promoCode || null);
+        service_state.setKey("promoCode", promoCode || null);
         const response = await fetchQuote({
           service_items: state.cart.map(toServiceCartItem),
           payment_method_id: paymentMethodId,
           promo_code: promoCode || void 0
         });
-        service_order_state.setKey("cartId", cart.get()?.id || null);
-        service_order_state.setKey("quote", response);
+        service_state.setKey("cartId", cart.get()?.id || null);
+        service_state.setKey("quote", response);
         const methods = response?.payment_methods || session.get()?.market?.payment_methods || [];
-        if (methods.length) service_order_state.setKey("availablePaymentMethods", methods);
+        if (methods.length) service_state.setKey("availablePaymentMethods", methods);
         return response;
       } catch (error) {
-        service_order_state.setKey("quoteError", readErrorMessage(error, "Failed to fetch quote."));
+        service_state.setKey("quoteError", readErrorMessage(error, "Failed to fetch quote."));
         return null;
       } finally {
-        service_order_state.setKey("fetchingQuote", false);
+        service_state.setKey("fetchingQuote", false);
       }
     },
     getProvidersList() {
-      return service_order_state.get().providers;
+      return service_state.get().providers;
     },
     prevStep() {
-      const current = serviceOrderCurrentStepName();
+      const current = serviceCurrentStepName();
       if (current === "review") {
-        service_order_state.setKey("dateTimeConfirmed", false);
+        service_state.setKey("dateTimeConfirmed", false);
         return;
       }
       if (current === "datetime") {
-        service_order_state.setKey("selectedSlot", null);
-        service_order_state.setKey("dateTimeConfirmed", false);
+        service_state.setKey("selectedSlot", null);
+        service_state.setKey("dateTimeConfirmed", false);
       }
     },
     nextStep() {
-      if (serviceOrderCurrentStepName() === "datetime" && service_order_can_proceed.get()) {
-        service_order_state.setKey("dateTimeConfirmed", true);
+      if (serviceCurrentStepName() === "datetime" && service_can_proceed.get()) {
+        service_state.setKey("dateTimeConfirmed", true);
       }
     },
     getServicePrice() {
-      const state = service_order_state.get();
+      const state = service_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: formatServiceOrderDateDisplay,
+    formatDateDisplay: formatServiceDateDisplay,
     serviceItemsFromSlots(slots) {
       return slots.map(toServiceCartItem);
     }
   };
-  service_items.subscribe((items) => setServiceOrderCartFromServiceItems(items));
+  service_items.subscribe((items) => setServiceCartFromServiceItems(items));
   async function loadNode(params, options) {
     cms_state.setKey("loading", true);
     cms_state.setKey("error", null);
     try {
-      const node = await client.cms.node.get(params, options);
-      const key = params.key || params.id || params.slug || node.id;
+      const { locale: nextLocale, market: nextMarket, ...nodeParams } = params;
+      setContext({ locale: nextLocale, market: nextMarket });
+      const node = await client.cms.node.get(nodeParams, options);
+      const key = nodeParams.key || nodeParams.id || nodeParams.slug || node.id;
       cms_state.setKey("nodes", { ...cms_state.get().nodes, [key]: node });
       return node;
     } catch (error) {
@@ -2517,11 +2535,6 @@ function createArkyStore(config) {
       cms_state.setKey("loading", false);
     }
   }
-  async function loadWebsiteNode(options) {
-    const node = await loadNode({ key: "website" }, options);
-    cms_state.setKey("website_node", node);
-    return node;
-  }
   async function loadForm(params, options) {
     cms_state.setKey("loading", true);
     cms_state.setKey("error", null);
@@ -2603,22 +2616,25 @@ function createArkyStore(config) {
       eshop_state.setKey("loading_availability", false);
     }
   }
-  async function initialize(options = {}) {
-    if (options.locale) setLocale(options.locale);
-    if (options.market) setMarket(options.market);
-    await identify({ market: currentMarketKey() });
+  async function setup(options = {}) {
+    setContext(options);
+    const shouldIdentify = options.identify === true || !!options.hydrateCart || !!options.track;
     const results = {
       session: session.get()
     };
-    if (options.hydrate_cart) results.cart = await ensureCart();
-    if (options.load_website) results.website_node = await loadWebsiteNode();
+    if (shouldIdentify) results.session = await ensureSession();
+    if (options.hydrateCart) results.cart = await ensureCart();
+    if (options.track) await client.activity.track(options.track);
     return results;
   }
+  async function initialize(options = {}) {
+    return setup(options);
+  }
   const cart_store = {
     cart,
     product_items,
     service_items,
-    quote,
+    quote_result: quote,
     promo_code,
     last_order,
     status: cart_status,
@@ -2626,46 +2642,80 @@ function createArkyStore(config) {
     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
-    }
+    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 product_store = {
+    get: (params, options) => client.eshop.product.get(params, options),
+    find: loadProducts,
+    list: loadProducts,
+    loadListing: loadProducts,
+    loadDetail: (params, options) => client.eshop.product.get(params, options)
   };
-  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
+  const service_store = {
+    get: (params, options) => client.eshop.service.get(params, options),
+    find: loadServices,
+    list: loadServices,
+    loadListing: loadServices,
+    loadDetail: (params, options) => client.eshop.service.get(params, options),
+    listProviders: (params, options) => client.eshop.service.findProviders(params, options),
+    findProviders: (params, options) => client.eshop.service.findProviders(params, options),
+    getAvailability: loadAvailability,
+    state: service_state,
+    form_blocks: service_form_blocks,
+    current_step_name: service_current_step_name,
+    can_proceed: service_can_proceed,
+    month_year: service_month_year,
+    chain_start: service_chain_start,
+    total_steps: service_total_steps,
+    steps: service_steps,
+    current_step: service_current_step,
+    initialize: service_controller.initialize,
+    select: service_controller.select,
+    setTimezone: service_controller.setTimezone,
+    loadMonth: service_controller.loadMonth,
+    prevMonth: service_controller.prevMonth,
+    nextMonth: service_controller.nextMonth,
+    selectProvider: service_controller.selectProvider,
+    selectDate: service_controller.selectDate,
+    createMultiDaySlots: service_controller.createMultiDaySlots,
+    selectTimeSlot: service_controller.selectTimeSlot,
+    resetDateSelection: service_controller.resetDateSelection,
+    updateCalendar: service_controller.updateCalendar,
+    findFirstAvailable: service_controller.findFirstAvailable,
+    addToCart: service_controller.addToCart,
+    removeFromCart: service_controller.removeFromCart,
+    clearCart: service_controller.clearCart,
+    getProvidersList: service_controller.getProvidersList,
+    prevStep: service_controller.prevStep,
+    nextStep: service_controller.nextStep,
+    getServicePrice: service_controller.getServicePrice,
+    formatDateDisplay: service_controller.formatDateDisplay,
+    serviceItemsFromSlots: service_controller.serviceItemsFromSlots
   };
   return {
     client,
@@ -2676,6 +2726,7 @@ function createArkyStore(config) {
     currency,
     allowed_payment_methods,
     payment_config,
+    setup,
     initialize,
     identify,
     verify: client.verify,
@@ -2690,6 +2741,7 @@ function createArkyStore(config) {
     },
     setMarket,
     setLocale,
+    setContext,
     getMarket: currentMarketKey,
     getLocale: currentLocale,
     cms: {
@@ -2697,8 +2749,7 @@ function createArkyStore(config) {
       node: {
         get: loadNode,
         find: (params, options) => client.cms.node.find(params, options),
-        getChildren: (params, options) => client.cms.node.getChildren(params, options),
-        loadWebsite: loadWebsiteNode
+        getChildren: (params, options) => client.cms.node.getChildren(params, options)
       },
       form: {
         get: loadForm,
@@ -2709,29 +2760,23 @@ function createArkyStore(config) {
     },
     eshop: {
       state: eshop_state,
-      product: {
-        get: (params, options) => client.eshop.product.get(params, options),
-        find: loadProducts
-      },
-      service: {
-        get: (params, options) => client.eshop.service.get(params, options),
-        find: loadServices,
-        findProviders: (params, options) => client.eshop.service.findProviders(params, options),
-        getAvailability: loadAvailability
-      },
+      product: product_store,
+      service: service_store,
       provider: {
         get: (params, options) => client.eshop.provider.get(params, options),
         find: loadProviders
       },
       order: client.eshop.order,
-      cart: cart_store,
-      serviceOrder: service_order_store
+      cart: cart_store
     },
     crm: client.crm,
     activity: {
       track(params) {
         return client.activity.track(params);
       },
+      pageView(payload = {}) {
+        return client.activity.track({ type: "page_view", payload });
+      },
       state: nanostores.atom(null)
     },
     store: client.store,