@atomic-solutions/woocommerce-react 0.1.0

package/dist/hooks/index.cjs

@@ -0,0 +1,1159 @@
+'use strict';
+
+var react = require('react');
+var reactQuery = require('@tanstack/react-query');
+var woocommerceUtils = require('@atomic-solutions/woocommerce-utils');
+
+// src/hooks/useWooCommerceClient.ts
+var WooCommerceContext = react.createContext(null);
+
+// src/hooks/useWooCommerceClient.ts
+var useWooCommerceClient = () => {
+  const context = react.useContext(WooCommerceContext);
+  if (!context) {
+    throw new Error(
+      "useWooCommerceClient must be used within WooCommerceProvider. Wrap your app with <WooCommerceProvider client={client} queryKeys={queryKeys}>."
+    );
+  }
+  return context.client;
+};
+var useWooCommerceQueryKeys = () => {
+  const context = react.useContext(WooCommerceContext);
+  if (!context) {
+    throw new Error(
+      "useWooCommerceQueryKeys must be used within WooCommerceProvider. Wrap your app with <WooCommerceProvider client={client} queryKeys={queryKeys}>."
+    );
+  }
+  return context.queryKeys;
+};
+
+// src/constants/stale-times.ts
+var STALE_TIME_SHORT = 60 * 1e3;
+var STALE_TIME_LONG = 60 * 60 * 1e3;
+var STALE_TIME_NONE = 0;
+var StaleTimes = {
+  /** Cart data - always fresh */
+  cart: STALE_TIME_NONE,
+  /** Checkout data - always fresh */
+  checkout: STALE_TIME_NONE,
+  /** Product list - 1 minute */
+  products: STALE_TIME_SHORT,
+  /** Product detail - 1 minute */
+  product: STALE_TIME_SHORT,
+  /** Product categories - always fresh */
+  categories: STALE_TIME_NONE,
+  /** Orders - always fresh */
+  orders: STALE_TIME_NONE,
+  /** Default for infinite queries - 1 hour */
+  infinite: STALE_TIME_LONG
+};
+var useInfiniteWooQuery = ({
+  queryKey,
+  queryFn,
+  params,
+  perPage = 10,
+  staleTime = StaleTimes.infinite,
+  enabled
+}) => {
+  const query = reactQuery.useInfiniteQuery({
+    queryKey,
+    queryFn: ({ pageParam }) => queryFn({
+      per_page: perPage,
+      ...params,
+      page: pageParam
+    }),
+    initialPageParam: 1,
+    getNextPageParam: (lastPage) => lastPage.pagination.nextPage,
+    getPreviousPageParam: (firstPage) => firstPage.pagination.prevPage,
+    staleTime,
+    enabled
+  });
+  const flatData = query.data?.pages.flatMap((page) => page.data) ?? [];
+  return {
+    ...query,
+    data: flatData
+    // Override data with flattened array
+  };
+};
+
+// src/hooks/products.ts
+var useProducts = (params) => {
+  const client = useWooCommerceClient();
+  const queryKeys = useWooCommerceQueryKeys();
+  return reactQuery.useQuery({
+    queryKey: queryKeys.products.list(params),
+    queryFn: () => client.products.list(params),
+    staleTime: StaleTimes.products
+  });
+};
+var useInfiniteProducts = (params) => {
+  const client = useWooCommerceClient();
+  const queryKeys = useWooCommerceQueryKeys();
+  return useInfiniteWooQuery({
+    queryKey: queryKeys.products.list(params),
+    queryFn: (p) => client.products.list({ ...p, page: p.page ?? 1 }),
+    params,
+    perPage: params?.per_page ?? 10
+  });
+};
+var useProduct = (id) => {
+  const client = useWooCommerceClient();
+  const queryKeys = useWooCommerceQueryKeys();
+  return reactQuery.useQuery({
+    queryKey: queryKeys.products.detail(id),
+    queryFn: () => client.products.get(id),
+    staleTime: StaleTimes.product
+  });
+};
+var useProductCategories = () => {
+  const client = useWooCommerceClient();
+  const queryKeys = useWooCommerceQueryKeys();
+  return reactQuery.useQuery({
+    queryKey: queryKeys.products.categories(),
+    queryFn: () => client.products.categories(),
+    staleTime: StaleTimes.categories
+  });
+};
+var groupBy = (fn, list) => {
+  return list.reduce(
+    (acc, item) => {
+      const key = fn(item);
+      if (!acc[key]) {
+        acc[key] = [];
+      }
+      acc[key].push(item);
+      return acc;
+    },
+    {}
+  );
+};
+var processCategoriesToTree = (data) => {
+  const rootCategories = data?.filter((item) => item.parent === 0);
+  const indexedData = groupBy((item) => String(item.parent), data ?? []);
+  const processCategory = (item) => ({
+    ...item,
+    subCategories: indexedData[item.id]?.map(processCategory)
+  });
+  return rootCategories?.map(processCategory) ?? [];
+};
+var useProductCategoryTree = () => {
+  const query = useProductCategories();
+  const flatData = query.data ?? [];
+  const treeData = processCategoriesToTree(flatData);
+  const findById = (id) => {
+    if (!id) return;
+    const numId = typeof id === "string" ? parseInt(id, 10) : id;
+    return flatData.find((item) => item.id === numId);
+  };
+  return {
+    ...query,
+    data: flatData,
+    treeData,
+    findById
+  };
+};
+var EventContext = react.createContext(null);
+var useEventEmitter = () => {
+  return react.useContext(EventContext);
+};
+
+// src/events/types.ts
+function createSuccessEvent(type, data) {
+  return { type, status: "success", data };
+}
+function createErrorEvent(type, error) {
+  return { type, status: "error", error };
+}
+
+// src/hooks/cart.ts
+var useCart = () => {
+  const client = useWooCommerceClient();
+  const queryKeys = useWooCommerceQueryKeys();
+  const query = reactQuery.useQuery({
+    queryKey: queryKeys.cart.details(),
+    queryFn: () => client.cart.get(),
+    staleTime: StaleTimes.cart
+  });
+  const cart = query.data;
+  const isInCart = (productId) => {
+    return cart?.items.some((item) => item.id === productId) ?? false;
+  };
+  const getCartItem = (productId) => {
+    return cart?.items.find((item) => item.id === productId);
+  };
+  const getQuantity = (productId) => {
+    return getCartItem(productId)?.quantity ?? 0;
+  };
+  return {
+    ...query,
+    isInCart,
+    getCartItem,
+    getQuantity
+  };
+};
+var useAddToCart = () => {
+  const client = useWooCommerceClient();
+  const queryKeys = useWooCommerceQueryKeys();
+  const queryClient = reactQuery.useQueryClient();
+  const emitEvent = useEventEmitter();
+  return reactQuery.useMutation({
+    mutationKey: queryKeys.cart.mutations.addItem(),
+    mutationFn: (input) => client.cart.addItem(input),
+    onSuccess: (cart, input) => {
+      queryClient.setQueryData(queryKeys.cart.details(), cart);
+      queryClient.invalidateQueries({ queryKey: queryKeys.cart.all });
+      const addedItem = cart.items.find((item) => item.id === input.id);
+      if (emitEvent && addedItem) {
+        emitEvent(createSuccessEvent("cart:item_added", { item: addedItem, cart }));
+      }
+    },
+    onError: (error) => {
+      if (emitEvent) {
+        const wooError = error instanceof woocommerceUtils.WooCommerceApiError ? error : new woocommerceUtils.WooCommerceApiError({
+          code: "unknown_error",
+          message: error instanceof Error ? error.message : "Unknown error",
+          statusCode: 500,
+          url: "",
+          method: "POST",
+          originalCode: "unknown_error"
+        });
+        emitEvent(createErrorEvent("cart:item_added", wooError));
+      }
+    }
+  });
+};
+var useUpdateCartItem = () => {
+  const client = useWooCommerceClient();
+  const queryKeys = useWooCommerceQueryKeys();
+  const queryClient = reactQuery.useQueryClient();
+  const emitEvent = useEventEmitter();
+  return reactQuery.useMutation({
+    mutationKey: queryKeys.cart.mutations.updateItem(),
+    mutationFn: (input) => client.cart.updateItem(input),
+    onSuccess: (cart, input) => {
+      queryClient.setQueryData(queryKeys.cart.details(), cart);
+      queryClient.invalidateQueries({ queryKey: queryKeys.cart.all });
+      const updatedItem = cart.items.find((item) => item.key === input.key);
+      if (emitEvent && updatedItem) {
+        emitEvent(createSuccessEvent("cart:item_updated", { item: updatedItem, cart }));
+      }
+    },
+    onError: (error) => {
+      if (emitEvent) {
+        const wooError = error instanceof woocommerceUtils.WooCommerceApiError ? error : new woocommerceUtils.WooCommerceApiError({
+          code: "unknown_error",
+          message: error instanceof Error ? error.message : "Unknown error",
+          statusCode: 500,
+          url: "",
+          method: "POST",
+          originalCode: "unknown_error"
+        });
+        emitEvent(createErrorEvent("cart:item_updated", wooError));
+      }
+    }
+  });
+};
+var useRemoveFromCart = () => {
+  const client = useWooCommerceClient();
+  const queryKeys = useWooCommerceQueryKeys();
+  const queryClient = reactQuery.useQueryClient();
+  const emitEvent = useEventEmitter();
+  return reactQuery.useMutation({
+    mutationKey: queryKeys.cart.mutations.removeItem(),
+    mutationFn: (input) => client.cart.removeItem(input),
+    onSuccess: (cart, input) => {
+      queryClient.setQueryData(queryKeys.cart.details(), cart);
+      queryClient.invalidateQueries({ queryKey: queryKeys.cart.all });
+      if (emitEvent) {
+        emitEvent(createSuccessEvent("cart:item_removed", { itemKey: input.key, cart }));
+      }
+    },
+    onError: (error) => {
+      if (emitEvent) {
+        const wooError = error instanceof woocommerceUtils.WooCommerceApiError ? error : new woocommerceUtils.WooCommerceApiError({
+          code: "unknown_error",
+          message: error instanceof Error ? error.message : "Unknown error",
+          statusCode: 500,
+          url: "",
+          method: "POST",
+          originalCode: "unknown_error"
+        });
+        emitEvent(createErrorEvent("cart:item_removed", wooError));
+      }
+    }
+  });
+};
+var useApplyCoupon = () => {
+  const client = useWooCommerceClient();
+  const queryKeys = useWooCommerceQueryKeys();
+  const queryClient = reactQuery.useQueryClient();
+  const emitEvent = useEventEmitter();
+  return reactQuery.useMutation({
+    mutationKey: queryKeys.cart.mutations.applyCoupon(),
+    mutationFn: (input) => client.cart.applyCoupon(input),
+    onSuccess: (cart, input) => {
+      queryClient.setQueryData(queryKeys.cart.details(), cart);
+      queryClient.invalidateQueries({ queryKey: queryKeys.cart.all });
+      if (emitEvent) {
+        emitEvent(createSuccessEvent("cart:coupon_applied", { code: input.code, cart }));
+      }
+    },
+    onError: (error) => {
+      if (emitEvent) {
+        const wooError = error instanceof woocommerceUtils.WooCommerceApiError ? error : new woocommerceUtils.WooCommerceApiError({
+          code: "unknown_error",
+          message: error instanceof Error ? error.message : "Unknown error",
+          statusCode: 500,
+          url: "",
+          method: "POST",
+          originalCode: "unknown_error"
+        });
+        emitEvent(createErrorEvent("cart:coupon_applied", wooError));
+      }
+    }
+  });
+};
+var useRemoveCoupon = () => {
+  const client = useWooCommerceClient();
+  const queryKeys = useWooCommerceQueryKeys();
+  const queryClient = reactQuery.useQueryClient();
+  const emitEvent = useEventEmitter();
+  return reactQuery.useMutation({
+    mutationKey: queryKeys.cart.mutations.removeCoupon(),
+    mutationFn: (input) => client.cart.removeCoupon(input),
+    onSuccess: (cart, input) => {
+      queryClient.setQueryData(queryKeys.cart.details(), cart);
+      queryClient.invalidateQueries({ queryKey: queryKeys.cart.all });
+      if (emitEvent) {
+        emitEvent(createSuccessEvent("cart:coupon_removed", { code: input.code, cart }));
+      }
+    },
+    onError: (error) => {
+      if (emitEvent) {
+        const wooError = error instanceof woocommerceUtils.WooCommerceApiError ? error : new woocommerceUtils.WooCommerceApiError({
+          code: "unknown_error",
+          message: error instanceof Error ? error.message : "Unknown error",
+          statusCode: 500,
+          url: "",
+          method: "POST",
+          originalCode: "unknown_error"
+        });
+        emitEvent(createErrorEvent("cart:coupon_removed", wooError));
+      }
+    }
+  });
+};
+var useUpdateCustomer = () => {
+  const client = useWooCommerceClient();
+  const queryKeys = useWooCommerceQueryKeys();
+  const queryClient = reactQuery.useQueryClient();
+  const emitEvent = useEventEmitter();
+  return reactQuery.useMutation({
+    mutationKey: queryKeys.cart.mutations.updateCustomer(),
+    mutationFn: (input) => client.cart.updateCustomer(input),
+    onSuccess: (cart) => {
+      queryClient.setQueryData(queryKeys.cart.details(), cart);
+      queryClient.invalidateQueries({ queryKey: queryKeys.cart.all });
+      if (emitEvent) {
+        emitEvent(createSuccessEvent("cart:customer_updated", { cart }));
+      }
+    },
+    onError: (error) => {
+      if (emitEvent) {
+        const wooError = error instanceof woocommerceUtils.WooCommerceApiError ? error : new woocommerceUtils.WooCommerceApiError({
+          code: "unknown_error",
+          message: error instanceof Error ? error.message : "Unknown error",
+          statusCode: 500,
+          url: "",
+          method: "POST",
+          originalCode: "unknown_error"
+        });
+        emitEvent(createErrorEvent("cart:customer_updated", wooError));
+      }
+    }
+  });
+};
+var useSelectShippingRate = () => {
+  const client = useWooCommerceClient();
+  const queryKeys = useWooCommerceQueryKeys();
+  const queryClient = reactQuery.useQueryClient();
+  const emitEvent = useEventEmitter();
+  return reactQuery.useMutation({
+    mutationKey: queryKeys.cart.mutations.selectShippingRate(),
+    mutationFn: (input) => client.cart.selectShippingRate(input),
+    onSuccess: (cart) => {
+      queryClient.setQueryData(queryKeys.cart.details(), cart);
+      queryClient.invalidateQueries({ queryKey: queryKeys.cart.all });
+      if (emitEvent) {
+        emitEvent(createSuccessEvent("cart:shipping_selected", { cart }));
+      }
+    },
+    onError: (error) => {
+      if (emitEvent) {
+        const wooError = error instanceof woocommerceUtils.WooCommerceApiError ? error : new woocommerceUtils.WooCommerceApiError({
+          code: "unknown_error",
+          message: error instanceof Error ? error.message : "Unknown error",
+          statusCode: 500,
+          url: "",
+          method: "POST",
+          originalCode: "unknown_error"
+        });
+        emitEvent(createErrorEvent("cart:shipping_selected", wooError));
+      }
+    }
+  });
+};
+var useCheckout = () => {
+  const client = useWooCommerceClient();
+  const queryKeys = useWooCommerceQueryKeys();
+  return reactQuery.useQuery({
+    queryKey: queryKeys.checkout.details(),
+    queryFn: () => client.checkout.get(),
+    staleTime: StaleTimes.checkout
+  });
+};
+var useProcessCheckout = () => {
+  const client = useWooCommerceClient();
+  const queryKeys = useWooCommerceQueryKeys();
+  const queryClient = reactQuery.useQueryClient();
+  const emitEvent = useEventEmitter();
+  return reactQuery.useMutation({
+    mutationKey: queryKeys.checkout.mutations.process(),
+    mutationFn: (input) => client.checkout.process(input),
+    onSuccess: (checkout) => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.cart.all });
+      queryClient.invalidateQueries({ queryKey: queryKeys.checkout.all });
+      if (emitEvent) {
+        emitEvent(createSuccessEvent("checkout:processed", { checkout }));
+      }
+    },
+    onError: (error) => {
+      if (emitEvent) {
+        const wooError = error instanceof woocommerceUtils.WooCommerceApiError ? error : new woocommerceUtils.WooCommerceApiError({
+          code: "unknown_error",
+          message: error instanceof Error ? error.message : "Unknown error",
+          statusCode: 500,
+          url: "",
+          method: "POST",
+          originalCode: "unknown_error"
+        });
+        emitEvent(createErrorEvent("checkout:processed", wooError));
+      }
+    }
+  });
+};
+var useOrder = (input) => {
+  const client = useWooCommerceClient();
+  const queryKeys = useWooCommerceQueryKeys();
+  return reactQuery.useQuery({
+    queryKey: queryKeys.orders.detail(input.id, input.billing_email, input.key),
+    queryFn: () => client.orders.get(input),
+    staleTime: StaleTimes.orders
+  });
+};
+
+// src/hooks/queryKeys.ts
+var createQueryKeys = (prefix = ["woocommerce"]) => ({
+  // All keys start with prefix
+  all: prefix,
+  // Products
+  products: {
+    all: [...prefix, "products"],
+    lists: () => [...prefix, "products", "list"],
+    list: (params) => [...prefix, "products", "list", params],
+    details: () => [...prefix, "products", "detail"],
+    detail: (id) => [...prefix, "products", "detail", id],
+    categories: () => [...prefix, "products", "categories"]
+  },
+  // Cart
+  cart: {
+    all: [...prefix, "cart"],
+    details: () => [...prefix, "cart", "details"],
+    // Mutation keys
+    mutations: {
+      addItem: () => [...prefix, "cart", "mutation", "addItem"],
+      updateItem: () => [...prefix, "cart", "mutation", "updateItem"],
+      removeItem: () => [...prefix, "cart", "mutation", "removeItem"],
+      applyCoupon: () => [...prefix, "cart", "mutation", "applyCoupon"],
+      removeCoupon: () => [...prefix, "cart", "mutation", "removeCoupon"],
+      updateCustomer: () => [...prefix, "cart", "mutation", "updateCustomer"],
+      selectShippingRate: () => [...prefix, "cart", "mutation", "selectShippingRate"]
+    }
+  },
+  // Checkout
+  checkout: {
+    all: [...prefix, "checkout"],
+    details: () => [...prefix, "checkout", "details"],
+    // Mutation keys
+    mutations: {
+      process: () => [...prefix, "checkout", "mutation", "process"]
+    }
+  },
+  // Orders
+  orders: {
+    all: [...prefix, "orders"],
+    lists: () => [...prefix, "orders", "list"],
+    list: (params) => [...prefix, "orders", "list", params],
+    details: () => [...prefix, "orders", "detail"],
+    detail: (id, billing_email, key) => [...prefix, "orders", "detail", id, billing_email, key].filter(Boolean)
+  }
+});
+var WooCommerceStoreContext = react.createContext(null);
+WooCommerceStoreContext.displayName = "WooCommerceStoreContext";
+
+// src/hooks/useStore.ts
+function useStore() {
+  const context = react.useContext(WooCommerceStoreContext);
+  if (!context) {
+    throw new Error("useStore must be used within a WooCommerceStoreProvider");
+  }
+  return context;
+}
+function useStoreFeatures() {
+  const { config } = useStore();
+  return config.features;
+}
+function useStoreLocale() {
+  const { config } = useStore();
+  return config.locale;
+}
+var DEFAULT_THEME = {
+  primary: "#007AFF",
+  // iOS blue
+  secondary: "#5856D6",
+  // iOS purple
+  mode: "auto",
+  fonts: {
+    heading: void 0,
+    body: void 0
+  }
+};
+function useStoreTheme(options = {}) {
+  const { externalTheme } = options;
+  const storeContext = react.useContext(WooCommerceStoreContext);
+  const storeTheme = storeContext?.config?.theme;
+  const theme = react.useMemo(() => {
+    return {
+      primary: externalTheme?.primary ?? storeTheme?.primary ?? DEFAULT_THEME.primary,
+      secondary: externalTheme?.secondary ?? storeTheme?.secondary ?? DEFAULT_THEME.secondary,
+      mode: externalTheme?.mode ?? storeTheme?.mode ?? DEFAULT_THEME.mode,
+      fonts: {
+        heading: externalTheme?.fonts?.heading ?? storeTheme?.fonts?.heading ?? DEFAULT_THEME.fonts.heading,
+        body: externalTheme?.fonts?.body ?? storeTheme?.fonts?.body ?? DEFAULT_THEME.fonts.body
+      }
+    };
+  }, [externalTheme, storeTheme]);
+  return {
+    theme,
+    storeTheme,
+    hasExternalTheme: !!externalTheme
+  };
+}
+
+// src/provider/types.ts
+var DEFAULT_STORE_CONFIG = {
+  locale: {
+    localeTag: "en-US"},
+  debug: process.env.NODE_ENV !== "production"
+};
+
+// src/utils/price.ts
+var DEFAULT_LOCALE = {
+  localeTag: "en-US",
+  currency: "USD",
+  currencyPosition: "before",
+  thousandsSeparator: ",",
+  decimalSeparator: ".",
+  decimals: 2
+};
+var CURRENCY_SYMBOLS = {
+  USD: "$",
+  EUR: "\u20AC",
+  GBP: "\xA3",
+  CAD: "CA$",
+  AUD: "A$",
+  JPY: "\xA5",
+  CNY: "\xA5",
+  INR: "\u20B9",
+  BRL: "R$",
+  MXN: "MX$",
+  RUB: "\u20BD",
+  KRW: "\u20A9",
+  CHF: "CHF",
+  SEK: "kr",
+  NOK: "kr",
+  DKK: "kr",
+  PLN: "z\u0142",
+  TRY: "\u20BA",
+  ZAR: "R",
+  NZD: "NZ$",
+  SGD: "S$",
+  HKD: "HK$",
+  THB: "\u0E3F",
+  PHP: "\u20B1",
+  // Balkans
+  BAM: "KM",
+  RSD: "din",
+  HRK: "kn",
+  MKD: "\u0434\u0435\u043D",
+  BGN: "\u043B\u0432",
+  RON: "lei"
+};
+function getCurrencySymbol(currencyCode) {
+  return CURRENCY_SYMBOLS[currencyCode.toUpperCase()] ?? currencyCode;
+}
+function formatNumber(value, locale) {
+  const fixed = value.toFixed(locale.decimals);
+  const [integerPart, decimalPart] = fixed.split(".");
+  const formattedInteger = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, locale.thousandsSeparator);
+  if (locale.decimals > 0 && decimalPart) {
+    return `${formattedInteger}${locale.decimalSeparator}${decimalPart}`;
+  }
+  return formattedInteger;
+}
+function formatPrice(price, locale = {}) {
+  const mergedLocale = { ...DEFAULT_LOCALE, ...locale };
+  const numericPrice = typeof price === "string" ? parseFloat(price) : price;
+  if (isNaN(numericPrice)) {
+    return "";
+  }
+  const symbol = getCurrencySymbol(mergedLocale.currency);
+  const formattedNumber = formatNumber(numericPrice, mergedLocale);
+  if (mergedLocale.currencyPosition === "after") {
+    return `${formattedNumber}${symbol}`;
+  }
+  return `${symbol}${formattedNumber}`;
+}
+function calculateDiscount(regularPrice, salePrice) {
+  const regular = typeof regularPrice === "string" ? parseFloat(regularPrice) : regularPrice;
+  const sale = typeof salePrice === "string" ? parseFloat(salePrice) : salePrice;
+  if (isNaN(regular) || isNaN(sale) || regular <= 0 || sale >= regular) {
+    return null;
+  }
+  return Math.round((regular - sale) / regular * 100);
+}
+function formatStoreApiPriceIntl(priceInMinorUnits, currencyCode, localeTag = "en-US") {
+  if (!priceInMinorUnits || !currencyCode) {
+    return "-";
+  }
+  const cents = parseInt(priceInMinorUnits, 10);
+  if (isNaN(cents)) {
+    return "-";
+  }
+  const decimalPrice = cents / 100;
+  try {
+    const formatter = new Intl.NumberFormat(localeTag, {
+      style: "currency",
+      currency: currencyCode
+    });
+    return formatter.format(decimalPrice);
+  } catch {
+    return formatPrice(decimalPrice, { currency: currencyCode });
+  }
+}
+
+// src/utils/stock.ts
+var DEFAULT_CONFIG = {
+  inStockText: "In Stock",
+  outOfStockText: "Out of Stock",
+  backorderText: "Available on Backorder",
+  showQuantity: false,
+  lowStockThreshold: 5,
+  lowStockText: "Only {quantity} left"
+};
+function getStockStatusText(status, quantity, config = {}) {
+  const mergedConfig = { ...DEFAULT_CONFIG, ...config };
+  switch (status) {
+    case "instock":
+      if (quantity !== null && quantity !== void 0 && quantity <= mergedConfig.lowStockThreshold && quantity > 0) {
+        return mergedConfig.lowStockText.replace("{quantity}", quantity.toString());
+      }
+      if (mergedConfig.showQuantity && quantity !== null && quantity !== void 0) {
+        return `${mergedConfig.inStockText} (${quantity})`;
+      }
+      return mergedConfig.inStockText;
+    case "outofstock":
+      return mergedConfig.outOfStockText;
+    case "onbackorder":
+      return mergedConfig.backorderText;
+    default:
+      return mergedConfig.inStockText;
+  }
+}
+function isPurchasable(status, quantity, manageStock = true) {
+  if (status === "outofstock") {
+    return false;
+  }
+  if (status === "onbackorder") {
+    return true;
+  }
+  if (manageStock && quantity !== null && quantity !== void 0) {
+    return quantity > 0;
+  }
+  return true;
+}
+function isLowStock(status, quantity, threshold = 5) {
+  return status === "instock" && quantity !== null && quantity !== void 0 && quantity <= threshold && quantity > 0;
+}
+
+// src/utils/image.ts
+var SIZE_SUFFIXES = {
+  thumbnail: "-150x150",
+  medium: "-300x300",
+  large: "-1024x1024",
+  full: ""
+};
+function getPrimaryImage(images) {
+  if (!images || images.length === 0) {
+    return void 0;
+  }
+  return images[0];
+}
+function getImageUrl(images, size = "full", fallback) {
+  const primary = getPrimaryImage(images);
+  if (!primary) {
+    return fallback;
+  }
+  return getSizedImageUrl(primary.src, size);
+}
+function getSizedImageUrl(url, size = "full") {
+  if (!url || size === "full") {
+    return url;
+  }
+  const hasSize = Object.values(SIZE_SUFFIXES).some((suffix2) => suffix2 && url.includes(suffix2));
+  if (hasSize) {
+    let result = url;
+    Object.values(SIZE_SUFFIXES).forEach((suffix2) => {
+      if (suffix2) {
+        result = result.replace(suffix2, SIZE_SUFFIXES[size]);
+      }
+    });
+    return result;
+  }
+  const suffix = SIZE_SUFFIXES[size];
+  const lastDot = url.lastIndexOf(".");
+  if (lastDot === -1) {
+    return url;
+  }
+  return `${url.slice(0, lastDot)}${suffix}${url.slice(lastDot)}`;
+}
+function getAllImageUrls(images, size = "full") {
+  if (!images || images.length === 0) {
+    return [];
+  }
+  return images.map((img) => getSizedImageUrl(img.src, size));
+}
+
+// src/hooks/useProductsFeed.ts
+function useProductsFeed(options = {}) {
+  const { params, imageSize = "medium" } = options;
+  const storeContext = react.useContext(WooCommerceStoreContext);
+  const storeConfig = storeContext?.config;
+  const localeTag = options.localeTag ?? storeConfig?.locale?.localeTag ?? DEFAULT_STORE_CONFIG.locale.localeTag;
+  const fallbackImageUrl = options.fallbackImageUrl ?? storeConfig?.fallbackImageUrl;
+  const imageUrlTransformer = storeConfig?.imageUrlTransformer;
+  const {
+    data: productsData,
+    isLoading,
+    isFetchingNextPage,
+    error,
+    hasNextPage = false,
+    fetchNextPage,
+    refetch,
+    isRefetching
+  } = useInfiniteProducts(params);
+  const { treeData: categoryTree = [], findById } = useProductCategoryTree();
+  const getProcessedImageUrl = react.useCallback(
+    (images) => {
+      const baseUrl = getImageUrl(images, imageSize, fallbackImageUrl);
+      if (baseUrl && imageUrlTransformer) {
+        return imageUrlTransformer(baseUrl, imageSize);
+      }
+      return baseUrl;
+    },
+    [imageSize, fallbackImageUrl, imageUrlTransformer]
+  );
+  const products = react.useMemo(() => {
+    if (!productsData) return [];
+    const productList = Array.isArray(productsData) ? productsData : [];
+    return productList.map((product) => {
+      const currencyCode = product.prices?.currency_code;
+      return {
+        id: product.id,
+        name: product.name,
+        slug: product.slug,
+        permalink: product.permalink,
+        imageUrl: getProcessedImageUrl(product.images),
+        price: formatStoreApiPriceIntl(product.prices?.price, currencyCode, localeTag),
+        regularPrice: formatStoreApiPriceIntl(
+          product.prices?.regular_price,
+          currencyCode,
+          localeTag
+        ),
+        isOnSale: product.on_sale,
+        canAddToCart: product.is_purchasable && product.is_in_stock,
+        raw: product
+      };
+    });
+  }, [productsData, localeTag, getProcessedImageUrl]);
+  const activeCategory = react.useMemo(() => {
+    if (!params?.category) return void 0;
+    return findById(params.category);
+  }, [params, findById]);
+  const refresh = react.useCallback(async () => {
+    await refetch();
+  }, [refetch]);
+  const totalCount = products.length;
+  return {
+    products,
+    isLoading,
+    isFetchingNextPage,
+    error,
+    hasNextPage,
+    fetchNextPage,
+    refresh,
+    isRefreshing: isRefetching,
+    activeCategory,
+    categoryTree,
+    findCategoryById: findById,
+    totalCount
+  };
+}
+function useProductView(options) {
+  const { productId, imageSize = "large", lowStockThreshold = 5 } = options;
+  const storeContext = react.useContext(WooCommerceStoreContext);
+  const storeConfig = storeContext?.config;
+  const localeTag = options.localeTag ?? storeConfig?.locale?.localeTag ?? DEFAULT_STORE_CONFIG.locale.localeTag;
+  const fallbackImageUrl = options.fallbackImageUrl ?? storeConfig?.fallbackImageUrl;
+  const imageUrlTransformer = storeConfig?.imageUrlTransformer;
+  const [draftQuantity, setDraftQuantity] = react.useState(1);
+  const { data: productData, isLoading, error, refetch } = useProduct(productId);
+  const { data: cartData } = useCart();
+  const addToCartMutation = useAddToCart();
+  const removeFromCartMutation = useRemoveFromCart();
+  const updateCartMutation = useUpdateCartItem();
+  const processImageUrl = react.useCallback(
+    (url) => {
+      if (!url) return url;
+      if (imageUrlTransformer) {
+        return imageUrlTransformer(url, imageSize);
+      }
+      return url;
+    },
+    [imageUrlTransformer, imageSize]
+  );
+  const product = react.useMemo(() => {
+    if (!productData) return null;
+    const currencyCode = productData.prices?.currency_code;
+    const stockStatus = productData.is_on_backorder ? "onbackorder" : productData.is_in_stock ? "instock" : "outofstock";
+    const lowStockRemaining = productData.low_stock_remaining;
+    const baseImageUrl = getImageUrl(productData.images, imageSize, fallbackImageUrl);
+    const baseImageUrls = getAllImageUrls(productData.images, imageSize);
+    return {
+      id: productData.id,
+      name: productData.name,
+      slug: productData.slug,
+      permalink: productData.permalink,
+      description: productData.description,
+      shortDescription: productData.short_description,
+      sku: productData.sku,
+      imageUrl: processImageUrl(baseImageUrl),
+      imageUrls: baseImageUrls.map((url) => processImageUrl(url) ?? url),
+      price: formatStoreApiPriceIntl(productData.prices?.price, currencyCode, localeTag),
+      regularPrice: formatStoreApiPriceIntl(
+        productData.prices?.regular_price,
+        currencyCode,
+        localeTag
+      ),
+      isOnSale: productData.on_sale,
+      discountPercent: calculateDiscount(
+        productData.prices?.regular_price ?? "0",
+        productData.prices?.price ?? "0"
+      ),
+      discountBadge: productData.on_sale ? `-${calculateDiscount(
+        productData.prices?.regular_price ?? "0",
+        productData.prices?.price ?? "0"
+      )}%` : null,
+      stockStatusText: getStockStatusText(stockStatus, lowStockRemaining ?? void 0, {
+        lowStockThreshold
+      }),
+      isPurchasable: isPurchasable(
+        stockStatus,
+        lowStockRemaining ?? void 0,
+        productData.sold_individually
+      ),
+      isLowStock: isLowStock(stockStatus, lowStockRemaining ?? void 0, lowStockThreshold),
+      maxQuantity: productData.add_to_cart?.maximum ?? 999,
+      minQuantity: productData.add_to_cart?.minimum ?? 1,
+      raw: productData
+    };
+  }, [productData, localeTag, fallbackImageUrl, imageSize, lowStockThreshold, processImageUrl]);
+  const cartItem = react.useMemo(() => {
+    return cartData?.items.find((item) => item.id === productId);
+  }, [cartData?.items, productId]);
+  const cartState = react.useMemo(
+    () => ({
+      isInCart: !!cartItem,
+      quantityInCart: cartItem?.quantity ?? 0,
+      cartItemKey: cartItem?.key ?? null,
+      cartQuantityLimits: cartItem ? {
+        minimum: cartItem.quantity_limits.minimum,
+        maximum: cartItem.quantity_limits.maximum
+      } : null
+    }),
+    [cartItem]
+  );
+  const addToCart = react.useCallback(async () => {
+    await addToCartMutation.mutateAsync({
+      id: productId,
+      quantity: draftQuantity
+    });
+    setDraftQuantity(1);
+  }, [addToCartMutation, productId, draftQuantity]);
+  const removeFromCart = react.useCallback(async () => {
+    if (!cartState.cartItemKey) return;
+    await removeFromCartMutation.mutateAsync({
+      key: cartState.cartItemKey
+    });
+  }, [removeFromCartMutation, cartState.cartItemKey]);
+  const updateCartQuantity = react.useCallback(
+    async (quantity) => {
+      if (!cartState.cartItemKey) return;
+      await updateCartMutation.mutateAsync({
+        key: cartState.cartItemKey,
+        quantity
+      });
+    },
+    [updateCartMutation, cartState.cartItemKey]
+  );
+  const refresh = react.useCallback(async () => {
+    await refetch();
+  }, [refetch]);
+  const isAddingToCart = addToCartMutation.isPending;
+  const isRemovingFromCart = removeFromCartMutation.isPending;
+  const isUpdatingCart = updateCartMutation.isPending;
+  const isCartBusy = isAddingToCart || isRemovingFromCart || isUpdatingCart;
+  return {
+    product,
+    isLoading,
+    error,
+    refresh,
+    cartState,
+    draftQuantity,
+    setDraftQuantity,
+    addToCart,
+    removeFromCart,
+    updateCartQuantity,
+    isAddingToCart,
+    isRemovingFromCart,
+    isUpdatingCart,
+    isCartBusy
+  };
+}
+var PAYMENT_METHOD_TITLES = {
+  cod: "Cash on Delivery",
+  monri: "Monri",
+  bacs: "Bank Transfer",
+  cheque: "Check Payment",
+  paypal: "PayPal",
+  stripe: "Credit Card"
+};
+function formatPaymentMethodTitle(methodId) {
+  const knownTitle = PAYMENT_METHOD_TITLES[methodId];
+  if (knownTitle) {
+    return knownTitle;
+  }
+  return methodId.replace(/[_-]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function useCartView(options = {}) {
+  const { imageSize = "thumbnail" } = options;
+  const storeContext = react.useContext(WooCommerceStoreContext);
+  const storeConfig = storeContext?.config;
+  const localeTag = options.localeTag ?? storeConfig?.locale?.localeTag ?? DEFAULT_STORE_CONFIG.locale.localeTag;
+  const fallbackImageUrl = options.fallbackImageUrl ?? storeConfig?.fallbackImageUrl;
+  const imageUrlTransformer = storeConfig?.imageUrlTransformer;
+  const { data: cartData, isLoading, error, refetch } = useCart();
+  const updateItemMutation = useUpdateCartItem();
+  const removeItemMutation = useRemoveFromCart();
+  const applyCouponMutation = useApplyCoupon();
+  const removeCouponMutation = useRemoveCoupon();
+  const selectShippingMutation = useSelectShippingRate();
+  const getProcessedImageUrl = react.useCallback(
+    (images) => {
+      const baseUrl = getImageUrl(images, imageSize, fallbackImageUrl);
+      if (baseUrl && imageUrlTransformer) {
+        return imageUrlTransformer(baseUrl, imageSize);
+      }
+      return baseUrl;
+    },
+    [imageSize, fallbackImageUrl, imageUrlTransformer]
+  );
+  const items = react.useMemo(() => {
+    if (!cartData?.items) return [];
+    const currencyCode = cartData.totals.currency_code;
+    return cartData.items.map(
+      (item) => ({
+        key: item.key,
+        id: item.id,
+        name: item.name,
+        imageUrl: getProcessedImageUrl(item.images),
+        quantity: item.quantity,
+        minQuantity: item.quantity_limits.minimum,
+        maxQuantity: item.quantity_limits.maximum,
+        lineTotal: formatStoreApiPriceIntl(item.totals.line_total, currencyCode, localeTag),
+        unitPrice: formatStoreApiPriceIntl(item.prices.price, currencyCode, localeTag),
+        raw: item
+      })
+    );
+  }, [cartData?.items, cartData?.totals.currency_code, localeTag, getProcessedImageUrl]);
+  const totals = react.useMemo(() => {
+    if (!cartData?.totals) {
+      return {
+        subtotal: "-",
+        shipping: "-",
+        tax: "-",
+        discount: "-",
+        total: "-",
+        itemCount: 0,
+        currencyCode: "USD"
+      };
+    }
+    const { totals: t } = cartData;
+    const currencyCode = t.currency_code;
+    return {
+      subtotal: formatStoreApiPriceIntl(t.total_items, currencyCode, localeTag),
+      shipping: formatStoreApiPriceIntl(t.total_shipping, currencyCode, localeTag),
+      tax: formatStoreApiPriceIntl(t.total_tax, currencyCode, localeTag),
+      discount: formatStoreApiPriceIntl(t.total_discount, currencyCode, localeTag),
+      total: formatStoreApiPriceIntl(t.total_price, currencyCode, localeTag),
+      itemCount: cartData.items_count,
+      currencyCode
+    };
+  }, [localeTag, cartData]);
+  const coupons = react.useMemo(() => {
+    if (!cartData?.coupons) return [];
+    return cartData.coupons.map((coupon) => ({
+      code: coupon.code,
+      discount: formatStoreApiPriceIntl(
+        coupon.totals.total_discount,
+        coupon.totals.currency_code,
+        localeTag
+      )
+    }));
+  }, [cartData?.coupons, localeTag]);
+  const shippingRates = react.useMemo(() => {
+    if (!cartData?.shipping_rates?.[0]?.shipping_rates) return [];
+    const currencyCode = cartData.totals.currency_code;
+    return cartData.shipping_rates[0].shipping_rates.map((rate) => ({
+      rateId: rate.rate_id,
+      name: rate.name,
+      price: formatStoreApiPriceIntl(rate.price, currencyCode, localeTag),
+      isSelected: rate.selected
+    }));
+  }, [cartData?.shipping_rates, cartData?.totals.currency_code, localeTag]);
+  const paymentMethods = react.useMemo(() => {
+    if (!cartData?.payment_methods) return [];
+    return cartData.payment_methods.map((methodId) => {
+      const title = formatPaymentMethodTitle(methodId);
+      return {
+        id: methodId,
+        title
+      };
+    });
+  }, [cartData?.payment_methods]);
+  const updateItemQuantity = react.useCallback(
+    async (key, quantity) => {
+      await updateItemMutation.mutateAsync({ key, quantity });
+    },
+    [updateItemMutation]
+  );
+  const removeItem = react.useCallback(
+    async (key) => {
+      await removeItemMutation.mutateAsync({ key });
+    },
+    [removeItemMutation]
+  );
+  const applyCoupon = react.useCallback(
+    async (code) => {
+      await applyCouponMutation.mutateAsync({ code });
+    },
+    [applyCouponMutation]
+  );
+  const removeCoupon = react.useCallback(
+    async (code) => {
+      await removeCouponMutation.mutateAsync({ code });
+    },
+    [removeCouponMutation]
+  );
+  const selectShippingRate = react.useCallback(
+    async (rateId, packageId = 0) => {
+      await selectShippingMutation.mutateAsync({
+        rate_id: rateId,
+        package_id: packageId
+      });
+    },
+    [selectShippingMutation]
+  );
+  const refresh = react.useCallback(async () => {
+    await refetch();
+  }, [refetch]);
+  const isUpdatingItem = updateItemMutation.isPending;
+  const isRemovingItem = removeItemMutation.isPending;
+  const isApplyingCoupon = applyCouponMutation.isPending;
+  const isRemovingCoupon = removeCouponMutation.isPending;
+  const isUpdatingShipping = selectShippingMutation.isPending;
+  const isBusy = isUpdatingItem || isRemovingItem || isApplyingCoupon || isRemovingCoupon || isUpdatingShipping;
+  return {
+    items,
+    totals,
+    coupons,
+    shippingRates,
+    paymentMethods,
+    isEmpty: items.length === 0,
+    needsShipping: cartData?.needs_shipping ?? false,
+    raw: cartData,
+    isLoading,
+    error,
+    updateItemQuantity,
+    removeItem,
+    isUpdatingItem,
+    isRemovingItem,
+    applyCoupon,
+    removeCoupon,
+    isApplyingCoupon,
+    isRemovingCoupon,
+    selectShippingRate,
+    isUpdatingShipping,
+    refresh,
+    isBusy
+  };
+}
+
+exports.createQueryKeys = createQueryKeys;
+exports.useAddToCart = useAddToCart;
+exports.useApplyCoupon = useApplyCoupon;
+exports.useCart = useCart;
+exports.useCartView = useCartView;
+exports.useCheckout = useCheckout;
+exports.useInfiniteProducts = useInfiniteProducts;
+exports.useOrder = useOrder;
+exports.useProcessCheckout = useProcessCheckout;
+exports.useProduct = useProduct;
+exports.useProductCategories = useProductCategories;
+exports.useProductCategoryTree = useProductCategoryTree;
+exports.useProductView = useProductView;
+exports.useProducts = useProducts;
+exports.useProductsFeed = useProductsFeed;
+exports.useRemoveCoupon = useRemoveCoupon;
+exports.useRemoveFromCart = useRemoveFromCart;
+exports.useSelectShippingRate = useSelectShippingRate;
+exports.useStore = useStore;
+exports.useStoreFeatures = useStoreFeatures;
+exports.useStoreLocale = useStoreLocale;
+exports.useStoreTheme = useStoreTheme;
+exports.useUpdateCartItem = useUpdateCartItem;
+exports.useUpdateCustomer = useUpdateCustomer;
+exports.useWooCommerceClient = useWooCommerceClient;
+exports.useWooCommerceQueryKeys = useWooCommerceQueryKeys;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map