@atomic-solutions/woocommerce-react 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1712 @@
+'use strict';
+
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var woocommerceUtils = require('@atomic-solutions/woocommerce-utils');
+var reactQuery = require('@tanstack/react-query');
+
+// src/provider/WooCommerceProvider.tsx
+var EventContext = react.createContext(null);
+var useEventEmitter = () => {
+  return react.useContext(EventContext);
+};
+var WooCommerceContext = react.createContext(null);
+var WooCommerceProvider = ({
+  client,
+  queryKeys,
+  onEvent,
+  children
+}) => {
+  const contextValue = react.useMemo(() => ({ client, queryKeys }), [client, queryKeys]);
+  return /* @__PURE__ */ jsxRuntime.jsx(WooCommerceContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxRuntime.jsx(EventContext.Provider, { value: onEvent ?? null, children }) });
+};
+
+// src/guardrails/storeValidator.ts
+function normalizeStoreUrl(url) {
+  let normalized = url.trim();
+  if (!normalized.startsWith("http://") && !normalized.startsWith("https://")) {
+    normalized = `https://${normalized}`;
+  }
+  normalized = normalized.replace(/\/+$/, "");
+  normalized = normalized.replace(/\/wp-json\/?$/, "");
+  return `${normalized}/wp-json`;
+}
+function getBaseUrl(normalizedUrl) {
+  return normalizedUrl.replace(/\/wp-json\/?$/, "");
+}
+async function validateWooCommerceStore(url, options = {}) {
+  const { timeout = 1e4, allowLocalhost = process.env.NODE_ENV !== "production" } = options;
+  try {
+    const normalizedUrl = normalizeStoreUrl(url);
+    const baseUrl = getBaseUrl(normalizedUrl);
+    const isLocalhost = baseUrl.includes("localhost") || baseUrl.includes("127.0.0.1");
+    if (isLocalhost && !allowLocalhost) {
+      return {
+        valid: false,
+        error: "Localhost URLs are not allowed in production"
+      };
+    }
+    const storeApiUrl = `${normalizedUrl}/wc/store/v1`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    let response;
+    try {
+      response = await fetch(storeApiUrl, {
+        method: "GET",
+        headers: {
+          "User-Agent": "@atomic-solutions/react-native-woocommerce",
+          Accept: "application/json"
+        },
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timeoutId);
+    }
+    if (response.status === 404) {
+      return {
+        valid: false,
+        error: "WooCommerce Store API not found. Ensure WooCommerce is installed and REST API is enabled."
+      };
+    }
+    if (response.status === 401 || response.status === 403) {
+      return {
+        valid: false,
+        error: "Access denied. Check that the REST API is publicly accessible for the Store API."
+      };
+    }
+    if (!response.ok) {
+      return {
+        valid: false,
+        error: `Unexpected response: ${response.status} ${response.statusText}`
+      };
+    }
+    let storeName;
+    let wcVersion;
+    try {
+      const rootResponse = await fetch(normalizedUrl, {
+        method: "GET",
+        headers: {
+          Accept: "application/json"
+        }
+      });
+      if (rootResponse.ok) {
+        const rootData = await rootResponse.json();
+        storeName = rootData.name;
+        if (rootData.namespaces) {
+          const hasWcNamespace = rootData.namespaces.some(
+            (ns) => ns.startsWith("wc/") || ns === "wc"
+          );
+          if (!hasWcNamespace) {
+            return {
+              valid: false,
+              error: "WooCommerce REST API namespace not found. Is WooCommerce installed?"
+            };
+          }
+        }
+      }
+    } catch {
+    }
+    return {
+      valid: true,
+      storeName: storeName || "WooCommerce Store",
+      storeUrl: normalizedUrl,
+      wcVersion
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        return {
+          valid: false,
+          error: `Connection timed out after ${timeout}ms`
+        };
+      }
+      if (error.message.includes("Network request failed")) {
+        return {
+          valid: false,
+          error: "Unable to connect to the store. Check the URL and your internet connection."
+        };
+      }
+      return {
+        valid: false,
+        error: error.message
+      };
+    }
+    return {
+      valid: false,
+      error: "An unexpected error occurred while validating the store"
+    };
+  }
+}
+function isValidStoreUrlFormat(url) {
+  if (!url || typeof url !== "string") {
+    return false;
+  }
+  const trimmed = url.trim();
+  if (trimmed.length === 0) {
+    return false;
+  }
+  try {
+    const normalized = normalizeStoreUrl(trimmed);
+    new URL(normalized);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/guardrails/rateLimiter.ts
+var DEFAULT_CONFIG = {
+  requestsPerSecond: 10,
+  requestsPerMinute: 60,
+  burstLimit: 20
+};
+var RateLimiter = class {
+  constructor(config = {}) {
+    // tokens per millisecond
+    this.queue = [];
+    this.isProcessing = false;
+    const mergedConfig = { ...DEFAULT_CONFIG, ...config };
+    this.maxTokens = mergedConfig.burstLimit;
+    this.tokens = this.maxTokens;
+    this.refillRate = mergedConfig.requestsPerSecond / 1e3;
+    this.lastRefill = Date.now();
+  }
+  /**
+   * Refills tokens based on elapsed time
+   */
+  refill() {
+    const now = Date.now();
+    const elapsed = now - this.lastRefill;
+    const tokensToAdd = elapsed * this.refillRate;
+    this.tokens = Math.min(this.maxTokens, this.tokens + tokensToAdd);
+    this.lastRefill = now;
+  }
+  /**
+   * Process queued requests
+   */
+  async processQueue() {
+    if (this.isProcessing) {
+      return;
+    }
+    this.isProcessing = true;
+    while (this.queue.length > 0) {
+      this.refill();
+      if (this.tokens >= 1) {
+        this.tokens -= 1;
+        const request = this.queue.shift();
+        request?.resolve();
+      } else {
+        const waitTime = Math.ceil((1 - this.tokens) / this.refillRate);
+        await this.sleep(waitTime);
+      }
+    }
+    this.isProcessing = false;
+  }
+  /**
+   * Sleep for specified milliseconds
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Acquire a token before making a request
+   * Returns immediately if tokens available, otherwise queues the request
+   *
+   * @returns Promise that resolves when request can proceed
+   */
+  acquire() {
+    return new Promise((resolve, reject) => {
+      this.refill();
+      if (this.tokens >= 1) {
+        this.tokens -= 1;
+        resolve();
+      } else {
+        this.queue.push({ resolve, reject });
+        this.processQueue();
+      }
+    });
+  }
+  /**
+   * Try to acquire a token without waiting
+   *
+   * @returns true if token was acquired, false if rate limited
+   */
+  tryAcquire() {
+    this.refill();
+    if (this.tokens >= 1) {
+      this.tokens -= 1;
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get current number of available tokens
+   */
+  getAvailableTokens() {
+    this.refill();
+    return Math.floor(this.tokens);
+  }
+  /**
+   * Get number of queued requests
+   */
+  getQueueLength() {
+    return this.queue.length;
+  }
+  /**
+   * Clear all queued requests (rejects them)
+   */
+  clearQueue() {
+    while (this.queue.length > 0) {
+      const request = this.queue.shift();
+      request?.reject(new Error("Rate limiter queue cleared"));
+    }
+  }
+  /**
+   * Reset the rate limiter to initial state
+   */
+  reset() {
+    this.clearQueue();
+    this.tokens = this.maxTokens;
+    this.lastRefill = Date.now();
+  }
+};
+var globalRateLimiter = null;
+function getGlobalRateLimiter(config) {
+  if (!globalRateLimiter) {
+    globalRateLimiter = new RateLimiter(config);
+  }
+  return globalRateLimiter;
+}
+function configureGlobalRateLimiter(config) {
+  if (globalRateLimiter) {
+    globalRateLimiter.clearQueue();
+  }
+  globalRateLimiter = new RateLimiter(config);
+}
+function resetGlobalRateLimiter() {
+  globalRateLimiter?.clearQueue();
+  globalRateLimiter = null;
+}
+
+// src/provider/types.ts
+var DEFAULT_STORE_CONFIG = {
+  features: {
+    auth: false,
+    wishlist: false,
+    reviews: true,
+    search: true,
+    categories: true
+  },
+  locale: {
+    localeTag: "en-US",
+    currency: "USD",
+    currencyPosition: "before",
+    thousandsSeparator: ",",
+    decimalSeparator: ".",
+    decimals: 2
+  },
+  guardrails: {
+    validateStore: true,
+    rateLimit: {
+      requestsPerMinute: 60,
+      requestsPerSecond: 10,
+      burstLimit: 20
+    }
+  },
+  debug: process.env.NODE_ENV !== "production"
+};
+var WooCommerceStoreContext = react.createContext(null);
+WooCommerceStoreContext.displayName = "WooCommerceStoreContext";
+var PACKAGE_VERSION = "0.1.0";
+function createCartHeadersAdapter() {
+  let headers = {};
+  return {
+    get: async () => headers,
+    save: async (newHeaders) => {
+      headers = { ...headers, ...newHeaders };
+    },
+    clear: async () => {
+      headers = {};
+    }
+  };
+}
+function WooCommerceStoreProvider({
+  config,
+  queryKeys,
+  children,
+  skipValidation = false,
+  loadingFallback = null,
+  errorFallback
+}) {
+  const [isValidating, setIsValidating] = react.useState(!skipValidation);
+  const [isValidated, setIsValidated] = react.useState(skipValidation);
+  const [validationResult, setValidationResult] = react.useState(
+    skipValidation ? { valid: true, storeUrl: normalizeStoreUrl(config.storeUrl) } : void 0
+  );
+  const [validationError, setValidationError] = react.useState();
+  const mergedConfig = react.useMemo(
+    () => ({
+      ...config,
+      features: { ...DEFAULT_STORE_CONFIG.features, ...config.features },
+      locale: { ...DEFAULT_STORE_CONFIG.locale, ...config.locale },
+      guardrails: { ...DEFAULT_STORE_CONFIG.guardrails, ...config.guardrails },
+      debug: config.debug ?? DEFAULT_STORE_CONFIG.debug
+    }),
+    [config]
+  );
+  react.useEffect(() => {
+    if (mergedConfig.guardrails.rateLimit) {
+      configureGlobalRateLimiter(mergedConfig.guardrails.rateLimit);
+    }
+  }, [mergedConfig.guardrails.rateLimit]);
+  const cartHeadersAdapter = react.useRef(createCartHeadersAdapter());
+  const client = react.useMemo(() => {
+    const normalizedUrl = normalizeStoreUrl(config.storeUrl);
+    return woocommerceUtils.createClient({
+      baseURL: normalizedUrl,
+      storeApiVersion: "v1",
+      cartHeaders: cartHeadersAdapter.current,
+      validationMode: "warn",
+      debug: mergedConfig.debug,
+      headers: {
+        "User-Agent": `@atomic-solutions/react-native-woocommerce/${PACKAGE_VERSION}`,
+        "X-WC-Client": "atomic-woocommerce",
+        "X-WC-Client-Version": PACKAGE_VERSION
+      },
+      onRequest: async (requestConfig) => {
+        const rateLimiter = getGlobalRateLimiter();
+        await rateLimiter.acquire();
+        return requestConfig;
+      },
+      onError: (error) => {
+        if (mergedConfig.debug) {
+          console.error("[WooCommerceStore] API Error:", error);
+        }
+      }
+    });
+  }, [config.storeUrl, mergedConfig.debug]);
+  const validateStore = react.useCallback(async () => {
+    if (skipValidation) {
+      return;
+    }
+    setIsValidating(true);
+    setValidationError(void 0);
+    try {
+      const result = await validateWooCommerceStore(config.storeUrl, {
+        allowLocalhost: process.env.NODE_ENV !== "production"
+      });
+      setValidationResult(result);
+      if (result.valid) {
+        setIsValidated(true);
+        setValidationError(void 0);
+        if (mergedConfig.debug) {
+          console.log("[WooCommerceStore] Connected to:", result.storeName);
+        }
+      } else {
+        setIsValidated(false);
+        setValidationError(result.error);
+        if (mergedConfig.debug) {
+          console.warn("[WooCommerceStore] Validation failed:", result.error);
+        }
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      setValidationError(errorMessage);
+      setIsValidated(false);
+    } finally {
+      setIsValidating(false);
+    }
+  }, [config.storeUrl, skipValidation, mergedConfig.debug]);
+  react.useEffect(() => {
+    if (mergedConfig.guardrails.validateStore) {
+      validateStore();
+    } else {
+      setIsValidated(true);
+      setIsValidating(false);
+    }
+  }, [validateStore, mergedConfig.guardrails.validateStore]);
+  const contextValue = react.useMemo(
+    () => ({
+      config: mergedConfig,
+      isValidated,
+      isValidating,
+      validationError,
+      validationResult,
+      revalidate: validateStore
+    }),
+    [mergedConfig, isValidated, isValidating, validationError, validationResult, validateStore]
+  );
+  if (isValidating && loadingFallback) {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: loadingFallback });
+  }
+  if (validationError && errorFallback) {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: errorFallback(validationError, validateStore) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(WooCommerceStoreContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxRuntime.jsx(WooCommerceProvider, { client, queryKeys, onEvent: config.onEvent, children }) });
+}
+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
+  };
+};
+
+// 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)
+  }
+});
+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/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));
+}
+var PLACEHOLDER_IMAGE_URL = "https://via.placeholder.com/300x300.png?text=No+Image";
+function getImageUrlOrPlaceholder(images, size = "medium") {
+  return getImageUrl(images, size, PLACEHOLDER_IMAGE_URL) ?? PLACEHOLDER_IMAGE_URL;
+}
+async function preloadImage(_url) {
+  return Promise.resolve();
+}
+async function preloadImages(urls) {
+  await Promise.all(urls.map(preloadImage));
+}
+
+// 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 formatPriceRange(minPrice, maxPrice, locale = {}) {
+  const min = typeof minPrice === "string" ? parseFloat(minPrice) : minPrice;
+  const max = typeof maxPrice === "string" ? parseFloat(maxPrice) : maxPrice;
+  if (isNaN(min) || isNaN(max)) {
+    return "";
+  }
+  if (min === max) {
+    return formatPrice(min, locale);
+  }
+  return `${formatPrice(min, locale)} - ${formatPrice(max, locale)}`;
+}
+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 formatStoreApiPrice(priceInMinorUnits, currencyCode, locale = {}) {
+  if (!priceInMinorUnits || !currencyCode) {
+    return "-";
+  }
+  const cents = parseInt(priceInMinorUnits, 10);
+  if (isNaN(cents)) {
+    return "-";
+  }
+  const decimalPrice = cents / 100;
+  return formatPrice(decimalPrice, { ...locale, currency: currencyCode });
+}
+function formatDiscountBadge(regularPrice, salePrice) {
+  const discount = calculateDiscount(regularPrice, salePrice);
+  return discount ? `-${discount}%` : null;
+}
+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 });
+  }
+}
+function parseWooCommercePrice(priceString) {
+  if (!priceString || typeof priceString !== "string") {
+    return NaN;
+  }
+  const cleaned = priceString.replace(/[^\d.,-]/g, "").trim();
+  if (cleaned.includes(",") && cleaned.includes(".")) {
+    const lastComma = cleaned.lastIndexOf(",");
+    const lastDot = cleaned.lastIndexOf(".");
+    if (lastComma > lastDot) {
+      return parseFloat(cleaned.replace(/\./g, "").replace(",", "."));
+    } else {
+      return parseFloat(cleaned.replace(/,/g, ""));
+    }
+  }
+  if (cleaned.includes(",") && !cleaned.includes(".")) {
+    const commaPos = cleaned.lastIndexOf(",");
+    const afterComma = cleaned.length - commaPos - 1;
+    if (afterComma <= 2) {
+      return parseFloat(cleaned.replace(",", "."));
+    }
+    return parseFloat(cleaned.replace(/,/g, ""));
+  }
+  return parseFloat(cleaned.replace(/,/g, ""));
+}
+
+// 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
+  };
+}
+
+// src/utils/stock.ts
+var DEFAULT_CONFIG2 = {
+  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_CONFIG2, ...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 getStockSeverity(status, quantity, lowStockThreshold = 5) {
+  switch (status) {
+    case "outofstock":
+      return "error";
+    case "onbackorder":
+      return "info";
+    case "instock":
+      if (quantity !== null && quantity !== void 0 && quantity <= lowStockThreshold && quantity > 0) {
+        return "warning";
+      }
+      return "success";
+    default:
+      return "info";
+  }
+}
+function isLowStock(status, quantity, threshold = 5) {
+  return status === "instock" && quantity !== null && quantity !== void 0 && quantity <= threshold && quantity > 0;
+}
+function getMaxAddToCartQuantity(status, stockQuantity, cartQuantity = 0, maxPurchaseQuantity) {
+  if (status === "outofstock") {
+    return 0;
+  }
+  if (status === "onbackorder") {
+    return maxPurchaseQuantity ?? 999;
+  }
+  let maxQty = stockQuantity ?? 999;
+  if (maxPurchaseQuantity && maxPurchaseQuantity < maxQty) {
+    maxQty = maxPurchaseQuantity;
+  }
+  return Math.max(0, maxQty - cartQuantity);
+}
+
+// src/hooks/useProductView.ts
+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
+  };
+}
+
+Object.defineProperty(exports, "addressSchema", {
+  enumerable: true,
+  get: function () { return woocommerceUtils.addressSchema; }
+});
+Object.defineProperty(exports, "checkoutSchema", {
+  enumerable: true,
+  get: function () { return woocommerceUtils.checkoutSchema; }
+});
+exports.DEFAULT_STORE_CONFIG = DEFAULT_STORE_CONFIG;
+exports.PLACEHOLDER_IMAGE_URL = PLACEHOLDER_IMAGE_URL;
+exports.RateLimiter = RateLimiter;
+exports.WooCommerceContext = WooCommerceContext;
+exports.WooCommerceProvider = WooCommerceProvider;
+exports.WooCommerceStoreContext = WooCommerceStoreContext;
+exports.WooCommerceStoreProvider = WooCommerceStoreProvider;
+exports.calculateDiscount = calculateDiscount;
+exports.configureGlobalRateLimiter = configureGlobalRateLimiter;
+exports.createQueryKeys = createQueryKeys;
+exports.formatDiscountBadge = formatDiscountBadge;
+exports.formatPrice = formatPrice;
+exports.formatPriceRange = formatPriceRange;
+exports.formatStoreApiPrice = formatStoreApiPrice;
+exports.formatStoreApiPriceIntl = formatStoreApiPriceIntl;
+exports.getAllImageUrls = getAllImageUrls;
+exports.getBaseUrl = getBaseUrl;
+exports.getCurrencySymbol = getCurrencySymbol;
+exports.getGlobalRateLimiter = getGlobalRateLimiter;
+exports.getImageUrl = getImageUrl;
+exports.getImageUrlOrPlaceholder = getImageUrlOrPlaceholder;
+exports.getMaxAddToCartQuantity = getMaxAddToCartQuantity;
+exports.getPrimaryImage = getPrimaryImage;
+exports.getSizedImageUrl = getSizedImageUrl;
+exports.getStockSeverity = getStockSeverity;
+exports.getStockStatusText = getStockStatusText;
+exports.isLowStock = isLowStock;
+exports.isPurchasable = isPurchasable;
+exports.isValidStoreUrlFormat = isValidStoreUrlFormat;
+exports.normalizeStoreUrl = normalizeStoreUrl;
+exports.parseWooCommercePrice = parseWooCommercePrice;
+exports.preloadImage = preloadImage;
+exports.preloadImages = preloadImages;
+exports.resetGlobalRateLimiter = resetGlobalRateLimiter;
+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;
+exports.validateWooCommerceStore = validateWooCommerceStore;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map