arky-sdk 0.7.93 → 0.7.95

package/dist/storefront.js

@@ -0,0 +1,1356 @@
+// src/utils/blocks.ts
+function getBlockLabel(block) {
+  if (!block) return "";
+  return block.key?.replace(/_/g, " ").replace(/\b\w/g, (l) => l.toUpperCase()) ?? "";
+}
+function formatBlockValue(block) {
+  if (!block || block.value === null || block.value === void 0) return "";
+  const value = block.value;
+  switch (block.type) {
+    case "boolean":
+      return value ? "Yes" : "No";
+    case "number":
+      if (block.properties?.variant === "DATE" || block.properties?.variant === "DATE_TIME") {
+        return new Date(value).toLocaleDateString();
+      }
+      return String(value);
+    case "relationship_entry":
+    case "relationship_media":
+      if (value && typeof value === "object") {
+        return value.mime_type ? value.name || value.id : value.title || value.name || value.id;
+      }
+      return String(value);
+    default:
+      return String(value);
+  }
+}
+function prepareBlocksForSubmission(formData, blockTypes) {
+  return Object.keys(formData).filter((key) => formData[key] !== null && formData[key] !== void 0).map((key) => ({
+    key,
+    value: blockTypes?.[key] === "list" && !Array.isArray(formData[key]) ? [formData[key]] : formData[key]
+  }));
+}
+function extractBlockValues(blocks) {
+  const values = {};
+  blocks.forEach((block) => {
+    values[block.key] = block.value ?? null;
+  });
+  return values;
+}
+var getBlockValue = (entry, blockKey) => {
+  const block = entry?.blocks?.find((f) => f.key === blockKey);
+  return block?.value ?? null;
+};
+var getBlockTextValue = (block, locale = "en") => {
+  if (!block || block.value === null || block.value === void 0) return "";
+  if (block.type === "localized_text" || block.type === "markdown") {
+    if (typeof block.value === "object" && block.value !== null) {
+      return block.value[locale] ?? block.value["en"] ?? "";
+    }
+  }
+  if (typeof block.value === "string") return block.value;
+  return String(block.value ?? "");
+};
+var getBlockValues = (entry, blockKey) => {
+  const block = entry?.blocks?.find((f) => f.key === blockKey);
+  if (!block) return [];
+  if (block.type === "list" && Array.isArray(block.value)) {
+    return block.value;
+  }
+  return [];
+};
+function unwrapBlock(block, locale) {
+  if (!block?.type || block.value === void 0) return block;
+  if (block.type === "list") {
+    return block.value.map((obj) => {
+      const parsed = {};
+      for (const [k, v] of Object.entries(obj)) {
+        parsed[k] = unwrapBlock(v, locale);
+      }
+      return parsed;
+    });
+  }
+  if (block.type === "map") {
+    const parsed = {};
+    for (const [k, v] of Object.entries(block.value || {})) {
+      parsed[k] = unwrapBlock(v, locale);
+    }
+    return parsed;
+  }
+  if (block.type === "localized_text" || block.type === "markdown") {
+    return block.value?.[locale];
+  }
+  return block.value;
+}
+var getBlockObjectValues = (entry, blockKey, locale = "en") => {
+  const block = entry?.blocks?.find((f) => f.key === blockKey);
+  if (!block || block.type !== "list" || !Array.isArray(block.value)) return [];
+  return block.value.map((obj) => {
+    if (!obj?.value || !Array.isArray(obj.value)) return {};
+    return obj.value.reduce((acc, current) => {
+      acc[current.key] = unwrapBlock(current, locale);
+      return acc;
+    }, {});
+  });
+};
+var getBlockFromArray = (entry, blockKey, locale = "en") => {
+  const block = entry?.blocks?.find((f) => f.key === blockKey);
+  if (!block) return {};
+  if (block.type === "list" && Array.isArray(block.value)) {
+    return block.value.reduce((acc, current) => {
+      acc[current.key] = unwrapBlock(current, locale);
+      return acc;
+    }, {});
+  }
+  if (block.type === "map" && block.value && typeof block.value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(block.value)) {
+      result[k] = unwrapBlock(v, locale);
+    }
+    return result;
+  }
+  return { [block.key]: unwrapBlock(block, locale) };
+};
+var getImageUrl = (imageBlock, isBlock = true) => {
+  if (!imageBlock) return null;
+  if (imageBlock.type === "relationship_media") {
+    const mediaValue = imageBlock.value;
+    return mediaValue?.resolutions?.original?.url || mediaValue?.url || null;
+  }
+  if (isBlock) {
+    if (typeof imageBlock === "string") return imageBlock;
+    if (imageBlock.url) return imageBlock.url;
+  }
+  return imageBlock.resolutions?.original?.url || null;
+};
+
+// src/api/storefront.ts
+var COMMON_ACTIVITY_TYPES = [
+  "page_view",
+  "product_view",
+  "service_view",
+  "provider_view",
+  "cart_added",
+  "cart_removed",
+  "checkout_started",
+  "purchase",
+  "booking_created",
+  "signin",
+  "signup",
+  "verified_email",
+  "search",
+  "share",
+  "wishlist_added"
+];
+var createActivityApi = (apiConfig) => ({
+  COMMON_ACTIVITY_TYPES,
+  async track(params) {
+    try {
+      await apiConfig.httpClient.post(
+        `/v1/storefront/${apiConfig.storeId}/activities/track`,
+        { type: params.type, payload: params.payload }
+      );
+    } catch {
+    }
+  }
+});
+function groupCartToItems(cart) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const slot of cart) {
+    const key = `${slot.service_id}:${slot.provider_id}`;
+    if (!groups.has(key)) {
+      groups.set(key, {
+        service_id: slot.service_id,
+        provider_id: slot.provider_id,
+        slots: []
+      });
+    }
+    groups.get(key).slots.push({ from: slot.from, to: slot.to });
+  }
+  return [...groups.values()];
+}
+var createStorefrontApi = (apiConfig) => {
+  const base = (storeId = apiConfig.storeId) => `/v1/storefront/${storeId}`;
+  let cart = [];
+  return {
+    store: {
+      getStore(options) {
+        return apiConfig.httpClient.get(base(), options);
+      },
+      location: {
+        getCountries(options) {
+          return apiConfig.httpClient.get(`/v1/platform/countries`, options);
+        },
+        getCountry(countryCode, options) {
+          return apiConfig.httpClient.get(
+            `/v1/platform/countries/${countryCode}`,
+            options
+          );
+        },
+        list(options) {
+          return apiConfig.httpClient.get(`${base()}/locations`, options);
+        },
+        get(id, options) {
+          return apiConfig.httpClient.get(`${base()}/locations/${id}`, options);
+        }
+      },
+      market: {
+        list(options) {
+          return apiConfig.httpClient.get(`${base()}/markets`, options);
+        },
+        get(id, options) {
+          return apiConfig.httpClient.get(`${base()}/markets/${id}`, options);
+        }
+      }
+    },
+    cms: {
+      node: {
+        async get(params, options) {
+          const store_id = params.store_id || apiConfig.storeId;
+          let identifier;
+          if (params.id) {
+            identifier = params.id;
+          } else if (params.slug) {
+            identifier = `${store_id}:${apiConfig.locale}:${params.slug}`;
+          } else if (params.key) {
+            identifier = `${store_id}:${params.key}`;
+          } else {
+            throw new Error("GetNodeParams requires id, slug, or key");
+          }
+          const response = await apiConfig.httpClient.get(
+            `${base(store_id)}/nodes/${identifier}`,
+            options
+          );
+          return {
+            ...response,
+            getBlock(key) {
+              return getBlockFromArray(response, key, apiConfig.locale);
+            },
+            getBlockValues(key) {
+              return getBlockObjectValues(response, key, apiConfig.locale);
+            },
+            getImage(key) {
+              const block = getBlockFromArray(response, key, apiConfig.locale);
+              return getImageUrl(block, true);
+            }
+          };
+        },
+        find(params, options) {
+          const { store_id, ...queryParams } = params;
+          return apiConfig.httpClient.get(`${base(store_id)}/nodes`, {
+            ...options,
+            params: queryParams
+          });
+        },
+        getChildren(params, options) {
+          const { id, store_id, ...queryParams } = params;
+          return apiConfig.httpClient.get(`${base(store_id)}/nodes/${id}/children`, {
+            ...options,
+            params: queryParams
+          });
+        }
+      },
+      form: {
+        get(params, options) {
+          const store_id = params.store_id || apiConfig.storeId;
+          let identifier;
+          if (params.id) {
+            identifier = params.id;
+          } else if (params.key) {
+            identifier = `${store_id}:${params.key}`;
+          } else {
+            throw new Error("GetFormParams requires id or key");
+          }
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/forms/${identifier}`,
+            options
+          );
+        },
+        submit(params, options) {
+          const { store_id, form_id, ...payload } = params;
+          const target_store_id = store_id || apiConfig.storeId;
+          if (!form_id) {
+            throw new Error("SubmitFormParams requires form_id");
+          }
+          return apiConfig.httpClient.post(
+            `${base(target_store_id)}/forms/${form_id}/submissions`,
+            { ...payload, form_id, store_id: target_store_id },
+            options
+          );
+        }
+      },
+      taxonomy: {
+        get(params, options) {
+          const store_id = params.store_id || apiConfig.storeId;
+          let identifier;
+          if (params.id) {
+            identifier = params.id;
+          } else if (params.key) {
+            identifier = `${store_id}:${params.key}`;
+          } else {
+            throw new Error("GetTaxonomyParams requires id or key");
+          }
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/taxonomies/${identifier}`,
+            options
+          );
+        },
+        getChildren(params, options) {
+          const store_id = params.store_id || apiConfig.storeId;
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/taxonomies/${params.id}/children`,
+            options
+          );
+        }
+      }
+    },
+    eshop: {
+      product: {
+        get(params, options) {
+          const store_id = params.store_id || apiConfig.storeId;
+          let identifier;
+          if (params.id) {
+            identifier = params.id;
+          } else if (params.slug) {
+            identifier = `${store_id}:${apiConfig.locale}:${params.slug}`;
+          } else {
+            throw new Error("GetProductParams requires id or slug");
+          }
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/products/${identifier}`,
+            options
+          );
+        },
+        find(params, options) {
+          const { store_id, ...queryParams } = params;
+          return apiConfig.httpClient.get(`${base(store_id)}/products`, {
+            ...options,
+            params: queryParams
+          });
+        }
+      },
+      order: {
+        getQuote(params, options) {
+          const store_id = params.store_id || apiConfig.storeId;
+          const { location, store_id: _store_id, ...rest } = params;
+          const shipping_address = location ? {
+            country: location.country || "",
+            state: location.state || "",
+            city: location.city || "",
+            postal_code: location.postal_code || "",
+            name: "",
+            street1: "",
+            street2: null
+          } : void 0;
+          return apiConfig.httpClient.post(
+            `${base(store_id)}/orders/quote`,
+            { ...rest, shipping_address, market: apiConfig.market },
+            options
+          );
+        },
+        checkout(params, options) {
+          const { store_id, ...rest } = params;
+          const target = store_id || apiConfig.storeId;
+          return apiConfig.httpClient.post(
+            `${base(target)}/orders/checkout`,
+            { ...rest, store_id: target, market: apiConfig.market },
+            options
+          );
+        },
+        get(params, options) {
+          const store_id = params.store_id || apiConfig.storeId;
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/orders/${params.id}`,
+            options
+          );
+        },
+        find(params, options) {
+          const { store_id, ...queryParams } = params;
+          return apiConfig.httpClient.get(`${base(store_id)}/orders`, {
+            ...options,
+            params: queryParams
+          });
+        }
+      }
+    },
+    booking: {
+      addToCart(slot) {
+        cart.push(slot);
+      },
+      removeFromCart(slotId) {
+        cart = cart.filter((slot) => slot.id !== slotId);
+      },
+      getCart() {
+        return [...cart];
+      },
+      clearCart() {
+        cart = [];
+      },
+      checkout(params, options) {
+        const { store_id, items: paramItems, ...payload } = params || {};
+        const target_store_id = store_id || apiConfig.storeId;
+        const items = paramItems || groupCartToItems(cart);
+        return apiConfig.httpClient.post(
+          `${base(target_store_id)}/bookings/checkout`,
+          { market: "booking", ...payload, items },
+          options
+        );
+      },
+      get(params, options) {
+        const store_id = params.store_id || apiConfig.storeId;
+        return apiConfig.httpClient.get(
+          `${base(store_id)}/bookings/${params.id}`,
+          options
+        );
+      },
+      find(params, options) {
+        const { store_id, ...queryParams } = params;
+        return apiConfig.httpClient.get(`${base(store_id)}/bookings`, {
+          ...options,
+          params: queryParams
+        });
+      },
+      getQuote(params, options) {
+        const { store_id, ...payload } = params;
+        const target_store_id = store_id || apiConfig.storeId;
+        return apiConfig.httpClient.post(
+          `${base(target_store_id)}/bookings/quote`,
+          { market: "booking", ...payload },
+          options
+        );
+      },
+      getAvailability(params, options) {
+        const { store_id, ...queryParams } = params;
+        const target_store_id = store_id || apiConfig.storeId;
+        return apiConfig.httpClient.get(
+          `${base(target_store_id)}/bookings/availability`,
+          { ...options, params: queryParams }
+        );
+      },
+      cancelItem(params, options) {
+        const { store_id, booking_id, item_id, ...payload } = params;
+        const target_store_id = store_id || apiConfig.storeId;
+        return apiConfig.httpClient.post(
+          `${base(target_store_id)}/bookings/${booking_id}/items/${item_id}/cancel`,
+          payload,
+          options
+        );
+      },
+      service: {
+        get(params, options) {
+          const store_id = params.store_id || apiConfig.storeId;
+          let identifier;
+          if (params.id) {
+            identifier = params.id;
+          } else if (params.slug) {
+            identifier = `${store_id}:${apiConfig.locale}:${params.slug}`;
+          } else {
+            throw new Error("GetServiceParams requires id or slug");
+          }
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/services/${identifier}`,
+            options
+          );
+        },
+        find(params, options) {
+          const { store_id, ...queryParams } = params;
+          return apiConfig.httpClient.get(`${base(store_id)}/services`, {
+            ...options,
+            params: queryParams
+          });
+        },
+        findProviders(params, options) {
+          const { store_id, ...queryParams } = params;
+          return apiConfig.httpClient.get(`${base(store_id)}/service-providers`, {
+            ...options,
+            params: queryParams
+          });
+        }
+      },
+      provider: {
+        get(params, options) {
+          const store_id = params.store_id || apiConfig.storeId;
+          let identifier;
+          if (params.id) {
+            identifier = params.id;
+          } else if (params.slug) {
+            identifier = `${store_id}:${apiConfig.locale}:${params.slug}`;
+          } else {
+            throw new Error("GetProviderParams requires id or slug");
+          }
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/providers/${identifier}`,
+            options
+          );
+        },
+        find(params, options) {
+          const { store_id, ...queryParams } = params;
+          return apiConfig.httpClient.get(`${base(store_id)}/providers`, {
+            ...options,
+            params: queryParams
+          });
+        }
+      }
+    },
+    crm: {
+      customer: {
+        async session(params, options) {
+          const store_id = params?.store_id || apiConfig.storeId;
+          const result = await apiConfig.httpClient.post(
+            `${base(store_id)}/customers/session`,
+            { store_id, market: params?.market || apiConfig.market || null },
+            options
+          );
+          if (result?.token?.access_token) {
+            apiConfig.setToken(result.token);
+          }
+          return result;
+        },
+        async connect(params, options) {
+          const store_id = params.store_id || apiConfig.storeId;
+          const result = await apiConfig.httpClient.post(
+            `${base(store_id)}/customers/connect`,
+            { email: params.email, store_id },
+            options
+          );
+          if (result?.access_token) {
+            apiConfig.setToken(result);
+          }
+          return result;
+        },
+        requestCode(params, options) {
+          const store_id = params.store_id || apiConfig.storeId;
+          return apiConfig.httpClient.post(
+            `${base(store_id)}/customers/auth/code`,
+            { email: params.email, store_id },
+            options
+          );
+        },
+        async verify(params, options) {
+          const store_id = params.store_id || apiConfig.storeId;
+          const result = await apiConfig.httpClient.post(
+            `${base(store_id)}/customers/auth/verify`,
+            { email: params.email, code: params.code, store_id },
+            options
+          );
+          if (result?.access_token) {
+            apiConfig.setToken(result);
+          }
+          return result;
+        },
+        async refreshToken(params, options) {
+          const store_id = params.store_id || apiConfig.storeId;
+          const result = await apiConfig.httpClient.post(
+            `${base(store_id)}/customers/auth/refresh`,
+            { refresh_token: params.refresh_token },
+            options
+          );
+          if (result?.access_token) {
+            apiConfig.setToken(result);
+          }
+          return result;
+        },
+        getMe(options) {
+          return apiConfig.httpClient.get(`${base()}/customers/me`, options);
+        }
+      },
+      audience: {
+        get(params, options) {
+          let identifier;
+          if (params.id) {
+            identifier = params.id;
+          } else if (params.key) {
+            identifier = `${apiConfig.storeId}:${params.key}`;
+          } else {
+            throw new Error("GetAudienceParams requires id or key");
+          }
+          return apiConfig.httpClient.get(
+            `${base(apiConfig.storeId)}/audiences/${identifier}`,
+            options
+          );
+        },
+        find(params, options) {
+          return apiConfig.httpClient.get(`${base()}/audiences`, {
+            ...options,
+            params
+          });
+        },
+        subscribe(params, options) {
+          return apiConfig.httpClient.post(
+            `${base()}/audiences/${params.id}/subscribe`,
+            {
+              customer_id: params.customer_id,
+              price_id: params.price_id,
+              success_url: params.success_url,
+              cancel_url: params.cancel_url,
+              confirm_url: params.confirm_url
+            },
+            options
+          );
+        },
+        checkAccess(params, options) {
+          return apiConfig.httpClient.get(
+            `${base()}/audiences/${params.id}/access`,
+            options
+          );
+        },
+        unsubscribe(token, options) {
+          return apiConfig.httpClient.get(`${base()}/audiences/unsubscribe`, {
+            ...options,
+            params: { token }
+          });
+        },
+        confirm(token, options) {
+          return apiConfig.httpClient.get(`${base()}/audiences/confirm`, {
+            ...options,
+            params: { token }
+          });
+        }
+      }
+    },
+    activity: createActivityApi(apiConfig),
+    automation: {
+      agent: {
+        getAgents(params, options) {
+          const store_id = params?.store_id || apiConfig.storeId;
+          const queryParams = { ...params || {} };
+          delete queryParams.store_id;
+          return apiConfig.httpClient.get(`${base(store_id)}/agents`, {
+            ...options,
+            params: Object.keys(queryParams).length > 0 ? queryParams : void 0
+          });
+        },
+        getAgent(params, options) {
+          const store_id = params.store_id || apiConfig.storeId;
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/agents/${params.id}`,
+            options
+          );
+        },
+        sendMessage(params, options) {
+          const store_id = params.store_id || apiConfig.storeId;
+          const body = { message: params.message };
+          if (params.chat_id) body.chat_id = params.chat_id;
+          return apiConfig.httpClient.post(
+            `${base(store_id)}/agents/${params.id}/chats/messages`,
+            body,
+            options
+          );
+        },
+        getChat(params, options) {
+          const store_id = params.store_id || apiConfig.storeId;
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/agents/${params.id}/chats/${params.chat_id}`,
+            options
+          );
+        },
+        getChatMessages(params, options) {
+          const store_id = params.store_id || apiConfig.storeId;
+          const queryParams = {};
+          if (params.limit) queryParams.limit = String(params.limit);
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/agents/${params.id}/chats/${params.chat_id}/messages`,
+            {
+              ...options,
+              params: Object.keys(queryParams).length > 0 ? queryParams : void 0
+            }
+          );
+        },
+        rateChat(params, options) {
+          const store_id = params.store_id || apiConfig.storeId;
+          const body = { rating: params.rating };
+          if (params.comment) body.comment = params.comment;
+          return apiConfig.httpClient.post(
+            `${base(store_id)}/agents/${params.id}/chats/${params.chat_id}/rate`,
+            body,
+            options
+          );
+        }
+      }
+    }
+  };
+};
+
+// src/utils/errors.ts
+var convertServerErrorToRequestError = (serverError, renameRules) => {
+  const validationErrors = serverError?.validationErrors ?? [];
+  return {
+    ...serverError,
+    validationErrors: validationErrors.map((validationError) => {
+      const field = validationError.field;
+      return {
+        field,
+        error: validationError.error || "GENERAL.VALIDATION_ERROR"
+      };
+    })
+  };
+};
+
+// src/utils/queryParams.ts
+function buildQueryString(params) {
+  const queryParts = [];
+  Object.entries(params).forEach(([key, value]) => {
+    if (value === null || value === void 0) {
+      return;
+    }
+    if (Array.isArray(value)) {
+      const jsonString = JSON.stringify(value);
+      queryParts.push(`${key}=${encodeURIComponent(jsonString)}`);
+    } else if (typeof value === "string") {
+      queryParts.push(`${key}=${encodeURIComponent(value)}`);
+    } else if (typeof value === "number" || typeof value === "boolean") {
+      queryParts.push(`${key}=${value}`);
+    } else if (typeof value === "object") {
+      const jsonString = JSON.stringify(value);
+      queryParts.push(`${key}=${encodeURIComponent(jsonString)}`);
+    }
+  });
+  return queryParts.length > 0 ? `?${queryParts.join("&")}` : "";
+}
+
+// src/services/createHttpClient.ts
+var STORAGE_KEYS = {
+  access_token: "arky_token",
+  refresh_token: "arky_refresh",
+  access_expires_at: "arky_expires_at"
+};
+function defaultGetToken() {
+  if (typeof window === "undefined") return { access_token: "" };
+  return {
+    access_token: localStorage.getItem(STORAGE_KEYS.access_token) || "",
+    refresh_token: localStorage.getItem(STORAGE_KEYS.refresh_token) || "",
+    access_expires_at: parseInt(localStorage.getItem(STORAGE_KEYS.access_expires_at) || "0", 10)
+  };
+}
+function defaultSetToken(tokens) {
+  if (typeof window === "undefined") return;
+  if (tokens.access_token) {
+    localStorage.setItem(STORAGE_KEYS.access_token, tokens.access_token);
+    localStorage.setItem(STORAGE_KEYS.refresh_token, tokens.refresh_token || "");
+    localStorage.setItem(STORAGE_KEYS.access_expires_at, (tokens.access_expires_at || 0).toString());
+  } else {
+    Object.values(STORAGE_KEYS).forEach((key) => localStorage.removeItem(key));
+  }
+}
+function defaultLogout() {
+  if (typeof window === "undefined") return;
+  Object.values(STORAGE_KEYS).forEach((key) => localStorage.removeItem(key));
+}
+function defaultIsAuthenticated() {
+  if (typeof window === "undefined") return false;
+  const token = localStorage.getItem(STORAGE_KEYS.access_token) || "";
+  return token.startsWith("customer_") || token.startsWith("account_");
+}
+function createHttpClient(cfg) {
+  const getToken = cfg.getToken || defaultGetToken;
+  const setToken = cfg.setToken || defaultSetToken;
+  const logout = cfg.logout || defaultLogout;
+  let refreshPromise = null;
+  function getRefreshEndpoint() {
+    const refreshPath = typeof cfg.refreshPath === "function" ? cfg.refreshPath() : cfg.refreshPath || "/v1/auth/refresh";
+    return `${cfg.baseUrl}${refreshPath}`;
+  }
+  async function ensureFreshToken() {
+    if (refreshPromise) {
+      return refreshPromise;
+    }
+    refreshPromise = (async () => {
+      const { refresh_token } = await getToken();
+      if (!refresh_token) {
+        logout();
+        const err = new Error("No refresh token available");
+        err.name = "ApiError";
+        err.statusCode = 401;
+        throw err;
+      }
+      const refRes = await fetch(getRefreshEndpoint(), {
+        method: "POST",
+        headers: { Accept: "application/json", "Content-Type": "application/json" },
+        body: JSON.stringify({ refresh_token })
+      });
+      if (!refRes.ok) {
+        logout();
+        const err = new Error("Token refresh failed");
+        err.name = "ApiError";
+        err.statusCode = 401;
+        throw err;
+      }
+      const data = await refRes.json();
+      setToken(data);
+    })().finally(() => {
+      refreshPromise = null;
+    });
+    return refreshPromise;
+  }
+  async function request(method, path, body, options) {
+    if (options?.transformRequest) {
+      body = options.transformRequest(body);
+    }
+    const headers = {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      ...options?.headers || {}
+    };
+    let { access_token, access_expires_at } = await getToken();
+    const nowSec = Date.now() / 1e3;
+    if (access_expires_at && nowSec > access_expires_at) {
+      await ensureFreshToken();
+      const tokens = await getToken();
+      access_token = tokens.access_token;
+    }
+    if (access_token) {
+      headers["Authorization"] = `Bearer ${access_token}`;
+    }
+    const finalPath = options?.params ? path + buildQueryString(options.params) : path;
+    const fetchOpts = { method, headers };
+    if (!["GET", "DELETE"].includes(method) && body !== void 0) {
+      fetchOpts.body = JSON.stringify(body);
+    }
+    const fullUrl = `${cfg.baseUrl}${finalPath}`;
+    let res;
+    let data;
+    const startedAt = Date.now();
+    try {
+      res = await fetch(fullUrl, fetchOpts);
+    } catch (error) {
+      const err = new Error(error instanceof Error ? error.message : "Network request failed");
+      err.name = "NetworkError";
+      err.method = method;
+      err.url = fullUrl;
+      if (options?.onError && method !== "GET") {
+        Promise.resolve(
+          options.onError({ error: err, method, url: fullUrl, aborted: false })
+        ).catch(() => {
+        });
+      }
+      throw err;
+    }
+    if (res.status === 401 && !options?.["_retried"]) {
+      try {
+        await ensureFreshToken();
+        const tokens = await getToken();
+        headers["Authorization"] = `Bearer ${tokens.access_token}`;
+        fetchOpts.headers = headers;
+        return request(method, path, body, { ...options, _retried: true });
+      } catch (refreshError) {
+        throw refreshError;
+      }
+    }
+    try {
+      const contentLength = res.headers.get("content-length");
+      const contentType = res.headers.get("content-type");
+      if (res.status === 204 || contentLength === "0" || !contentType?.includes("application/json")) {
+        data = {};
+      } else {
+        data = await res.json();
+      }
+    } catch (error) {
+      const err = new Error("Failed to parse response");
+      err.name = "ParseError";
+      err.method = method;
+      err.url = fullUrl;
+      err.status = res.status;
+      if (options?.onError && method !== "GET") {
+        Promise.resolve(
+          options.onError({ error: err, method, url: fullUrl, status: res.status })
+        ).catch(() => {
+        });
+      }
+      throw err;
+    }
+    if (!res.ok) {
+      const serverErr = data;
+      const reqErr = convertServerErrorToRequestError(serverErr);
+      const err = new Error(serverErr.message || "Request failed");
+      err.name = "ApiError";
+      err.statusCode = serverErr.statusCode || res.status;
+      err.validationErrors = reqErr.validationErrors;
+      err.method = method;
+      err.url = fullUrl;
+      const requestId = res.headers.get("x-request-id") || res.headers.get("request-id");
+      if (requestId) err.requestId = requestId;
+      if (options?.onError && method !== "GET") {
+        Promise.resolve(
+          options.onError({
+            error: err,
+            method,
+            url: fullUrl,
+            status: res.status,
+            response: serverErr,
+            request_id: requestId || null,
+            duration_ms: Date.now() - startedAt
+          })
+        ).catch(() => {
+        });
+      }
+      throw err;
+    }
+    if (options?.onSuccess && method !== "GET") {
+      const requestId = res.headers.get("x-request-id") || res.headers.get("request-id");
+      Promise.resolve(
+        options.onSuccess({
+          data,
+          method,
+          url: fullUrl,
+          status: res.status,
+          request_id: requestId || null,
+          duration_ms: Date.now() - startedAt
+        })
+      ).catch(() => {
+      });
+    }
+    return data;
+  }
+  return {
+    get: (path, opts) => request("GET", path, void 0, opts),
+    post: (path, body, opts) => request("POST", path, body, opts),
+    put: (path, body, opts) => request("PUT", path, body, opts),
+    patch: (path, body, opts) => request("PATCH", path, body, opts),
+    delete: (path, opts) => request("DELETE", path, void 0, opts)
+  };
+}
+
+// src/utils/price.ts
+function formatCurrency(amount, currencyCode, locale = "en") {
+  if (!currencyCode) return "";
+  return new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: currencyCode.toUpperCase()
+  }).format(amount);
+}
+function getMinorUnits(currency) {
+  try {
+    const formatter = new Intl.NumberFormat("en", {
+      style: "currency",
+      currency: currency.toUpperCase()
+    });
+    const parts = formatter.formatToParts(1.11);
+    const fractionPart = parts.find((p) => p.type === "fraction");
+    return fractionPart?.value.length ?? 2;
+  } catch {
+    return 2;
+  }
+}
+function convertToMajor(minorAmount, currency) {
+  const units = getMinorUnits(currency);
+  return minorAmount / Math.pow(10, units);
+}
+function getCurrencySymbol(currency) {
+  try {
+    return new Intl.NumberFormat("en", {
+      style: "currency",
+      currency: currency.toUpperCase(),
+      currencyDisplay: "narrowSymbol"
+    }).formatToParts(0).find((p) => p.type === "currency")?.value || currency.toUpperCase();
+  } catch {
+    return currency.toUpperCase();
+  }
+}
+function getCurrencyName(currency) {
+  try {
+    return new Intl.DisplayNames(["en"], { type: "currency" }).of(currency.toUpperCase()) || currency.toUpperCase();
+  } catch {
+    return currency.toUpperCase();
+  }
+}
+function formatMinor(amountMinor, currency) {
+  if (!currency) return "";
+  return formatCurrency(convertToMajor(amountMinor, currency), currency);
+}
+function formatPayment(payment) {
+  return formatMinor(payment.total, payment.currency);
+}
+function formatPrice(prices, marketId) {
+  if (!prices || prices.length === 0) return "";
+  const price = marketId ? prices.find((p) => p.market === marketId) || prices[0] : prices[0];
+  if (!price) return "";
+  return formatMinor(price.amount, price.currency);
+}
+function getPriceAmount(prices, marketId) {
+  if (!prices || prices.length === 0) return 0;
+  const price = prices.find((p) => p.market === marketId) || prices[0];
+  return price?.amount || 0;
+}
+
+// src/utils/validation.ts
+function validatePhoneNumber(phone) {
+  if (!phone) {
+    return { isValid: false, error: "Phone number is required" };
+  }
+  const cleaned = phone.replace(/\D/g, "");
+  if (cleaned.length < 8) {
+    return { isValid: false, error: "Phone number is too short" };
+  }
+  if (cleaned.length > 15) {
+    return { isValid: false, error: "Phone number is too long" };
+  }
+  return { isValid: true };
+}
+
+// src/utils/timezone.ts
+var tzGroups = [
+  {
+    label: "US",
+    zones: [
+      { label: "Eastern Time", value: "America/New_York" },
+      { label: "Central Time", value: "America/Chicago" },
+      { label: "Mountain Time", value: "America/Denver" },
+      { label: "Pacific Time", value: "America/Los_Angeles" }
+    ]
+  },
+  {
+    label: "Europe",
+    zones: [
+      { label: "London", value: "Europe/London" },
+      { label: "Paris", value: "Europe/Paris" },
+      { label: "Berlin", value: "Europe/Berlin" },
+      { label: "Rome", value: "Europe/Rome" }
+    ]
+  },
+  {
+    label: "Asia",
+    zones: [
+      { label: "Tokyo", value: "Asia/Tokyo" },
+      { label: "Shanghai", value: "Asia/Shanghai" },
+      { label: "Mumbai", value: "Asia/Kolkata" },
+      { label: "Dubai", value: "Asia/Dubai" }
+    ]
+  }
+];
+function findTimeZone(groups) {
+  try {
+    const detected = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    for (const group of groups) {
+      for (const zone of group.zones) {
+        if (zone.value === detected) {
+          return detected;
+        }
+      }
+    }
+    return "UTC";
+  } catch (e) {
+    return "UTC";
+  }
+}
+
+// src/utils/text.ts
+var locales = ["en", "sr-latn"];
+var localeMap = {
+  "en": "en-US",
+  "sr-latn": "sr-RS"
+};
+function slugify(text) {
+  return text.toString().toLowerCase().replace(/\s+/g, "-").replace(/[^\w-]+/g, "").replace(/--+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+}
+function humanize(text) {
+  const slugifiedText = slugify(text);
+  return slugifiedText.replace(/-/g, " ").replace(
+    /\w\S*/g,
+    (w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()
+  );
+}
+function categorify(text) {
+  const slugifiedText = slugify(text);
+  return slugifiedText.replace(/-/g, " ").toUpperCase();
+}
+function formatDate(date, locale) {
+  let localeString = "en-US";
+  if (locales.includes(locale)) {
+    localeString = localeMap[locale];
+  }
+  return new Date(date).toLocaleDateString(localeString, {
+    timeZone: "UTC",
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+}
+
+// src/utils/svg.ts
+async function fetchSvgContent(mediaObject) {
+  if (!mediaObject) return null;
+  const svgUrl = getImageUrl(mediaObject, false);
+  try {
+    const response = await fetch(svgUrl);
+    if (!response.ok) {
+      console.error(`Failed to fetch SVG: ${response.status} ${response.statusText}`);
+      return null;
+    }
+    const svgContent = await response.text();
+    return svgContent;
+  } catch (error) {
+    console.error("Error fetching SVG:", error);
+    return null;
+  }
+}
+async function getSvgContentForAstro(mediaObject) {
+  try {
+    const svgContent = await fetchSvgContent(mediaObject);
+    return svgContent || "";
+  } catch (error) {
+    console.error("Error getting SVG content for Astro:", error);
+    return "";
+  }
+}
+async function injectSvgIntoElement(mediaObject, targetElement, className) {
+  if (!targetElement) return;
+  try {
+    const svgContent = await fetchSvgContent(mediaObject);
+    if (svgContent) {
+      targetElement.innerHTML = svgContent;
+      if (className) {
+        const svgElement = targetElement.querySelector("svg");
+        if (svgElement) {
+          svgElement.classList.add(...className.split(" "));
+        }
+      }
+    }
+  } catch (error) {
+    console.error("Error injecting SVG:", error);
+  }
+}
+
+// src/utils/keyValidation.ts
+var KEY_PATTERN = /^[a-zA-Z0-9_-]+$/;
+function isValidKey(key) {
+  if (!key || key.length === 0) return false;
+  return KEY_PATTERN.test(key);
+}
+function validateKey(key) {
+  if (!key || key.length === 0) {
+    return { valid: false, error: "Key is required" };
+  }
+  if (key.length > 255) {
+    return { valid: false, error: "Key must be 255 characters or less" };
+  }
+  if (!KEY_PATTERN.test(key)) {
+    return {
+      valid: false,
+      error: "Key can only contain letters, numbers, underscores (_) and hyphens (-)"
+    };
+  }
+  return { valid: true };
+}
+function toKey(input) {
+  if (!input) return "";
+  return input.toLowerCase().trim().replace(/\s+/g, "_").replace(/[^a-z0-9_-]/g, "").replace(/^[-_]+|[-_]+$/g, "").replace(/[-_]{2,}/g, "_");
+}
+function nameToKey(name) {
+  return toKey(name);
+}
+
+// src/utils/inventory.ts
+function getAvailableStock(variant) {
+  if (!variant?.inventory) return 0;
+  return variant.inventory.reduce((sum, inv) => sum + inv.available, 0);
+}
+function getReservedStock(variant) {
+  if (!variant?.inventory) return 0;
+  return variant.inventory.reduce((sum, inv) => sum + inv.reserved, 0);
+}
+function hasStock(variant, quantity = 1) {
+  return getAvailableStock(variant) >= quantity;
+}
+function getInventoryAt(variant, locationId) {
+  return variant?.inventory?.find((inv) => inv.location_id === locationId);
+}
+function getFirstAvailableFCId(variant, quantity = 1) {
+  const inv = variant?.inventory?.find((i) => i.available >= quantity);
+  return inv?.location_id;
+}
+
+// src/index.ts
+function createUtilitySurface(apiConfig) {
+  return {
+    getImageUrl: (imageBlock, isBlock = true) => getImageUrl(imageBlock, isBlock),
+    getBlockValue,
+    getBlockTextValue,
+    getBlockValues,
+    getBlockLabel,
+    getBlockObjectValues,
+    getBlockFromArray,
+    formatBlockValue,
+    prepareBlocksForSubmission,
+    extractBlockValues,
+    formatPrice: (prices) => formatPrice(prices, apiConfig.market),
+    getPriceAmount: (prices) => getPriceAmount(prices, apiConfig.market),
+    formatPayment,
+    formatMinor,
+    getCurrencySymbol,
+    getCurrencyName,
+    validatePhoneNumber,
+    tzGroups,
+    findTimeZone,
+    slugify,
+    humanize,
+    categorify,
+    formatDate,
+    getSvgContentForAstro,
+    fetchSvgContent,
+    injectSvgIntoElement,
+    isValidKey,
+    validateKey,
+    toKey,
+    nameToKey,
+    getAvailableStock,
+    getReservedStock,
+    hasStock,
+    getInventoryAt,
+    getFirstAvailableFCId
+  };
+}
+function createStorefront(config) {
+  const locale = config.locale || "en";
+  const market = config.market || "";
+  const getToken = config.getToken || defaultGetToken;
+  const setToken = config.setToken || defaultSetToken;
+  const logout = config.logout || defaultLogout;
+  const isAuthenticated = config.isAuthenticated || defaultIsAuthenticated;
+  let refresh_store_id = config.storeId;
+  const httpClient = createHttpClient({
+    ...config,
+    getToken,
+    setToken,
+    logout,
+    refreshPath: () => `/v1/storefront/${refresh_store_id}/customers/auth/refresh`
+  });
+  const apiConfig = {
+    httpClient,
+    storeId: config.storeId,
+    baseUrl: config.baseUrl,
+    market,
+    locale,
+    setToken,
+    getToken
+  };
+  const storefrontApi = createStorefrontApi(apiConfig);
+  let sessionPromise = null;
+  let currentSession = null;
+  const sessionListeners = /* @__PURE__ */ new Set();
+  const customerApi = storefrontApi.crm.customer;
+  function emitSessionChange(session2) {
+    for (const listener of sessionListeners) {
+      Promise.resolve().then(() => listener(session2)).catch(() => {
+      });
+    }
+  }
+  function setCurrentSessionFromResult(result) {
+    const s = {
+      customer: result.customer,
+      store: result.store,
+      market: result.market || null
+    };
+    currentSession = s;
+    emitSessionChange(s);
+    return s;
+  }
+  function clearSession() {
+    sessionPromise = null;
+    currentSession = null;
+    emitSessionChange(null);
+  }
+  async function invalidateAfterAuth(promise) {
+    const result = await promise;
+    clearSession();
+    return result;
+  }
+  function session(market2) {
+    if (market2 !== void 0) apiConfig.market = market2;
+    if (sessionPromise) return sessionPromise;
+    sessionPromise = (async () => {
+      try {
+        const result = await customerApi.session({
+          market: apiConfig.market
+        });
+        return setCurrentSessionFromResult(result);
+      } catch (err) {
+        const status = err?.statusCode || err?.status || err?.response?.status;
+        if (status === 401) {
+          currentSession = null;
+          emitSessionChange(null);
+          await setToken({ access_token: "", refresh_token: "", access_expires_at: 0 });
+          const result = await customerApi.session({
+            market: apiConfig.market
+          });
+          return setCurrentSessionFromResult(result);
+        }
+        throw err;
+      }
+    })().catch((err) => {
+      sessionPromise = null;
+      throw err;
+    });
+    return sessionPromise;
+  }
+  function setMarket(key) {
+    apiConfig.market = key;
+    clearSession();
+  }
+  function onSessionChange(listener) {
+    sessionListeners.add(listener);
+    if (currentSession) {
+      Promise.resolve().then(() => listener(currentSession)).catch(() => {
+      });
+    }
+    return () => {
+      sessionListeners.delete(listener);
+    };
+  }
+  function getSession() {
+    return currentSession;
+  }
+  function logoutAndClearSession() {
+    clearSession();
+    return logout();
+  }
+  function setTokenAndClearSession(tokens) {
+    setToken(tokens);
+    clearSession();
+  }
+  const crm = {
+    ...storefrontApi.crm,
+    customer: {
+      ...customerApi,
+      async session(params, options) {
+        const result = await customerApi.session(params, options);
+        setCurrentSessionFromResult(result);
+        return result;
+      },
+      connect: (params, options) => invalidateAfterAuth(customerApi.connect(params, options)),
+      verify: (params, options) => invalidateAfterAuth(customerApi.verify(params, options))
+    }
+  };
+  return {
+    session,
+    getSession,
+    onSessionChange,
+    store: storefrontApi.store,
+    cms: storefrontApi.cms,
+    eshop: storefrontApi.eshop,
+    booking: storefrontApi.booking,
+    crm,
+    activity: storefrontApi.activity,
+    automation: storefrontApi.automation,
+    setStoreId: (storeId) => {
+      refresh_store_id = storeId;
+      apiConfig.storeId = storeId;
+      clearSession();
+    },
+    getStoreId: () => apiConfig.storeId,
+    setMarket,
+    getMarket: () => apiConfig.market,
+    setLocale: (locale2) => {
+      apiConfig.locale = locale2;
+    },
+    getLocale: () => apiConfig.locale,
+    isAuthenticated,
+    logout: logoutAndClearSession,
+    setToken: setTokenAndClearSession,
+    extractBlockValues,
+    utils: createUtilitySurface(apiConfig)
+  };
+}
+
+export { COMMON_ACTIVITY_TYPES, createStorefront };
+//# sourceMappingURL=storefront.js.map
+//# sourceMappingURL=storefront.js.map