@diffsome/react 1.1.0

package/dist/index.mjs

@@ -0,0 +1,2255 @@
+// src/context/DiffsomeContext.tsx
+import { createContext, useContext, useState, useEffect, useMemo } from "react";
+import { Diffsome } from "@diffsome/sdk";
+import { jsx } from "react/jsx-runtime";
+var DiffsomeContext = createContext(null);
+function DiffsomeProvider({ children, config }) {
+  const [isReady, setIsReady] = useState(false);
+  const client = useMemo(() => {
+    return new Diffsome({
+      ...config,
+      persistToken: config.persistToken ?? true,
+      storageType: config.storageType ?? "localStorage"
+    });
+  }, [config.tenantId, config.baseUrl, config.apiKey]);
+  useEffect(() => {
+    setIsReady(true);
+  }, []);
+  const value = useMemo(() => ({
+    client,
+    isReady
+  }), [client, isReady]);
+  return /* @__PURE__ */ jsx(DiffsomeContext.Provider, { value, children });
+}
+function useDiffsome() {
+  const context = useContext(DiffsomeContext);
+  if (!context) {
+    throw new Error("useDiffsome must be used within DiffsomeProvider");
+  }
+  return context;
+}
+function useClient() {
+  const { client } = useDiffsome();
+  return client;
+}
+
+// src/hooks/useAuth.ts
+import { useState as useState2, useEffect as useEffect2, useCallback as useCallback2 } from "react";
+function useAuth() {
+  const client = useClient();
+  const [user, setUser] = useState2(null);
+  const [loading, setLoading] = useState2(true);
+  const [error, setError] = useState2(null);
+  const isAuthenticated = !!user && client.isAuthenticated();
+  const fetchProfile = useCallback2(async () => {
+    if (!client.isAuthenticated()) {
+      setUser(null);
+      setLoading(false);
+      return;
+    }
+    try {
+      const profile = await client.auth.me();
+      setUser(profile);
+      setError(null);
+    } catch (err) {
+      setUser(null);
+      setError(err instanceof Error ? err : new Error("Failed to fetch profile"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  useEffect2(() => {
+    fetchProfile();
+  }, [fetchProfile]);
+  const login = useCallback2(async (credentials) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.auth.login(credentials);
+      setUser(response.user);
+      return response;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Login failed");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  const register = useCallback2(async (data) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.auth.register(data);
+      setUser(response.user);
+      return response;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Registration failed");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  const logout = useCallback2(async () => {
+    setLoading(true);
+    try {
+      await client.auth.logout();
+    } finally {
+      setUser(null);
+      setLoading(false);
+    }
+  }, [client]);
+  const getProfile = useCallback2(async () => {
+    const profile = await client.auth.me();
+    setUser(profile);
+    return profile;
+  }, [client]);
+  const updateProfile = useCallback2(async (data) => {
+    const profile = await client.auth.updateProfile(data);
+    setUser(profile);
+    return profile;
+  }, [client]);
+  const forgotPassword = useCallback2(async (email) => {
+    return await client.auth.forgotPassword({ email });
+  }, [client]);
+  const resetPassword = useCallback2(async (data) => {
+    return await client.auth.resetPassword(data);
+  }, [client]);
+  const refresh = useCallback2(async () => {
+    await fetchProfile();
+  }, [fetchProfile]);
+  return {
+    user,
+    isAuthenticated,
+    loading,
+    error,
+    login,
+    register,
+    logout,
+    getProfile,
+    updateProfile,
+    forgotPassword,
+    resetPassword,
+    refresh
+  };
+}
+
+// src/hooks/useSocialAuth.ts
+import { useState as useState3, useEffect as useEffect3, useCallback as useCallback3 } from "react";
+function useSocialAuth() {
+  const client = useClient();
+  const [providers, setProviders] = useState3([]);
+  const [loading, setLoading] = useState3(true);
+  const [error, setError] = useState3(null);
+  const fetchProviders = useCallback3(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.auth.getSocialProviders();
+      setProviders(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch providers"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  useEffect3(() => {
+    fetchProviders();
+  }, [fetchProviders]);
+  const getAuthUrl = useCallback3(async (provider) => {
+    const result = await client.auth.getSocialAuthUrl(provider);
+    return result.url;
+  }, [client]);
+  const handleCallback = useCallback3(async (provider, code) => {
+    return await client.auth.socialCallback(provider, code);
+  }, [client]);
+  return {
+    providers,
+    loading,
+    error,
+    getAuthUrl,
+    handleCallback,
+    refresh: fetchProviders
+  };
+}
+
+// src/hooks/useCart.ts
+import { useState as useState4, useEffect as useEffect4, useCallback as useCallback4 } from "react";
+function useCart() {
+  const client = useClient();
+  const [cart, setCart] = useState4(null);
+  const [loading, setLoading] = useState4(true);
+  const [error, setError] = useState4(null);
+  const fetchCart = useCallback4(async () => {
+    try {
+      const cartData = await client.shop.getCart();
+      setCart(cartData);
+      setError(null);
+    } catch (err) {
+      setCart(null);
+      setError(err instanceof Error ? err : new Error("Failed to fetch cart"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  useEffect4(() => {
+    fetchCart();
+  }, [fetchCart]);
+  const addToCart = useCallback4(async (productId, quantity = 1, variantId, options) => {
+    const data = {
+      product_id: productId,
+      quantity,
+      variant_id: variantId,
+      options
+    };
+    const updatedCart = await client.shop.addToCart(data);
+    setCart(updatedCart);
+    return updatedCart;
+  }, [client]);
+  const updateItem = useCallback4(async (itemId, quantity) => {
+    const updatedCart = await client.shop.updateCartItem(itemId, { quantity });
+    setCart(updatedCart);
+    return updatedCart;
+  }, [client]);
+  const removeItem = useCallback4(async (itemId) => {
+    const updatedCart = await client.shop.removeFromCart(itemId);
+    setCart(updatedCart);
+    return updatedCart;
+  }, [client]);
+  const clearCart = useCallback4(async () => {
+    await client.shop.clearCart();
+    setCart(null);
+  }, [client]);
+  const refresh = useCallback4(async () => {
+    setLoading(true);
+    await fetchCart();
+  }, [fetchCart]);
+  const isInCart = useCallback4((productId, variantId) => {
+    if (!cart?.items) return false;
+    return cart.items.some(
+      (item) => item.product_id === productId && (variantId === void 0 || item.variant_id === variantId)
+    );
+  }, [cart]);
+  const getItemQuantity = useCallback4((productId, variantId) => {
+    if (!cart?.items) return 0;
+    const item = cart.items.find(
+      (item2) => item2.product_id === productId && (variantId === void 0 || item2.variant_id === variantId)
+    );
+    return item?.quantity ?? 0;
+  }, [cart]);
+  return {
+    cart,
+    items: cart?.items ?? [],
+    itemCount: cart?.item_count ?? 0,
+    totalQuantity: cart?.total_quantity ?? 0,
+    subtotal: cart?.subtotal ?? 0,
+    shippingFee: cart?.shipping_fee ?? 0,
+    total: cart?.total ?? 0,
+    loading,
+    error,
+    addToCart,
+    updateItem,
+    removeItem,
+    clearCart,
+    refresh,
+    isInCart,
+    getItemQuantity
+  };
+}
+
+// src/hooks/useWishlist.ts
+import { useState as useState5, useEffect as useEffect5, useCallback as useCallback5 } from "react";
+function useWishlist() {
+  const client = useClient();
+  const [items, setItems] = useState5([]);
+  const [loading, setLoading] = useState5(true);
+  const [error, setError] = useState5(null);
+  const [wishlistMap, setWishlistMap] = useState5({});
+  const fetchWishlist = useCallback5(async () => {
+    if (!client.isAuthenticated()) {
+      setItems([]);
+      setWishlistMap({});
+      setLoading(false);
+      return;
+    }
+    try {
+      const response = await client.shop.getWishlist({ per_page: 100 });
+      setItems(response.data);
+      const map = {};
+      response.data.forEach((item) => {
+        const key = item.variant_id ? `${item.product_id}_${item.variant_id}` : String(item.product_id);
+        map[key] = true;
+      });
+      setWishlistMap(map);
+      setError(null);
+    } catch (err) {
+      setItems([]);
+      setWishlistMap({});
+      setError(err instanceof Error ? err : new Error("Failed to fetch wishlist"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  useEffect5(() => {
+    fetchWishlist();
+  }, [fetchWishlist]);
+  const isInWishlist = useCallback5((productId, variantId) => {
+    const key = variantId ? `${productId}_${variantId}` : String(productId);
+    return wishlistMap[key] || false;
+  }, [wishlistMap]);
+  const toggleWishlist = useCallback5(async (productId, variantId) => {
+    const result = await client.shop.toggleWishlist(productId, variantId);
+    const key = variantId ? `${productId}_${variantId}` : String(productId);
+    setWishlistMap((prev) => ({
+      ...prev,
+      [key]: result.in_wishlist
+    }));
+    if (result.action === "added") {
+      await fetchWishlist();
+    } else {
+      setItems((prev) => prev.filter(
+        (item) => !(item.product_id === productId && item.variant_id === variantId)
+      ));
+    }
+    return result;
+  }, [client, fetchWishlist]);
+  const addToWishlist = useCallback5(async (productId, variantId, note) => {
+    const item = await client.shop.addToWishlist({
+      product_id: productId,
+      variant_id: variantId,
+      note
+    });
+    await fetchWishlist();
+    return item;
+  }, [client, fetchWishlist]);
+  const removeFromWishlist = useCallback5(async (wishlistId) => {
+    const item = items.find((i) => i.id === wishlistId);
+    await client.shop.removeFromWishlist(wishlistId);
+    if (item) {
+      const key = item.variant_id ? `${item.product_id}_${item.variant_id}` : String(item.product_id);
+      setWishlistMap((prev) => {
+        const next = { ...prev };
+        delete next[key];
+        return next;
+      });
+    }
+    setItems((prev) => prev.filter((i) => i.id !== wishlistId));
+  }, [client, items]);
+  const moveToCart = useCallback5(async (wishlistIds) => {
+    const result = await client.shop.moveWishlistToCart(wishlistIds);
+    await fetchWishlist();
+    return result;
+  }, [client, fetchWishlist]);
+  const updateNote = useCallback5(async (wishlistId, note) => {
+    const item = await client.shop.updateWishlistNote(wishlistId, note);
+    setItems((prev) => prev.map((i) => i.id === wishlistId ? item : i));
+    return item;
+  }, [client]);
+  const getProductWishlistCount = useCallback5(async (productSlug) => {
+    return await client.shop.getProductWishlistCount(productSlug);
+  }, [client]);
+  const refresh = useCallback5(async () => {
+    setLoading(true);
+    await fetchWishlist();
+  }, [fetchWishlist]);
+  return {
+    items,
+    count: items.length,
+    loading,
+    error,
+    isInWishlist,
+    toggleWishlist,
+    addToWishlist,
+    removeFromWishlist,
+    moveToCart,
+    updateNote,
+    getProductWishlistCount,
+    refresh
+  };
+}
+
+// src/hooks/useProducts.ts
+import { useState as useState6, useEffect as useEffect6, useCallback as useCallback6 } from "react";
+function useProducts(options = {}) {
+  const { autoFetch = true, ...params } = options;
+  const client = useClient();
+  const [products, setProducts] = useState6([]);
+  const [meta, setMeta] = useState6(null);
+  const [loading, setLoading] = useState6(autoFetch);
+  const [error, setError] = useState6(null);
+  const [currentParams, setCurrentParams] = useState6(params);
+  const fetchProducts = useCallback6(async (fetchParams, append = false) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.shop.listProducts(fetchParams);
+      if (append) {
+        setProducts((prev) => [...prev, ...response.data]);
+      } else {
+        setProducts(response.data);
+      }
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch products"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  useEffect6(() => {
+    if (autoFetch) {
+      fetchProducts(params);
+    }
+  }, []);
+  const hasMore = meta ? meta.current_page < meta.last_page : false;
+  const loadMore = useCallback6(async () => {
+    if (!hasMore || loading) return;
+    const nextPage = (meta?.current_page ?? 0) + 1;
+    await fetchProducts({ ...currentParams, page: nextPage }, true);
+  }, [hasMore, loading, meta, currentParams, fetchProducts]);
+  const refresh = useCallback6(async () => {
+    setCurrentParams(params);
+    await fetchProducts(params);
+  }, [params, fetchProducts]);
+  const search = useCallback6(async (query) => {
+    const searchParams = { ...params, search: query, page: 1 };
+    setCurrentParams(searchParams);
+    await fetchProducts(searchParams);
+  }, [params, fetchProducts]);
+  return {
+    products,
+    meta,
+    loading,
+    error,
+    hasMore,
+    loadMore,
+    refresh,
+    search
+  };
+}
+function useProduct(idOrSlug) {
+  const client = useClient();
+  const [product, setProduct] = useState6(null);
+  const [loading, setLoading] = useState6(true);
+  const [error, setError] = useState6(null);
+  const fetchProduct = useCallback6(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.shop.getProduct(idOrSlug);
+      setProduct(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch product"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, idOrSlug]);
+  useEffect6(() => {
+    fetchProduct();
+  }, [fetchProduct]);
+  return {
+    product,
+    loading,
+    error,
+    refresh: fetchProduct
+  };
+}
+function useCategories() {
+  const client = useClient();
+  const [categories, setCategories] = useState6([]);
+  const [loading, setLoading] = useState6(true);
+  const [error, setError] = useState6(null);
+  const fetchCategories = useCallback6(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.shop.listCategories();
+      setCategories(response.data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch categories"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  useEffect6(() => {
+    fetchCategories();
+  }, [fetchCategories]);
+  return {
+    categories,
+    loading,
+    error,
+    refresh: fetchCategories
+  };
+}
+function useFeaturedProducts(limit = 8) {
+  const client = useClient();
+  const [products, setProducts] = useState6([]);
+  const [loading, setLoading] = useState6(true);
+  const [error, setError] = useState6(null);
+  const fetchProducts = useCallback6(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.shop.featuredProducts(limit);
+      setProducts(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch featured products"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, limit]);
+  useEffect6(() => {
+    fetchProducts();
+  }, [fetchProducts]);
+  return {
+    products,
+    loading,
+    error,
+    refresh: fetchProducts
+  };
+}
+function useProductsByType(type, params) {
+  const client = useClient();
+  const [products, setProducts] = useState6([]);
+  const [meta, setMeta] = useState6(null);
+  const [loading, setLoading] = useState6(true);
+  const [error, setError] = useState6(null);
+  const fetchProducts = useCallback6(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.shop.listProductsByType(type, params);
+      setProducts(response.data);
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch products"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, type, params]);
+  useEffect6(() => {
+    fetchProducts();
+  }, [fetchProducts]);
+  return {
+    products,
+    meta,
+    loading,
+    error,
+    refresh: fetchProducts
+  };
+}
+function useDigitalProducts(params) {
+  return useProductsByType("digital", params);
+}
+function useSubscriptionProducts(params) {
+  return useProductsByType("subscription", params);
+}
+function useBundleProducts(params) {
+  return useProductsByType("bundle", params);
+}
+function useBundleItems(productSlug) {
+  const client = useClient();
+  const [bundle, setBundle] = useState6(null);
+  const [loading, setLoading] = useState6(true);
+  const [error, setError] = useState6(null);
+  const fetchBundle = useCallback6(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.shop.getBundleItems(productSlug);
+      setBundle(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch bundle items"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, productSlug]);
+  useEffect6(() => {
+    fetchBundle();
+  }, [fetchBundle]);
+  return {
+    bundle,
+    loading,
+    error,
+    refresh: fetchBundle
+  };
+}
+
+// src/hooks/useOrders.ts
+import { useState as useState7, useEffect as useEffect7, useCallback as useCallback7 } from "react";
+function useOrders(params) {
+  const client = useClient();
+  const [orders, setOrders] = useState7([]);
+  const [meta, setMeta] = useState7(null);
+  const [loading, setLoading] = useState7(true);
+  const [error, setError] = useState7(null);
+  const fetchOrders = useCallback7(async (fetchParams, append = false) => {
+    if (!client.isAuthenticated()) {
+      setOrders([]);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.shop.listOrders(fetchParams);
+      if (append) {
+        setOrders((prev) => [...prev, ...response.data]);
+      } else {
+        setOrders(response.data);
+      }
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch orders"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  useEffect7(() => {
+    fetchOrders(params);
+  }, []);
+  const hasMore = meta ? meta.current_page < meta.last_page : false;
+  const loadMore = useCallback7(async () => {
+    if (!hasMore || loading) return;
+    const nextPage = (meta?.current_page ?? 0) + 1;
+    await fetchOrders({ ...params, page: nextPage }, true);
+  }, [hasMore, loading, meta, params, fetchOrders]);
+  const refresh = useCallback7(async () => {
+    await fetchOrders(params);
+  }, [params, fetchOrders]);
+  return {
+    orders,
+    meta,
+    loading,
+    error,
+    hasMore,
+    loadMore,
+    refresh
+  };
+}
+function useOrder(idOrNumber) {
+  const client = useClient();
+  const [order, setOrder] = useState7(null);
+  const [loading, setLoading] = useState7(true);
+  const [error, setError] = useState7(null);
+  const fetchOrder = useCallback7(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.shop.getOrder(idOrNumber);
+      setOrder(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch order"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, idOrNumber]);
+  useEffect7(() => {
+    fetchOrder();
+  }, [fetchOrder]);
+  const cancel = useCallback7(async () => {
+    if (!order) throw new Error("Order not loaded");
+    const cancelled = await client.shop.cancelOrder(order.id);
+    setOrder(cancelled);
+    return cancelled;
+  }, [client, order]);
+  return {
+    order,
+    loading,
+    error,
+    cancel,
+    refresh: fetchOrder
+  };
+}
+function useCreateOrder() {
+  const client = useClient();
+  const [loading, setLoading] = useState7(false);
+  const [error, setError] = useState7(null);
+  const createOrder = useCallback7(async (data) => {
+    setLoading(true);
+    setError(null);
+    try {
+      return await client.shop.createOrder(data);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to create order");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  return {
+    createOrder,
+    loading,
+    error
+  };
+}
+
+// src/hooks/usePayment.ts
+import { useState as useState8, useCallback as useCallback8 } from "react";
+function usePaymentStatus() {
+  const client = useClient();
+  const [status, setStatus] = useState8(null);
+  const [loading, setLoading] = useState8(true);
+  const [error, setError] = useState8(null);
+  const fetchStatus = useCallback8(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.shop.getPaymentStatus();
+      setStatus(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch payment status"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  return {
+    status,
+    loading,
+    error,
+    refresh: fetchStatus,
+    isTossAvailable: status?.toss?.available ?? false,
+    isStripeAvailable: status?.stripe?.available ?? false,
+    stripePublishableKey: status?.stripe?.publishable_key ?? null
+  };
+}
+function useTossPayment() {
+  const client = useClient();
+  const [loading, setLoading] = useState8(false);
+  const [error, setError] = useState8(null);
+  const preparePayment = useCallback8(async (orderNumber, successUrl, failUrl) => {
+    setLoading(true);
+    setError(null);
+    try {
+      return await client.shop.tossPaymentReady({
+        order_number: orderNumber,
+        success_url: successUrl,
+        fail_url: failUrl
+      });
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to prepare payment");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  const confirmPayment = useCallback8(async (paymentKey, orderId, amount) => {
+    setLoading(true);
+    setError(null);
+    try {
+      return await client.shop.tossPaymentConfirm({
+        payment_key: paymentKey,
+        order_id: orderId,
+        amount
+      });
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to confirm payment");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  const cancelPayment = useCallback8(async (orderNumber, reason, amount) => {
+    setLoading(true);
+    setError(null);
+    try {
+      await client.shop.tossPaymentCancel(orderNumber, reason, amount);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to cancel payment");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  return {
+    preparePayment,
+    confirmPayment,
+    cancelPayment,
+    loading,
+    error
+  };
+}
+function useStripePayment() {
+  const client = useClient();
+  const [loading, setLoading] = useState8(false);
+  const [error, setError] = useState8(null);
+  const createCheckout = useCallback8(async (orderNumber, successUrl, cancelUrl) => {
+    setLoading(true);
+    setError(null);
+    try {
+      return await client.shop.stripeCheckout({
+        order_number: orderNumber,
+        success_url: successUrl,
+        cancel_url: cancelUrl
+      });
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to create checkout");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  const verifyPayment = useCallback8(async (sessionId) => {
+    setLoading(true);
+    setError(null);
+    try {
+      return await client.shop.stripeVerify({ session_id: sessionId });
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to verify payment");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  const refund = useCallback8(async (orderNumber, reason, amount) => {
+    setLoading(true);
+    setError(null);
+    try {
+      await client.shop.stripeRefund(orderNumber, reason, amount);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to refund");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  return {
+    createCheckout,
+    verifyPayment,
+    refund,
+    loading,
+    error
+  };
+}
+
+// src/hooks/useCoupons.ts
+import { useState as useState9, useEffect as useEffect8, useCallback as useCallback9 } from "react";
+function useCoupons() {
+  const client = useClient();
+  const [coupons, setCoupons] = useState9([]);
+  const [loading, setLoading] = useState9(true);
+  const [error, setError] = useState9(null);
+  const fetchCoupons = useCallback9(async () => {
+    if (!client.isAuthenticated()) {
+      setCoupons([]);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.shop.myCoupons();
+      setCoupons(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch coupons"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  useEffect8(() => {
+    fetchCoupons();
+  }, [fetchCoupons]);
+  return {
+    coupons,
+    loading,
+    error,
+    refresh: fetchCoupons
+  };
+}
+function useValidateCoupon() {
+  const client = useClient();
+  const [validation, setValidation] = useState9(null);
+  const [loading, setLoading] = useState9(false);
+  const [error, setError] = useState9(null);
+  const validate = useCallback9(async (code, orderAmount) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await client.shop.validateCoupon(code, orderAmount);
+      setValidation(result);
+      return result;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to validate coupon");
+      setError(error2);
+      setValidation({ valid: false, message: error2.message });
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  const reset = useCallback9(() => {
+    setValidation(null);
+    setError(null);
+  }, []);
+  return {
+    validate,
+    validation,
+    loading,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useSubscriptions.ts
+import { useState as useState10, useEffect as useEffect9, useCallback as useCallback10 } from "react";
+function useSubscriptions() {
+  const client = useClient();
+  const [subscriptions, setSubscriptions] = useState10([]);
+  const [loading, setLoading] = useState10(true);
+  const [error, setError] = useState10(null);
+  const fetchSubscriptions = useCallback10(async () => {
+    if (!client.isAuthenticated()) {
+      setSubscriptions([]);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.shop.getSubscriptions();
+      setSubscriptions(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch subscriptions"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  useEffect9(() => {
+    fetchSubscriptions();
+  }, [fetchSubscriptions]);
+  const activeSubscription = subscriptions.find((s) => s.is_active) ?? null;
+  const hasActiveSubscription = !!activeSubscription;
+  return {
+    subscriptions,
+    loading,
+    error,
+    activeSubscription,
+    hasActiveSubscription,
+    refresh: fetchSubscriptions
+  };
+}
+function useSubscription(id) {
+  const client = useClient();
+  const [subscription, setSubscription] = useState10(null);
+  const [loading, setLoading] = useState10(true);
+  const [error, setError] = useState10(null);
+  const fetchSubscription = useCallback10(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.shop.getSubscription(id);
+      setSubscription(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch subscription"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, id]);
+  useEffect9(() => {
+    fetchSubscription();
+  }, [fetchSubscription]);
+  const cancel = useCallback10(async (immediately = false) => {
+    const updated = await client.shop.cancelSubscription(id, immediately);
+    setSubscription(updated);
+    return updated;
+  }, [client, id]);
+  const pause = useCallback10(async () => {
+    const updated = await client.shop.pauseSubscription(id);
+    setSubscription(updated);
+    return updated;
+  }, [client, id]);
+  const resume = useCallback10(async () => {
+    const updated = await client.shop.resumeSubscription(id);
+    setSubscription(updated);
+    return updated;
+  }, [client, id]);
+  return {
+    subscription,
+    loading,
+    error,
+    cancel,
+    pause,
+    resume,
+    refresh: fetchSubscription
+  };
+}
+function useCreateSubscription() {
+  const client = useClient();
+  const [loading, setLoading] = useState10(false);
+  const [error, setError] = useState10(null);
+  const createCheckout = useCallback10(async (planId, successUrl, cancelUrl) => {
+    setLoading(true);
+    setError(null);
+    try {
+      return await client.shop.createSubscriptionCheckout({
+        plan_id: planId,
+        success_url: successUrl,
+        cancel_url: cancelUrl
+      });
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to create checkout");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  const verifyCheckout = useCallback10(async (sessionId) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await client.shop.verifySubscriptionCheckout(sessionId);
+      return result.subscription;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to verify checkout");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  const createSetupIntent = useCallback10(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await client.shop.createSetupIntent();
+      return result.client_secret;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to create setup intent");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  return {
+    createCheckout,
+    verifyCheckout,
+    createSetupIntent,
+    loading,
+    error
+  };
+}
+
+// src/hooks/useDownloads.ts
+import { useState as useState11, useEffect as useEffect10, useCallback as useCallback11 } from "react";
+function useDownloads() {
+  const client = useClient();
+  const [downloads, setDownloads] = useState11([]);
+  const [loading, setLoading] = useState11(true);
+  const [error, setError] = useState11(null);
+  const fetchDownloads = useCallback11(async () => {
+    if (!client.isAuthenticated()) {
+      setDownloads([]);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.shop.getMyDownloads();
+      setDownloads(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch downloads"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  useEffect10(() => {
+    fetchDownloads();
+  }, [fetchDownloads]);
+  const getDownloadUrl = useCallback11((token) => {
+    return client.shop.getDownloadUrl(token);
+  }, [client]);
+  const getDownloadInfo = useCallback11(async (token) => {
+    return await client.shop.getDownloadInfo(token);
+  }, [client]);
+  return {
+    downloads,
+    loading,
+    error,
+    getDownloadUrl,
+    getDownloadInfo,
+    refresh: fetchDownloads
+  };
+}
+function useOrderDownloads(orderNumber) {
+  const client = useClient();
+  const [downloads, setDownloads] = useState11([]);
+  const [loading, setLoading] = useState11(true);
+  const [error, setError] = useState11(null);
+  const fetchDownloads = useCallback11(async () => {
+    if (!client.isAuthenticated()) {
+      setDownloads([]);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.shop.getOrderDownloads(orderNumber);
+      setDownloads(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch downloads"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, orderNumber]);
+  useEffect10(() => {
+    fetchDownloads();
+  }, [fetchDownloads]);
+  const getDownloadUrl = useCallback11((token) => {
+    return client.shop.getDownloadUrl(token);
+  }, [client]);
+  const getDownloadInfo = useCallback11(async (token) => {
+    return await client.shop.getDownloadInfo(token);
+  }, [client]);
+  return {
+    downloads,
+    loading,
+    error,
+    getDownloadUrl,
+    getDownloadInfo,
+    refresh: fetchDownloads
+  };
+}
+
+// src/hooks/useReviews.ts
+import { useState as useState12, useEffect as useEffect11, useCallback as useCallback12 } from "react";
+function useProductReviews(productSlug, params) {
+  const client = useClient();
+  const [reviews, setReviews] = useState12([]);
+  const [stats, setStats] = useState12(null);
+  const [meta, setMeta] = useState12(null);
+  const [loading, setLoading] = useState12(true);
+  const [error, setError] = useState12(null);
+  const fetchReviews = useCallback12(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.shop.getProductReviews(productSlug, params);
+      setReviews(response.data);
+      setStats(response.stats);
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch reviews"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, productSlug, params]);
+  useEffect11(() => {
+    fetchReviews();
+  }, [fetchReviews]);
+  return {
+    reviews,
+    stats,
+    meta,
+    loading,
+    error,
+    refresh: fetchReviews
+  };
+}
+function useCanReview(productSlug) {
+  const client = useClient();
+  const [canReview, setCanReview] = useState12(false);
+  const [reason, setReason] = useState12(null);
+  const [loading, setLoading] = useState12(true);
+  const [error, setError] = useState12(null);
+  const check = useCallback12(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.shop.canReviewProduct(productSlug);
+      setCanReview(response.can_review);
+      setReason(response.reason ?? null);
+      return response;
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to check review eligibility"));
+      return { can_review: false, reason: "not_logged_in" };
+    } finally {
+      setLoading(false);
+    }
+  }, [client, productSlug]);
+  useEffect11(() => {
+    if (client.isAuthenticated()) {
+      check();
+    } else {
+      setCanReview(false);
+      setReason("not_logged_in");
+      setLoading(false);
+    }
+  }, [check, client]);
+  return {
+    canReview,
+    reason,
+    loading,
+    error,
+    check
+  };
+}
+function useCreateReview() {
+  const client = useClient();
+  const [loading, setLoading] = useState12(false);
+  const [error, setError] = useState12(null);
+  const createReview = useCallback12(async (productSlug, data) => {
+    setLoading(true);
+    setError(null);
+    try {
+      return await client.shop.createReview(productSlug, data);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to create review");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  return {
+    createReview,
+    loading,
+    error
+  };
+}
+function useMyReviews(params) {
+  const client = useClient();
+  const [reviews, setReviews] = useState12([]);
+  const [meta, setMeta] = useState12(null);
+  const [loading, setLoading] = useState12(true);
+  const [error, setError] = useState12(null);
+  const fetchReviews = useCallback12(async () => {
+    if (!client.isAuthenticated()) {
+      setReviews([]);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.shop.myReviews(params);
+      setReviews(response.data);
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch reviews"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, params]);
+  useEffect11(() => {
+    fetchReviews();
+  }, [fetchReviews]);
+  const deleteReview = useCallback12(async (reviewId) => {
+    await client.shop.deleteReview(reviewId);
+    setReviews((prev) => prev.filter((r) => r.id !== reviewId));
+  }, [client]);
+  const updateReview = useCallback12(async (reviewId, data) => {
+    const updated = await client.shop.updateReview(reviewId, data);
+    setReviews((prev) => prev.map((r) => r.id === reviewId ? updated : r));
+    return updated;
+  }, [client]);
+  return {
+    reviews,
+    meta,
+    loading,
+    error,
+    refresh: fetchReviews,
+    deleteReview,
+    updateReview
+  };
+}
+
+// src/hooks/useBlog.ts
+import { useState as useState13, useEffect as useEffect12, useCallback as useCallback13 } from "react";
+function useBlog(options = {}) {
+  const { autoFetch = true, ...params } = options;
+  const client = useClient();
+  const [posts, setPosts] = useState13([]);
+  const [meta, setMeta] = useState13(null);
+  const [loading, setLoading] = useState13(autoFetch);
+  const [error, setError] = useState13(null);
+  const [currentParams, setCurrentParams] = useState13(params);
+  const fetchPosts = useCallback13(async (fetchParams, append = false) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.blog.list(fetchParams);
+      if (append) {
+        setPosts((prev) => [...prev, ...response.data]);
+      } else {
+        setPosts(response.data);
+      }
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch blog posts"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  useEffect12(() => {
+    if (autoFetch) {
+      fetchPosts(params);
+    }
+  }, []);
+  const hasMore = meta ? meta.current_page < meta.last_page : false;
+  const loadMore = useCallback13(async () => {
+    if (!hasMore || loading) return;
+    const nextPage = (meta?.current_page ?? 0) + 1;
+    await fetchPosts({ ...currentParams, page: nextPage }, true);
+  }, [hasMore, loading, meta, currentParams, fetchPosts]);
+  const refresh = useCallback13(async () => {
+    setCurrentParams(params);
+    await fetchPosts(params);
+  }, [params, fetchPosts]);
+  return {
+    posts,
+    meta,
+    loading,
+    error,
+    hasMore,
+    loadMore,
+    refresh
+  };
+}
+function useBlogPost(slug) {
+  const client = useClient();
+  const [post, setPost] = useState13(null);
+  const [loading, setLoading] = useState13(true);
+  const [error, setError] = useState13(null);
+  const fetchPost = useCallback13(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.blog.get(slug);
+      setPost(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch blog post"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, slug]);
+  useEffect12(() => {
+    fetchPost();
+  }, [fetchPost]);
+  return {
+    post,
+    loading,
+    error,
+    refresh: fetchPost
+  };
+}
+function useBlogCategories() {
+  const client = useClient();
+  const [categories, setCategories] = useState13([]);
+  const [loading, setLoading] = useState13(true);
+  const [error, setError] = useState13(null);
+  const fetchCategories = useCallback13(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.blog.categories();
+      setCategories(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch blog categories"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  useEffect12(() => {
+    fetchCategories();
+  }, [fetchCategories]);
+  return {
+    categories,
+    loading,
+    error,
+    refresh: fetchCategories
+  };
+}
+function useBlogTags() {
+  const client = useClient();
+  const [tags, setTags] = useState13([]);
+  const [loading, setLoading] = useState13(true);
+  const [error, setError] = useState13(null);
+  const fetchTags = useCallback13(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.blog.tags();
+      setTags(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch blog tags"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  useEffect12(() => {
+    fetchTags();
+  }, [fetchTags]);
+  return {
+    tags,
+    loading,
+    error,
+    refresh: fetchTags
+  };
+}
+function useFeaturedBlog(limit = 5) {
+  const client = useClient();
+  const [posts, setPosts] = useState13([]);
+  const [loading, setLoading] = useState13(true);
+  const [error, setError] = useState13(null);
+  const fetchPosts = useCallback13(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.blog.featured(limit);
+      setPosts(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch featured posts"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, limit]);
+  useEffect12(() => {
+    fetchPosts();
+  }, [fetchPosts]);
+  return {
+    posts,
+    loading,
+    error,
+    refresh: fetchPosts
+  };
+}
+function useBlogSearch() {
+  const client = useClient();
+  const [posts, setPosts] = useState13([]);
+  const [meta, setMeta] = useState13(null);
+  const [loading, setLoading] = useState13(false);
+  const [error, setError] = useState13(null);
+  const search = useCallback13(async (query) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.blog.search(query);
+      setPosts(response.data);
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to search posts"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  return {
+    posts,
+    meta,
+    loading,
+    error,
+    search
+  };
+}
+
+// src/hooks/useBoards.ts
+import { useState as useState14, useEffect as useEffect13, useCallback as useCallback14 } from "react";
+function useBoards(params) {
+  const client = useClient();
+  const [boards, setBoards] = useState14([]);
+  const [loading, setLoading] = useState14(true);
+  const [error, setError] = useState14(null);
+  const fetchBoards = useCallback14(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.boards.list(params);
+      setBoards(response.data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch boards"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, params]);
+  useEffect13(() => {
+    fetchBoards();
+  }, [fetchBoards]);
+  return {
+    boards,
+    loading,
+    error,
+    refresh: fetchBoards
+  };
+}
+function useBoard(slug) {
+  const client = useClient();
+  const [board, setBoard] = useState14(null);
+  const [loading, setLoading] = useState14(true);
+  const [error, setError] = useState14(null);
+  const fetchBoard = useCallback14(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.boards.get(slug);
+      setBoard(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch board"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, slug]);
+  useEffect13(() => {
+    fetchBoard();
+  }, [fetchBoard]);
+  return {
+    board,
+    loading,
+    error,
+    refresh: fetchBoard
+  };
+}
+function useBoardPosts(boardSlug, params) {
+  const client = useClient();
+  const [posts, setPosts] = useState14([]);
+  const [meta, setMeta] = useState14(null);
+  const [loading, setLoading] = useState14(true);
+  const [error, setError] = useState14(null);
+  const [currentParams, setCurrentParams] = useState14(params);
+  const fetchPosts = useCallback14(async (fetchParams, append = false) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.boards.listPosts(boardSlug, fetchParams);
+      if (append) {
+        setPosts((prev) => [...prev, ...response.data]);
+      } else {
+        setPosts(response.data);
+      }
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch posts"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, boardSlug]);
+  useEffect13(() => {
+    fetchPosts(params);
+  }, []);
+  const hasMore = meta ? meta.current_page < meta.last_page : false;
+  const loadMore = useCallback14(async () => {
+    if (!hasMore || loading) return;
+    const nextPage = (meta?.current_page ?? 0) + 1;
+    await fetchPosts({ ...currentParams, page: nextPage }, true);
+  }, [hasMore, loading, meta, currentParams, fetchPosts]);
+  const refresh = useCallback14(async () => {
+    setCurrentParams(params);
+    await fetchPosts(params);
+  }, [params, fetchPosts]);
+  return {
+    posts,
+    meta,
+    loading,
+    error,
+    hasMore,
+    loadMore,
+    refresh
+  };
+}
+function useBoardPost(postId) {
+  const client = useClient();
+  const [post, setPost] = useState14(null);
+  const [loading, setLoading] = useState14(true);
+  const [error, setError] = useState14(null);
+  const fetchPost = useCallback14(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.boards.getPost(postId);
+      setPost(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch post"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, postId]);
+  useEffect13(() => {
+    fetchPost();
+  }, [fetchPost]);
+  return {
+    post,
+    loading,
+    error,
+    refresh: fetchPost
+  };
+}
+function useCreateBoardPost() {
+  const client = useClient();
+  const [loading, setLoading] = useState14(false);
+  const [error, setError] = useState14(null);
+  const createPost = useCallback14(async (data) => {
+    setLoading(true);
+    setError(null);
+    try {
+      return await client.boards.createPost(data);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to create post");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  return {
+    createPost,
+    loading,
+    error
+  };
+}
+
+// src/hooks/useComments.ts
+import { useState as useState15, useEffect as useEffect14, useCallback as useCallback15 } from "react";
+function useComments(options) {
+  const { type, target, page, per_page } = options;
+  const client = useClient();
+  const [comments, setComments] = useState15([]);
+  const [meta, setMeta] = useState15(null);
+  const [loading, setLoading] = useState15(true);
+  const [error, setError] = useState15(null);
+  const fetchComments = useCallback15(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      let response;
+      const params = { page, per_page };
+      switch (type) {
+        case "board":
+          response = await client.comments.boardPost(target, params);
+          break;
+        case "blog":
+          response = await client.comments.blogPost(target, params);
+          break;
+        case "standalone":
+          response = await client.comments.standalone(target, params);
+          break;
+      }
+      setComments(response.data);
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch comments"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, type, target, page, per_page]);
+  useEffect14(() => {
+    fetchComments();
+  }, [fetchComments]);
+  const createComment = useCallback15(async (data) => {
+    let response;
+    switch (type) {
+      case "board":
+        response = await client.comments.createBoardPost(target, data);
+        break;
+      case "blog":
+        response = await client.comments.createBlogPost(target, data);
+        break;
+      case "standalone":
+        response = await client.comments.createStandalone(target, data);
+        break;
+    }
+    await fetchComments();
+    return response.data;
+  }, [client, type, target, fetchComments]);
+  const updateComment = useCallback15(async (commentId, content) => {
+    const response = await client.comments.update(commentId, { content });
+    setComments((prev) => prev.map((c) => c.id === commentId ? response.data : c));
+    return response.data;
+  }, [client]);
+  const deleteComment = useCallback15(async (commentId, password) => {
+    await client.comments.delete(commentId, password ? { password } : void 0);
+    setComments((prev) => prev.filter((c) => c.id !== commentId));
+  }, [client]);
+  const likeComment = useCallback15(async (commentId) => {
+    const response = await client.comments.like(commentId);
+    setComments((prev) => prev.map(
+      (c) => c.id === commentId ? { ...c, likes: response.data.likes } : c
+    ));
+    return response.data.likes;
+  }, [client]);
+  return {
+    comments,
+    meta,
+    loading,
+    error,
+    createComment,
+    updateComment,
+    deleteComment,
+    likeComment,
+    refresh: fetchComments
+  };
+}
+
+// src/hooks/useForms.ts
+import { useState as useState16, useEffect as useEffect15, useCallback as useCallback16 } from "react";
+function useForm(formSlug) {
+  const client = useClient();
+  const [form, setForm] = useState16(null);
+  const [loading, setLoading] = useState16(true);
+  const [error, setError] = useState16(null);
+  const [submitting, setSubmitting] = useState16(false);
+  const [submitted, setSubmitted] = useState16(false);
+  const fetchForm = useCallback16(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.forms.get(formSlug);
+      setForm(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch form"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, formSlug]);
+  useEffect15(() => {
+    fetchForm();
+  }, [fetchForm]);
+  const submit = useCallback16(async (data) => {
+    setSubmitting(true);
+    setError(null);
+    try {
+      const submission = await client.forms.submit(formSlug, data);
+      setSubmitted(true);
+      return submission;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to submit form");
+      setError(error2);
+      throw error2;
+    } finally {
+      setSubmitting(false);
+    }
+  }, [client, formSlug]);
+  const reset = useCallback16(() => {
+    setSubmitted(false);
+    setError(null);
+  }, []);
+  return {
+    form,
+    loading,
+    error,
+    submit,
+    submitting,
+    submitted,
+    reset
+  };
+}
+
+// src/hooks/useReservation.ts
+import { useState as useState17, useEffect as useEffect16, useCallback as useCallback17 } from "react";
+function useReservationServices() {
+  const client = useClient();
+  const [services, setServices] = useState17([]);
+  const [loading, setLoading] = useState17(true);
+  const [error, setError] = useState17(null);
+  const fetchServices = useCallback17(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.reservation.listServices();
+      setServices(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch services"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  useEffect16(() => {
+    fetchServices();
+  }, [fetchServices]);
+  return {
+    services,
+    loading,
+    error,
+    refresh: fetchServices
+  };
+}
+function useReservationStaffs() {
+  const client = useClient();
+  const [staffs, setStaffs] = useState17([]);
+  const [loading, setLoading] = useState17(true);
+  const [error, setError] = useState17(null);
+  const fetchStaffs = useCallback17(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.reservation.listStaff();
+      setStaffs(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch staffs"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  useEffect16(() => {
+    fetchStaffs();
+  }, [fetchStaffs]);
+  return {
+    staffs,
+    loading,
+    error,
+    refresh: fetchStaffs
+  };
+}
+function useAvailableSlots(serviceId, date, staffId) {
+  const client = useClient();
+  const [slots, setSlots] = useState17([]);
+  const [loading, setLoading] = useState17(true);
+  const [error, setError] = useState17(null);
+  const fetchSlots = useCallback17(async () => {
+    if (!serviceId || !date) {
+      setSlots([]);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.reservation.getAvailableSlots({
+        service_id: serviceId,
+        date,
+        staff_id: staffId
+      });
+      setSlots(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch slots"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, serviceId, date, staffId]);
+  useEffect16(() => {
+    fetchSlots();
+  }, [fetchSlots]);
+  return {
+    slots,
+    loading,
+    error,
+    refresh: fetchSlots
+  };
+}
+function useMyReservations(params) {
+  const client = useClient();
+  const [reservations, setReservations] = useState17([]);
+  const [meta, setMeta] = useState17(null);
+  const [loading, setLoading] = useState17(true);
+  const [error, setError] = useState17(null);
+  const fetchReservations = useCallback17(async () => {
+    if (!client.isAuthenticated()) {
+      setReservations([]);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.reservation.list(params);
+      setReservations(response.data);
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch reservations"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, params]);
+  useEffect16(() => {
+    fetchReservations();
+  }, [fetchReservations]);
+  return {
+    reservations,
+    meta,
+    loading,
+    error,
+    refresh: fetchReservations
+  };
+}
+function useCreateReservation() {
+  const client = useClient();
+  const [loading, setLoading] = useState17(false);
+  const [error, setError] = useState17(null);
+  const createReservation = useCallback17(async (data) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await client.reservation.create(data);
+      return result.reservation;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to create reservation");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  return {
+    createReservation,
+    loading,
+    error
+  };
+}
+function useReservationSettings() {
+  const client = useClient();
+  const [settings, setSettings] = useState17(null);
+  const [loading, setLoading] = useState17(true);
+  const [error, setError] = useState17(null);
+  const fetchSettings = useCallback17(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.reservation.getSettings();
+      setSettings(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch settings"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  useEffect16(() => {
+    fetchSettings();
+  }, [fetchSettings]);
+  return {
+    settings,
+    loading,
+    error,
+    refresh: fetchSettings
+  };
+}
+
+// src/hooks/useMedia.ts
+import { useState as useState18, useEffect as useEffect17, useCallback as useCallback18 } from "react";
+function useMedia(options = {}) {
+  const { type, page, per_page, autoFetch = true } = options;
+  const client = useClient();
+  const [files, setFiles] = useState18([]);
+  const [meta, setMeta] = useState18(null);
+  const [loading, setLoading] = useState18(autoFetch);
+  const [error, setError] = useState18(null);
+  const [uploading, setUploading] = useState18(false);
+  const [uploadProgress, setUploadProgress] = useState18(0);
+  const fetchMedia = useCallback18(async () => {
+    if (!client.isAuthenticated()) {
+      setFiles([]);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.media.list({ type, page, per_page });
+      setFiles(response.data);
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch media"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, type, page, per_page]);
+  useEffect17(() => {
+    if (autoFetch) {
+      fetchMedia();
+    }
+  }, [autoFetch, fetchMedia]);
+  const upload = useCallback18(async (file) => {
+    setUploading(true);
+    setUploadProgress(0);
+    setError(null);
+    try {
+      const media = await client.media.upload(file);
+      setFiles((prev) => [media, ...prev]);
+      setUploadProgress(100);
+      return media;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to upload file");
+      setError(error2);
+      throw error2;
+    } finally {
+      setUploading(false);
+    }
+  }, [client]);
+  const uploadMultiple = useCallback18(async (filesToUpload) => {
+    setUploading(true);
+    setUploadProgress(0);
+    setError(null);
+    try {
+      const results = [];
+      for (let i = 0; i < filesToUpload.length; i++) {
+        const media = await client.media.upload(filesToUpload[i]);
+        results.push(media);
+        setUploadProgress(Math.round((i + 1) / filesToUpload.length * 100));
+      }
+      setFiles((prev) => [...results, ...prev]);
+      return results;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to upload files");
+      setError(error2);
+      throw error2;
+    } finally {
+      setUploading(false);
+    }
+  }, [client]);
+  const deleteFile = useCallback18(async (mediaId) => {
+    await client.media.delete(mediaId);
+    setFiles((prev) => prev.filter((f) => f.id !== mediaId));
+  }, [client]);
+  return {
+    files,
+    meta,
+    loading,
+    error,
+    upload,
+    uploadMultiple,
+    deleteFile,
+    refresh: fetchMedia,
+    uploading,
+    uploadProgress
+  };
+}
+
+// src/hooks/useEntities.ts
+import { useState as useState19, useEffect as useEffect18, useCallback as useCallback19, useMemo as useMemo2 } from "react";
+function useEntities() {
+  const client = useClient();
+  const [entities, setEntities] = useState19([]);
+  const [loading, setLoading] = useState19(true);
+  const [error, setError] = useState19(null);
+  const fetchEntities = useCallback19(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.entities.list();
+      setEntities(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch entities"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  useEffect18(() => {
+    fetchEntities();
+  }, [fetchEntities]);
+  return {
+    entities,
+    loading,
+    error,
+    refresh: fetchEntities
+  };
+}
+function useEntity(slug) {
+  const client = useClient();
+  const [entity, setEntity] = useState19(null);
+  const [loading, setLoading] = useState19(true);
+  const [error, setError] = useState19(null);
+  const fetchEntity = useCallback19(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.entities.get(slug);
+      setEntity(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch entity"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, slug]);
+  useEffect18(() => {
+    fetchEntity();
+  }, [fetchEntity]);
+  return {
+    entity,
+    loading,
+    error,
+    refresh: fetchEntity
+  };
+}
+function useEntityRecords(slug, params) {
+  const client = useClient();
+  const [records, setRecords] = useState19([]);
+  const [meta, setMeta] = useState19(null);
+  const [loading, setLoading] = useState19(true);
+  const [error, setError] = useState19(null);
+  const [currentParams, setCurrentParams] = useState19(params);
+  const fetchRecords = useCallback19(async (fetchParams, append = false) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.entities.listRecords(slug, fetchParams);
+      if (append) {
+        setRecords((prev) => [...prev, ...response.data]);
+      } else {
+        setRecords(response.data);
+      }
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch records"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, slug]);
+  useEffect18(() => {
+    fetchRecords(params);
+  }, []);
+  const hasMore = meta ? meta.current_page < meta.last_page : false;
+  const loadMore = useCallback19(async () => {
+    if (!hasMore || loading) return;
+    const nextPage = (meta?.current_page ?? 0) + 1;
+    await fetchRecords({ ...currentParams, page: nextPage }, true);
+  }, [hasMore, loading, meta, currentParams, fetchRecords]);
+  const createRecord = useCallback19(async (data) => {
+    const record = await client.entities.createRecord(slug, data);
+    setRecords((prev) => [record, ...prev]);
+    return record;
+  }, [client, slug]);
+  const updateRecord = useCallback19(async (id, data) => {
+    const record = await client.entities.updateRecord(slug, id, data);
+    setRecords((prev) => prev.map((r) => r.id === id ? record : r));
+    return record;
+  }, [client, slug]);
+  const deleteRecord = useCallback19(async (id) => {
+    await client.entities.deleteRecord(slug, id);
+    setRecords((prev) => prev.filter((r) => r.id !== id));
+  }, [client, slug]);
+  const refresh = useCallback19(async () => {
+    setCurrentParams(params);
+    await fetchRecords(params);
+  }, [params, fetchRecords]);
+  return {
+    records,
+    meta,
+    loading,
+    error,
+    hasMore,
+    loadMore,
+    createRecord,
+    updateRecord,
+    deleteRecord,
+    refresh
+  };
+}
+function useEntityRecord(slug, id) {
+  const client = useClient();
+  const [record, setRecord] = useState19(null);
+  const [loading, setLoading] = useState19(true);
+  const [error, setError] = useState19(null);
+  const fetchRecord = useCallback19(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.entities.getRecord(slug, id);
+      setRecord(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch record"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, slug, id]);
+  useEffect18(() => {
+    fetchRecord();
+  }, [fetchRecord]);
+  const update = useCallback19(async (data) => {
+    const updated = await client.entities.updateRecord(slug, id, data);
+    setRecord(updated);
+    return updated;
+  }, [client, slug, id]);
+  return {
+    record,
+    loading,
+    error,
+    update,
+    refresh: fetchRecord
+  };
+}
+function useTypedEntity(slug) {
+  const client = useClient();
+  return useMemo2(() => ({
+    useRecords: (params) => {
+      const result = useEntityRecords(slug, params);
+      return {
+        ...result,
+        records: result.records
+      };
+    },
+    useRecord: (id) => {
+      const result = useEntityRecord(slug, id);
+      return {
+        ...result,
+        record: result.record
+      };
+    },
+    create: async (data) => {
+      const record = await client.entities.createRecord(slug, data);
+      return record;
+    },
+    update: async (id, data) => {
+      const record = await client.entities.updateRecord(slug, id, data);
+      return record;
+    },
+    delete: (id) => client.entities.deleteRecord(slug, id)
+  }), [client, slug]);
+}
+export {
+  DiffsomeContext,
+  DiffsomeProvider,
+  useAuth,
+  useAvailableSlots,
+  useBlog,
+  useBlogCategories,
+  useBlogPost,
+  useBlogSearch,
+  useBlogTags,
+  useBoard,
+  useBoardPost,
+  useBoardPosts,
+  useBoards,
+  useBundleItems,
+  useBundleProducts,
+  useCanReview,
+  useCart,
+  useCategories,
+  useClient,
+  useComments,
+  useCoupons,
+  useCreateBoardPost,
+  useCreateOrder,
+  useCreateReservation,
+  useCreateReview,
+  useCreateSubscription,
+  useDiffsome,
+  useDigitalProducts,
+  useDownloads,
+  useEntities,
+  useEntity,
+  useEntityRecord,
+  useEntityRecords,
+  useFeaturedBlog,
+  useFeaturedProducts,
+  useForm,
+  useMedia,
+  useMyReservations,
+  useMyReviews,
+  useOrder,
+  useOrderDownloads,
+  useOrders,
+  usePaymentStatus,
+  useProduct,
+  useProductReviews,
+  useProducts,
+  useProductsByType,
+  useReservationServices,
+  useReservationSettings,
+  useReservationStaffs,
+  useSocialAuth,
+  useStripePayment,
+  useSubscription,
+  useSubscriptionProducts,
+  useSubscriptions,
+  useTossPayment,
+  useTypedEntity,
+  useValidateCoupon,
+  useWishlist
+};