@behio/storefront-sdk 0.1.0

package/dist/react.js

@@ -0,0 +1,813 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunk26WZOAWPjs = require('./chunk-26WZOAWP.js');
+
+// src/react/provider.tsx
+var _react = require('react');
+var _reactquery = require('@tanstack/react-query');
+
+// src/react/context.ts
+
+var BehioContext = _react.createContext.call(void 0, null);
+function useBehio() {
+  const ctx = _react.useContext.call(void 0, BehioContext);
+  if (!ctx) {
+    throw new Error("useBehio must be used within a <BehioProvider>");
+  }
+  return ctx;
+}
+
+// src/react/storage.ts
+function getCookie(name) {
+  if (typeof document === "undefined") return null;
+  const match = document.cookie.match(new RegExp("(?:^|; )" + name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "=([^;]*)"));
+  return match ? decodeURIComponent(match[1]) : null;
+}
+function setCookie(name, value, maxAgeDays = 30) {
+  if (typeof document === "undefined") return;
+  const maxAge = maxAgeDays * 24 * 60 * 60;
+  document.cookie = `${name}=${encodeURIComponent(value)}; path=/; max-age=${maxAge}; SameSite=Lax`;
+}
+function removeCookie(name) {
+  if (typeof document === "undefined") return;
+  document.cookie = `${name}=; path=/; max-age=0; SameSite=Lax`;
+}
+var cookieStorage = {
+  get: getCookie,
+  set: setCookie,
+  remove: removeCookie
+};
+var localStorageAdapter = {
+  get(key) {
+    try {
+      return window.localStorage.getItem(key);
+    } catch (e) {
+      return null;
+    }
+  },
+  set(key, value) {
+    try {
+      window.localStorage.setItem(key, value);
+    } catch (e2) {
+    }
+  },
+  remove(key) {
+    try {
+      window.localStorage.removeItem(key);
+    } catch (e3) {
+    }
+  }
+};
+function createMemoryStorage() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      return _nullishCoalesce(store.get(key), () => ( null));
+    },
+    set(key, value) {
+      store.set(key, value);
+    },
+    remove(key) {
+      store.delete(key);
+    }
+  };
+}
+var memoryStorage = createMemoryStorage();
+function detectStorage() {
+  if (typeof document !== "undefined") {
+    return cookieStorage;
+  }
+  if (typeof window !== "undefined" && window.localStorage) {
+    return localStorageAdapter;
+  }
+  return createMemoryStorage();
+}
+function resolveStorage(option) {
+  if (!option) return detectStorage();
+  if (typeof option === "object") return option;
+  switch (option) {
+    case "cookies":
+      return cookieStorage;
+    case "localStorage":
+      return localStorageAdapter;
+    case "memory":
+      return createMemoryStorage();
+  }
+}
+var STORAGE_KEYS = {
+  ACCESS_TOKEN: "behio_access_token",
+  REFRESH_TOKEN: "behio_refresh_token",
+  CART_SESSION: "behio_cart_session"
+};
+
+// src/react/provider.tsx
+var _jsxruntime = require('react/jsx-runtime');
+function BehioProvider({
+  apiKey,
+  baseUrl,
+  locale,
+  currency,
+  storage: storageOption,
+  queryClient: externalQueryClient,
+  children
+}) {
+  const storageAdapter = _react.useMemo.call(void 0, () => resolveStorage(storageOption), [storageOption]);
+  const clientRef = _react.useRef.call(void 0, null);
+  if (!clientRef.current) {
+    clientRef.current = new (0, _chunk26WZOAWPjs.BehioStorefront)({
+      apiKey,
+      baseUrl,
+      locale,
+      currency
+    });
+  }
+  const client = clientRef.current;
+  _react.useEffect.call(void 0, () => {
+    const accessToken = storageAdapter.get(STORAGE_KEYS.ACCESS_TOKEN);
+    const refreshToken = storageAdapter.get(STORAGE_KEYS.REFRESH_TOKEN);
+    if (accessToken && refreshToken) {
+      client.setTokens({ accessToken, refreshToken });
+    }
+    const cartSession = storageAdapter.get(STORAGE_KEYS.CART_SESSION);
+    if (cartSession) {
+      client.setCartSession(cartSession);
+    }
+  }, [client, storageAdapter]);
+  const queryClientRef = _react.useRef.call(void 0, null);
+  const qc = _react.useMemo.call(void 0, () => {
+    if (externalQueryClient) return externalQueryClient;
+    if (!queryClientRef.current) {
+      queryClientRef.current = new (0, _reactquery.QueryClient)({
+        defaultOptions: {
+          queries: {
+            staleTime: 6e4,
+            retry: 1
+          }
+        }
+      });
+    }
+    return queryClientRef.current;
+  }, [externalQueryClient]);
+  const ctxValue = _react.useMemo.call(void 0, 
+    () => ({ client, storage: storageAdapter }),
+    [client, storageAdapter]
+  );
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _reactquery.QueryClientProvider, { client: qc, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, BehioContext.Provider, { value: ctxValue, children }) });
+}
+
+// src/react/hooks/use-products.ts
+
+function useProducts(query) {
+  const { client } = useBehio();
+  const { initialData, enabled, ...productsQuery } = _nullishCoalesce(query, () => ( {}));
+  const serializedQuery = JSON.stringify(productsQuery);
+  return _reactquery.useQuery.call(void 0, {
+    queryKey: ["behio", "products", serializedQuery],
+    queryFn: () => client.catalog.getProducts(productsQuery),
+    initialData,
+    enabled
+  });
+}
+
+// src/react/hooks/use-product.ts
+
+function useProduct(slug, options) {
+  const { client } = useBehio();
+  return _reactquery.useQuery.call(void 0, {
+    queryKey: ["behio", "product", slug],
+    queryFn: () => client.catalog.getProduct(slug, {
+      locale: _optionalChain([options, 'optionalAccess', _ => _.locale]),
+      currency: _optionalChain([options, 'optionalAccess', _2 => _2.currency])
+    }),
+    initialData: _optionalChain([options, 'optionalAccess', _3 => _3.initialData]),
+    enabled: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _4 => _4.enabled]), () => ( !!slug))
+  });
+}
+
+// src/react/hooks/use-categories.ts
+
+function useCategories(locale) {
+  const { client } = useBehio();
+  return _reactquery.useQuery.call(void 0, {
+    queryKey: ["behio", "categories", locale],
+    queryFn: async () => {
+      const result = await client.catalog.getCategories(locale);
+      return result.categories;
+    }
+  });
+}
+
+// src/react/hooks/use-labels.ts
+
+function useLabels(locale) {
+  const { client } = useBehio();
+  return _reactquery.useQuery.call(void 0, {
+    queryKey: ["behio", "labels", locale],
+    queryFn: async () => {
+      const result = await client.catalog.getLabels(locale);
+      return result.labels;
+    }
+  });
+}
+
+// src/react/hooks/use-featured.ts
+
+function useFeatured(options) {
+  const { client } = useBehio();
+  return _reactquery.useQuery.call(void 0, {
+    queryKey: ["behio", "featured", _optionalChain([options, 'optionalAccess', _5 => _5.locale]), _optionalChain([options, 'optionalAccess', _6 => _6.currency])],
+    queryFn: () => client.catalog.getFeatured({
+      locale: _optionalChain([options, 'optionalAccess', _7 => _7.locale]),
+      currency: _optionalChain([options, 'optionalAccess', _8 => _8.currency])
+    }),
+    initialData: _optionalChain([options, 'optionalAccess', _9 => _9.initialData]),
+    enabled: _optionalChain([options, 'optionalAccess', _10 => _10.enabled])
+  });
+}
+
+// src/react/hooks/use-filters.ts
+
+function useFilters() {
+  const { client } = useBehio();
+  return _reactquery.useQuery.call(void 0, {
+    queryKey: ["behio", "filters"],
+    queryFn: async () => {
+      const result = await client.catalog.getFilters();
+      return result.filters;
+    }
+  });
+}
+
+// src/react/hooks/use-search.ts
+
+
+function useSearch(query, options) {
+  const { client } = useBehio();
+  const debounceMs = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _11 => _11.debounceMs]), () => ( 300));
+  const [debouncedQuery, setDebouncedQuery] = _react.useState.call(void 0, query);
+  _react.useEffect.call(void 0, () => {
+    if (debounceMs <= 0) {
+      setDebouncedQuery(query);
+      return;
+    }
+    const timer = setTimeout(() => setDebouncedQuery(query), debounceMs);
+    return () => clearTimeout(timer);
+  }, [query, debounceMs]);
+  return _reactquery.useQuery.call(void 0, {
+    queryKey: ["behio", "search", debouncedQuery, _optionalChain([options, 'optionalAccess', _12 => _12.page]), _optionalChain([options, 'optionalAccess', _13 => _13.limit])],
+    queryFn: () => client.catalog.search(debouncedQuery, {
+      page: _optionalChain([options, 'optionalAccess', _14 => _14.page]),
+      limit: _optionalChain([options, 'optionalAccess', _15 => _15.limit])
+    }),
+    enabled: (_nullishCoalesce(_optionalChain([options, 'optionalAccess', _16 => _16.enabled]), () => ( true))) && debouncedQuery.length > 0
+  });
+}
+
+// src/react/hooks/use-cart.ts
+
+
+var CART_KEY = ["behio", "cart"];
+function useCart() {
+  const { client, storage } = useBehio();
+  const queryClient = _reactquery.useQueryClient.call(void 0, );
+  const {
+    data: cart,
+    isLoading,
+    error
+  } = _reactquery.useQuery.call(void 0, {
+    queryKey: [...CART_KEY],
+    queryFn: () => client.cart.get(),
+    // Only fetch if we have a cart session or are logged in
+    enabled: !!client.getCartSession() || !!client.getAccessToken()
+  });
+  const addMutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: async ({ productId, quantity }) => {
+      return client.cart.addItem({ productId, quantity: _nullishCoalesce(quantity, () => ( 1)) });
+    },
+    onSuccess: (result) => {
+      if (result.newSessionToken) {
+        storage.set(STORAGE_KEYS.CART_SESSION, result.newSessionToken);
+      }
+      queryClient.setQueryData([...CART_KEY], result);
+    }
+  });
+  const updateMutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: async ({ itemId, quantity }) => {
+      return client.cart.updateQuantity(itemId, quantity);
+    },
+    onMutate: async ({ itemId, quantity }) => {
+      await queryClient.cancelQueries({ queryKey: [...CART_KEY] });
+      const previous = queryClient.getQueryData([...CART_KEY]);
+      if (previous) {
+        const updatedItems = previous.items.map(
+          (item) => item.id === itemId ? { ...item, quantity, totalPrice: item.unitPrice * quantity } : item
+        );
+        queryClient.setQueryData([...CART_KEY], {
+          ...previous,
+          items: updatedItems,
+          itemCount: updatedItems.reduce((sum, i) => sum + i.quantity, 0)
+        });
+      }
+      return { previous };
+    },
+    onError: (_err, _vars, context) => {
+      if (_optionalChain([context, 'optionalAccess', _17 => _17.previous])) {
+        queryClient.setQueryData([...CART_KEY], context.previous);
+      }
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: [...CART_KEY] });
+    }
+  });
+  const removeMutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: async (itemId) => {
+      return client.cart.removeItem(itemId);
+    },
+    onMutate: async (itemId) => {
+      await queryClient.cancelQueries({ queryKey: [...CART_KEY] });
+      const previous = queryClient.getQueryData([...CART_KEY]);
+      if (previous) {
+        const updatedItems = previous.items.filter((item) => item.id !== itemId);
+        queryClient.setQueryData([...CART_KEY], {
+          ...previous,
+          items: updatedItems,
+          itemCount: updatedItems.reduce((sum, i) => sum + i.quantity, 0)
+        });
+      }
+      return { previous };
+    },
+    onError: (_err, _vars, context) => {
+      if (_optionalChain([context, 'optionalAccess', _18 => _18.previous])) {
+        queryClient.setQueryData([...CART_KEY], context.previous);
+      }
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: [...CART_KEY] });
+    }
+  });
+  const clearMutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: () => client.cart.clear(),
+    onSuccess: () => {
+      queryClient.setQueryData([...CART_KEY], null);
+      client.clearCartSession();
+      storage.remove(STORAGE_KEYS.CART_SESSION);
+    }
+  });
+  const applyDiscountMutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: (code) => client.cart.applyDiscount(code),
+    onSuccess: (result) => {
+      queryClient.setQueryData([...CART_KEY], result);
+    }
+  });
+  const removeDiscountMutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: () => client.cart.removeDiscount(),
+    onSuccess: (result) => {
+      queryClient.setQueryData([...CART_KEY], result);
+    }
+  });
+  const mergeMutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: () => client.cart.merge(),
+    onSuccess: (result) => {
+      queryClient.setQueryData([...CART_KEY], result);
+      client.clearCartSession();
+      storage.remove(STORAGE_KEYS.CART_SESSION);
+    }
+  });
+  const addItem = _react.useCallback.call(void 0, 
+    (productId, quantity) => addMutation.mutateAsync({ productId, quantity }),
+    [addMutation]
+  );
+  const updateQuantity = _react.useCallback.call(void 0, 
+    (itemId, quantity) => updateMutation.mutateAsync({ itemId, quantity }),
+    [updateMutation]
+  );
+  const removeItem = _react.useCallback.call(void 0, 
+    (itemId) => removeMutation.mutateAsync(itemId),
+    [removeMutation]
+  );
+  const clear = _react.useCallback.call(void 0, 
+    () => clearMutation.mutateAsync(),
+    [clearMutation]
+  );
+  const applyDiscount = _react.useCallback.call(void 0, 
+    (code) => applyDiscountMutation.mutateAsync(code),
+    [applyDiscountMutation]
+  );
+  const removeDiscount = _react.useCallback.call(void 0, 
+    () => removeDiscountMutation.mutateAsync(),
+    [removeDiscountMutation]
+  );
+  const merge = _react.useCallback.call(void 0, 
+    () => mergeMutation.mutateAsync(),
+    [mergeMutation]
+  );
+  return {
+    cart: _nullishCoalesce(cart, () => ( null)),
+    isLoading,
+    error,
+    // Actions
+    addItem,
+    updateQuantity,
+    removeItem,
+    clear,
+    applyDiscount,
+    removeDiscount,
+    merge,
+    // Computed
+    itemCount: _nullishCoalesce(_optionalChain([cart, 'optionalAccess', _19 => _19.itemCount]), () => ( 0)),
+    isEmpty: !cart || cart.items.length === 0,
+    // Mutation states
+    isAdding: addMutation.isPending,
+    isUpdating: updateMutation.isPending,
+    isRemoving: removeMutation.isPending
+  };
+}
+
+// src/react/hooks/use-cart-count.ts
+
+var CART_KEY2 = ["behio", "cart"];
+function useCartCount() {
+  const { client } = useBehio();
+  const queryClient = _reactquery.useQueryClient.call(void 0, );
+  const cachedCart = queryClient.getQueryData([...CART_KEY2]);
+  const { data } = _reactquery.useQuery.call(void 0, {
+    queryKey: [...CART_KEY2],
+    queryFn: () => client.cart.get(),
+    enabled: !cachedCart && (!!client.getCartSession() || !!client.getAccessToken())
+  });
+  const cart = _nullishCoalesce(cachedCart, () => ( data));
+  return _nullishCoalesce(_optionalChain([cart, 'optionalAccess', _20 => _20.itemCount]), () => ( 0));
+}
+
+// src/react/hooks/use-auth.ts
+
+
+var CUSTOMER_KEY = ["behio", "customer"];
+var CART_KEY3 = ["behio", "cart"];
+function useAuth() {
+  const { client, storage } = useBehio();
+  const queryClient = _reactquery.useQueryClient.call(void 0, );
+  const isLoggedIn = !!client.getAccessToken();
+  const {
+    data: customer,
+    isLoading
+  } = _reactquery.useQuery.call(void 0, {
+    queryKey: [...CUSTOMER_KEY],
+    queryFn: () => client.customer.getProfile(),
+    enabled: isLoggedIn
+  });
+  const persistTokens = _react.useCallback.call(void 0, 
+    (tokens) => {
+      client.setTokens(tokens);
+      storage.set(STORAGE_KEYS.ACCESS_TOKEN, tokens.accessToken);
+      storage.set(STORAGE_KEYS.REFRESH_TOKEN, tokens.refreshToken);
+    },
+    [client, storage]
+  );
+  const clearAuth = _react.useCallback.call(void 0, () => {
+    client.clearTokens();
+    storage.remove(STORAGE_KEYS.ACCESS_TOKEN);
+    storage.remove(STORAGE_KEYS.REFRESH_TOKEN);
+    queryClient.setQueryData([...CUSTOMER_KEY], null);
+    queryClient.invalidateQueries({ queryKey: ["behio", "orders"] });
+    queryClient.invalidateQueries({ queryKey: ["behio", "addresses"] });
+  }, [client, storage, queryClient]);
+  const postAuth = _react.useCallback.call(void 0, async () => {
+    await queryClient.invalidateQueries({ queryKey: [...CUSTOMER_KEY] });
+    if (client.getCartSession()) {
+      try {
+        await client.cart.merge();
+        client.clearCartSession();
+        storage.remove(STORAGE_KEYS.CART_SESSION);
+      } catch (e4) {
+      }
+    }
+    queryClient.invalidateQueries({ queryKey: [...CART_KEY3] });
+  }, [client, storage, queryClient]);
+  const loginMutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: async ({ email, password }) => {
+      return client.auth.login({ email, password });
+    },
+    onSuccess: async (tokens) => {
+      persistTokens(tokens);
+      await postAuth();
+    }
+  });
+  const registerMutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: async (input) => {
+      return client.auth.register(input);
+    },
+    onSuccess: async (tokens) => {
+      persistTokens(tokens);
+      await postAuth();
+    }
+  });
+  const logoutMutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: () => client.auth.logout(),
+    onSettled: () => {
+      clearAuth();
+    }
+  });
+  const forgotPasswordMutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: (email) => client.auth.forgotPassword(email)
+  });
+  const resetPasswordMutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: ({ token, newPassword }) => client.auth.resetPassword(token, newPassword)
+  });
+  const verifyEmailMutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: (token) => client.auth.verifyEmail(token)
+  });
+  const login = _react.useCallback.call(void 0, 
+    (email, password) => loginMutation.mutateAsync({ email, password }).then(() => void 0),
+    [loginMutation]
+  );
+  const register = _react.useCallback.call(void 0, 
+    (input) => registerMutation.mutateAsync(input).then(() => void 0),
+    [registerMutation]
+  );
+  const logout = _react.useCallback.call(void 0, 
+    () => logoutMutation.mutateAsync().then(() => void 0),
+    [logoutMutation]
+  );
+  const forgotPassword = _react.useCallback.call(void 0, 
+    (email) => forgotPasswordMutation.mutateAsync(email).then(() => void 0),
+    [forgotPasswordMutation]
+  );
+  const resetPassword = _react.useCallback.call(void 0, 
+    (token, newPassword) => resetPasswordMutation.mutateAsync({ token, newPassword }).then(() => void 0),
+    [resetPasswordMutation]
+  );
+  const verifyEmail = _react.useCallback.call(void 0, 
+    (token) => verifyEmailMutation.mutateAsync(token).then(() => void 0),
+    [verifyEmailMutation]
+  );
+  return {
+    isLoggedIn,
+    customer: _nullishCoalesce(customer, () => ( null)),
+    isLoading,
+    // Actions
+    login,
+    register,
+    logout,
+    forgotPassword,
+    resetPassword,
+    verifyEmail,
+    // Mutation states
+    isLoggingIn: loginMutation.isPending,
+    isRegistering: registerMutation.isPending,
+    loginError: loginMutation.error,
+    registerError: registerMutation.error
+  };
+}
+
+// src/react/hooks/use-customer.ts
+
+
+var CUSTOMER_KEY2 = ["behio", "customer"];
+function useCustomer() {
+  const { client } = useBehio();
+  const queryClient = _reactquery.useQueryClient.call(void 0, );
+  const {
+    data,
+    isLoading,
+    error
+  } = _reactquery.useQuery.call(void 0, {
+    queryKey: [...CUSTOMER_KEY2],
+    queryFn: () => client.customer.getProfile(),
+    enabled: !!client.getAccessToken()
+  });
+  const updateMutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: (data2) => client.customer.updateProfile(data2),
+    onSuccess: (updated) => {
+      queryClient.setQueryData([...CUSTOMER_KEY2], updated);
+    }
+  });
+  const updateProfile = _react.useCallback.call(void 0, 
+    (profileData) => updateMutation.mutateAsync(profileData),
+    [updateMutation]
+  );
+  return {
+    data: _nullishCoalesce(data, () => ( null)),
+    isLoading,
+    error,
+    updateProfile,
+    isUpdating: updateMutation.isPending
+  };
+}
+
+// src/react/hooks/use-addresses.ts
+
+
+var ADDRESSES_KEY = ["behio", "addresses"];
+function useAddresses() {
+  const { client } = useBehio();
+  const queryClient = _reactquery.useQueryClient.call(void 0, );
+  const {
+    data,
+    isLoading,
+    error
+  } = _reactquery.useQuery.call(void 0, {
+    queryKey: [...ADDRESSES_KEY],
+    queryFn: async () => {
+      const result = await client.customer.getAddresses();
+      return result.items;
+    },
+    enabled: !!client.getAccessToken()
+  });
+  const createMutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: (address) => client.customer.createAddress(address),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: [...ADDRESSES_KEY] });
+    }
+  });
+  const updateMutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: ({ addressId, data: data2 }) => client.customer.updateAddress(addressId, data2),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: [...ADDRESSES_KEY] });
+    }
+  });
+  const deleteMutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: (addressId) => client.customer.deleteAddress(addressId),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: [...ADDRESSES_KEY] });
+    }
+  });
+  const createAddress = _react.useCallback.call(void 0, 
+    (address) => createMutation.mutateAsync(address),
+    [createMutation]
+  );
+  const updateAddress = _react.useCallback.call(void 0, 
+    (addressId, addressData) => updateMutation.mutateAsync({ addressId, data: addressData }),
+    [updateMutation]
+  );
+  const deleteAddress = _react.useCallback.call(void 0, 
+    (addressId) => deleteMutation.mutateAsync(addressId),
+    [deleteMutation]
+  );
+  return {
+    addresses: _nullishCoalesce(data, () => ( [])),
+    isLoading,
+    error,
+    createAddress,
+    updateAddress,
+    deleteAddress,
+    isCreating: createMutation.isPending,
+    isDeleting: deleteMutation.isPending
+  };
+}
+
+// src/react/hooks/use-orders.ts
+
+function useOrders(options) {
+  const { client } = useBehio();
+  return _reactquery.useQuery.call(void 0, {
+    queryKey: ["behio", "orders", _optionalChain([options, 'optionalAccess', _21 => _21.page]), _optionalChain([options, 'optionalAccess', _22 => _22.limit])],
+    queryFn: () => client.orders.list({
+      page: _optionalChain([options, 'optionalAccess', _23 => _23.page]),
+      limit: _optionalChain([options, 'optionalAccess', _24 => _24.limit])
+    }),
+    enabled: (_nullishCoalesce(_optionalChain([options, 'optionalAccess', _25 => _25.enabled]), () => ( true))) && !!client.getAccessToken()
+  });
+}
+
+// src/react/hooks/use-order.ts
+
+
+function useOrder(orderNumber) {
+  const { client } = useBehio();
+  const queryClient = _reactquery.useQueryClient.call(void 0, );
+  const {
+    data,
+    isLoading,
+    error
+  } = _reactquery.useQuery.call(void 0, {
+    queryKey: ["behio", "order", orderNumber],
+    queryFn: () => client.orders.get(orderNumber),
+    enabled: !!orderNumber && !!client.getAccessToken()
+  });
+  const cancelMutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: () => client.orders.cancel(orderNumber),
+    onSuccess: (updated) => {
+      queryClient.setQueryData(["behio", "order", orderNumber], updated);
+      queryClient.invalidateQueries({ queryKey: ["behio", "orders"] });
+    }
+  });
+  const cancel = _react.useCallback.call(void 0, 
+    () => cancelMutation.mutateAsync(),
+    [cancelMutation]
+  );
+  return {
+    data: _nullishCoalesce(data, () => ( null)),
+    isLoading,
+    error,
+    cancel,
+    isCancelling: cancelMutation.isPending
+  };
+}
+
+// src/react/hooks/use-checkout.ts
+
+
+function useCheckout() {
+  const { client, storage } = useBehio();
+  const queryClient = _reactquery.useQueryClient.call(void 0, );
+  const [order, setOrder] = _react.useState.call(void 0, null);
+  const mutation = _reactquery.useMutation.call(void 0, {
+    mutationFn: (input) => client.checkout.createOrder(input),
+    onSuccess: (result) => {
+      setOrder(result);
+      storage.remove(STORAGE_KEYS.CART_SESSION);
+      queryClient.invalidateQueries({ queryKey: ["behio", "cart"] });
+      queryClient.invalidateQueries({ queryKey: ["behio", "orders"] });
+    }
+  });
+  const createOrder = _react.useCallback.call(void 0, 
+    (input) => mutation.mutateAsync(input),
+    [mutation]
+  );
+  const reset = _react.useCallback.call(void 0, () => {
+    setOrder(null);
+    mutation.reset();
+  }, [mutation]);
+  return {
+    createOrder,
+    isCreating: mutation.isPending,
+    error: mutation.error,
+    order,
+    reset
+  };
+}
+
+// src/react/hooks/use-pages.ts
+
+function usePages(locale) {
+  const { client } = useBehio();
+  return _reactquery.useQuery.call(void 0, {
+    queryKey: ["behio", "pages", locale],
+    queryFn: async () => {
+      const result = await client.pages.list(locale);
+      return result.pages;
+    }
+  });
+}
+function usePage(slug, locale) {
+  const { client } = useBehio();
+  return _reactquery.useQuery.call(void 0, {
+    queryKey: ["behio", "page", slug, locale],
+    queryFn: () => client.pages.get(slug, locale),
+    enabled: !!slug
+  });
+}
+
+// src/react/hooks/use-shop-info.ts
+
+function useShopInfo() {
+  const { client } = useBehio();
+  return _reactquery.useQuery.call(void 0, {
+    queryKey: ["behio", "shop-info"],
+    queryFn: () => client.getShopInfo()
+  });
+}
+
+// src/react/utils/format-price.ts
+function formatPrice(amount, currency, locale) {
+  const resolvedLocale = _nullishCoalesce(locale, () => ( "cs"));
+  try {
+    return new Intl.NumberFormat(resolvedLocale, {
+      style: "currency",
+      currency,
+      minimumFractionDigits: Number.isInteger(amount) ? 0 : 2,
+      maximumFractionDigits: 2
+    }).format(amount);
+  } catch (e5) {
+    return `${amount} ${currency}`;
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.BehioProvider = BehioProvider; exports.cookieStorage = cookieStorage; exports.createMemoryStorage = createMemoryStorage; exports.detectStorage = detectStorage; exports.formatPrice = formatPrice; exports.localStorageAdapter = localStorageAdapter; exports.memoryStorage = memoryStorage; exports.useAddresses = useAddresses; exports.useAuth = useAuth; exports.useBehio = useBehio; exports.useCart = useCart; exports.useCartCount = useCartCount; exports.useCategories = useCategories; exports.useCheckout = useCheckout; exports.useCustomer = useCustomer; exports.useFeatured = useFeatured; exports.useFilters = useFilters; exports.useLabels = useLabels; exports.useOrder = useOrder; exports.useOrders = useOrders; exports.usePage = usePage; exports.usePages = usePages; exports.useProduct = useProduct; exports.useProducts = useProducts; exports.useSearch = useSearch; exports.useShopInfo = useShopInfo;