@simpleapps-com/augur-hooks 0.1.0

package/dist/index.js

@@ -0,0 +1,971 @@
+// src/provider.tsx
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var AugurApiContext = createContext(null);
+function AugurHooksProvider({ api, children }) {
+  return /* @__PURE__ */ jsx(AugurApiContext.Provider, { value: api, children });
+}
+function useAugurApi() {
+  const api = useContext(AugurApiContext);
+  if (!api) {
+    throw new Error(
+      "useAugurApi must be used within an <AugurHooksProvider>. Wrap your app with <AugurHooksProvider api={apiInstance}>."
+    );
+  }
+  return api;
+}
+
+// src/stores/cart-store.ts
+import { create } from "zustand";
+import { devtools } from "zustand/middleware";
+var useCartStore = create()(
+  devtools(
+    (set) => ({
+      cartHdrUid: void 0,
+      cartLines: [],
+      cartItemCount: 0,
+      setCartHdrUid: (cartHdrUid) => set({ cartHdrUid }, false, "setCartHdrUid"),
+      setCartLines: (cartLines) => {
+        const cartItemCount = cartLines.reduce(
+          (sum, line) => sum + (line.quantity || 0),
+          0
+        );
+        set({ cartLines, cartItemCount }, false, "setCartLines");
+      }
+    }),
+    { name: "CartStore", enabled: process.env.NODE_ENV === "development" }
+  )
+);
+var useCartHdrUid = () => useCartStore((s) => s.cartHdrUid);
+var useCartLines = () => useCartStore((s) => s.cartLines);
+var useCartItemCount = () => useCartStore((s) => s.cartItemCount);
+var useSetCartHdrUid = () => useCartStore((s) => s.setCartHdrUid);
+var useSetCartLines = () => useCartStore((s) => s.setCartLines);
+
+// src/stores/items-filters-store.ts
+import { create as create2 } from "zustand";
+import { devtools as devtools2 } from "zustand/middleware";
+var DEFAULT_FILTER_STATE = {
+  filters: [],
+  limit: 12,
+  offset: 0,
+  sortBy: "asc",
+  q: "",
+  page: 1
+};
+var useItemFiltersStore = create2()(
+  devtools2(
+    (set) => ({
+      initialFiltersState: DEFAULT_FILTER_STATE,
+      itemsFilters: DEFAULT_FILTER_STATE,
+      setItemsFilters: (state) => set({ itemsFilters: state }, false, "setItemsFilters")
+    }),
+    {
+      name: "ItemsFiltersStore",
+      enabled: process.env.NODE_ENV === "development"
+    }
+  )
+);
+
+// src/hooks/use-debounce.ts
+import { useEffect, useState } from "react";
+function useDebounce(value, delay = 500) {
+  const [debouncedValue, setDebouncedValue] = useState(value);
+  useEffect(() => {
+    const handler = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      clearTimeout(handler);
+    };
+  }, [value, delay]);
+  return debouncedValue;
+}
+
+// src/hooks/use-format-price.ts
+function useFormatPrice(locale = "en-US", currency = "USD") {
+  const formatPrice = (price) => {
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency,
+      minimumFractionDigits: 2
+    }).format(price);
+  };
+  return { formatPrice };
+}
+
+// src/hooks/use-item-price.ts
+import { useQuery } from "@tanstack/react-query";
+import { CACHE_CONFIG } from "@simpleapps-com/augur-utils";
+var PRICE_CACHE_OPTIONS = {
+  ...CACHE_CONFIG.SEMI_STATIC,
+  refetchOnReconnect: true,
+  refetchOnWindowFocus: false,
+  meta: { persist: true }
+};
+var getItemPriceKey = (itemId, customerId, quantity = 1) => {
+  return ["price", itemId?.toUpperCase() || "", customerId, quantity];
+};
+var getItemPriceOptions = (api, itemId, customerId, quantity = 1) => ({
+  queryKey: getItemPriceKey(itemId, customerId, quantity),
+  queryFn: async () => {
+    const response = await api.pricing.priceEngine.get({
+      itemId: itemId?.toUpperCase() || "",
+      customerId: Number(customerId),
+      quantity
+    });
+    return response.data;
+  },
+  ...PRICE_CACHE_OPTIONS
+});
+function useItemPrice(itemId, customerId, quantity = 1, options = {}) {
+  const api = useAugurApi();
+  const defaultOptions = getItemPriceOptions(api, itemId, customerId, quantity);
+  return useQuery({
+    ...defaultOptions,
+    ...options.queryFn ? { queryFn: options.queryFn } : {},
+    enabled: options.enabled ?? (Boolean(itemId) && Boolean(customerId)),
+    retry: 3
+  });
+}
+
+// src/hooks/use-inv-mast-doc.ts
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+import { CACHE_CONFIG as CACHE_CONFIG2 } from "@simpleapps-com/augur-utils";
+var INV_MAST_DOC_CACHE_OPTIONS = CACHE_CONFIG2.STATIC;
+var getInvMastDocKey = (invMastUid, itemId, includePricing) => {
+  return [
+    "invMastDoc",
+    invMastUid,
+    itemId.toUpperCase(),
+    includePricing
+  ];
+};
+var getInvMastDocOptions = (api, invMastUid, itemId, includePricing) => ({
+  queryKey: getInvMastDocKey(invMastUid, itemId, includePricing),
+  queryFn: async () => {
+    const response = await api.items.invMast.doc.list(invMastUid, {
+      includePricing
+    });
+    if (!response.data) throw new Error("Item not found");
+    return response.data;
+  },
+  ...INV_MAST_DOC_CACHE_OPTIONS
+});
+function useInvMastDoc(invMastUid, itemId, options = {}) {
+  const api = useAugurApi();
+  const queryOpts = getInvMastDocOptions(
+    api,
+    invMastUid,
+    itemId,
+    options.includePricing ?? "N"
+  );
+  const { data, isLoading, error } = useQuery2({
+    ...queryOpts,
+    ...options.queryFn ? { queryFn: options.queryFn } : {},
+    enabled: options.enabled ?? true,
+    initialData: options.initialData
+  });
+  return { item: data, isLoading, error };
+}
+
+// src/hooks/use-item-category.ts
+import { useQuery as useQuery3 } from "@tanstack/react-query";
+import { CACHE_CONFIG as CACHE_CONFIG3 } from "@simpleapps-com/augur-utils";
+var CATEGORY_CACHE_OPTIONS = CACHE_CONFIG3.STATIC;
+var getItemCategoryKey = (itemCategoryUid, apiOptions) => {
+  return ["itemCategory", itemCategoryUid, apiOptions];
+};
+var getItemCategoryOptions = (api, itemCategoryUid, apiOptions) => ({
+  queryKey: getItemCategoryKey(itemCategoryUid, apiOptions),
+  queryFn: async () => {
+    const response = await api.items.itemCategory.get(
+      itemCategoryUid,
+      apiOptions
+    );
+    if (!response.data) throw new Error("Item category not found");
+    return response.data;
+  },
+  ...CATEGORY_CACHE_OPTIONS
+});
+function useItemCategory(itemCategoryUid, options = {}) {
+  const api = useAugurApi();
+  const queryOpts = getItemCategoryOptions(
+    api,
+    itemCategoryUid,
+    options.apiOptions
+  );
+  const { data, isLoading, error } = useQuery3({
+    ...queryOpts,
+    ...options.queryFn ? { queryFn: options.queryFn } : {},
+    enabled: options.enabled ?? true
+  });
+  return { category: data, isLoading, error };
+}
+
+// src/hooks/use-inv-mast.ts
+import { useQuery as useQuery4 } from "@tanstack/react-query";
+import { CACHE_CONFIG as CACHE_CONFIG4 } from "@simpleapps-com/augur-utils";
+var INV_MAST_CACHE_OPTIONS = CACHE_CONFIG4.STATIC;
+var getInvMastKey = (invMastUid, itemId) => {
+  return ["invMast", invMastUid, itemId.toUpperCase()];
+};
+var getInvMastOptions = (api, invMastUid, itemId) => ({
+  queryKey: getInvMastKey(invMastUid, itemId),
+  queryFn: async () => {
+    const response = await api.items.invMast.get(invMastUid);
+    if (!response.data) throw new Error("Item not found");
+    return response.data;
+  },
+  ...INV_MAST_CACHE_OPTIONS
+});
+function useInvMast(invMastUid, itemId, options = {}) {
+  const api = useAugurApi();
+  const queryOpts = getInvMastOptions(api, invMastUid, itemId);
+  const { data, isLoading, error } = useQuery4({
+    ...queryOpts,
+    ...options.queryFn ? { queryFn: options.queryFn } : {},
+    enabled: options.enabled ?? true
+  });
+  return { item: data, isLoading, error };
+}
+
+// src/hooks/use-inv-mast-stock.ts
+import { useQuery as useQuery5 } from "@tanstack/react-query";
+import { CACHE_CONFIG as CACHE_CONFIG5 } from "@simpleapps-com/augur-utils";
+var getInvMastStockKey = (invMastUid) => {
+  return ["invMastStock", invMastUid];
+};
+var getInvMastStockOptions = (api, invMastUid) => ({
+  queryKey: getInvMastStockKey(invMastUid),
+  queryFn: async () => {
+    const response = await api.items.invMast.stock.list(Number(invMastUid));
+    const stockData = response.data?.stockData ?? [];
+    return stockData.reduce(
+      (qty, stock) => qty + stock.qtyOnHand,
+      0
+    );
+  },
+  ...CACHE_CONFIG5.SEMI_STATIC
+});
+function useInvMastStock(invMastUid, options = {}) {
+  const api = useAugurApi();
+  const queryOpts = getInvMastStockOptions(api, invMastUid);
+  const { data, isLoading, error } = useQuery5({
+    ...queryOpts,
+    ...options.queryFn ? { queryFn: options.queryFn } : {},
+    enabled: (options.enabled ?? true) && !!invMastUid,
+    retry: 3,
+    retryDelay: (attemptIndex) => Math.min(1e3 * 2 ** attemptIndex, 1e4)
+  });
+  return {
+    qtyOnHand: data ?? null,
+    loading: isLoading,
+    error
+  };
+}
+
+// src/hooks/use-product-category.ts
+import { useQuery as useQuery6 } from "@tanstack/react-query";
+import { CACHE_CONFIG as CACHE_CONFIG6 } from "@simpleapps-com/augur-utils";
+var getProductCategoryKey = (itemCategoryUid) => {
+  return ["productCategory", itemCategoryUid];
+};
+var getProductCategoryOptions = (api, itemCategoryUid) => ({
+  queryKey: getProductCategoryKey(itemCategoryUid),
+  queryFn: async () => {
+    const response = await api.items.itemCategory.get(
+      Number(itemCategoryUid)
+    );
+    return response.data;
+  },
+  ...CACHE_CONFIG6.STATIC
+});
+function useProductCategory(itemCategoryUid, options = {}) {
+  const api = useAugurApi();
+  const { data, isLoading, error } = useQuery6({
+    ...itemCategoryUid ? getProductCategoryOptions(api, itemCategoryUid) : { queryKey: getProductCategoryKey(null), queryFn: () => Promise.reject() },
+    ...options.queryFn ? { queryFn: options.queryFn } : {},
+    enabled: (options.enabled ?? true) && !!itemCategoryUid,
+    retry: 3,
+    retryDelay: (attemptIndex) => Math.min(1e3 * 2 ** attemptIndex, 1e4)
+  });
+  return {
+    childrenTotal: data?.childrenTotal ?? 0,
+    itemCategoryDesc: data?.itemCategoryDesc ?? "",
+    productCategories: data?.children ?? null,
+    productCategoryImage: data?.categoryImage ?? null,
+    loading: isLoading,
+    error
+  };
+}
+
+// src/hooks/use-item-details.ts
+import { useQuery as useQuery7 } from "@tanstack/react-query";
+import { CACHE_CONFIG as CACHE_CONFIG7 } from "@simpleapps-com/augur-utils";
+var getItemDetailsKey = (itemId) => {
+  return ["itemDetails", itemId];
+};
+var getItemDetailsOptions = (api, itemId) => ({
+  queryKey: getItemDetailsKey(itemId),
+  queryFn: async () => {
+    const response = await api.items.invMast.doc.list(Number(itemId));
+    if (!response.data) throw new Error("Item not found");
+    return response.data;
+  },
+  ...CACHE_CONFIG7.STATIC
+});
+function useItemDetails(itemId, options = {}) {
+  const api = useAugurApi();
+  const { data, isLoading, error } = useQuery7({
+    ...itemId ? getItemDetailsOptions(api, itemId) : { queryKey: getItemDetailsKey(""), queryFn: () => Promise.reject() },
+    ...options.queryFn ? { queryFn: options.queryFn } : {},
+    enabled: (options.enabled ?? true) && !!itemId,
+    retry: 3,
+    retryDelay: (attemptIndex) => Math.min(1e3 * 2 ** attemptIndex, 1e4)
+  });
+  const categoryList = data?.categoryList ?? [];
+  return {
+    itemCategoryUid: categoryList.length > 0 ? categoryList[categoryList.length - 1] : null,
+    itemDetails: data ?? null,
+    loading: isLoading,
+    error
+  };
+}
+
+// src/hooks/use-item-attributes.ts
+import { useQuery as useQuery8 } from "@tanstack/react-query";
+import { CACHE_CONFIG as CACHE_CONFIG8 } from "@simpleapps-com/augur-utils";
+var getItemAttributesKey = (itemCategoryUid) => {
+  return ["itemAttributes", itemCategoryUid];
+};
+var getItemAttributesOptions = (api, itemCategoryUid) => ({
+  queryKey: getItemAttributesKey(itemCategoryUid),
+  queryFn: async () => {
+    const response = await api.openSearch.itemSearch.attributes.list({
+      q: "",
+      searchType: "query",
+      classId5List: String(itemCategoryUid)
+    });
+    return response.data;
+  },
+  ...CACHE_CONFIG8.STATIC
+});
+function useItemAttributes(itemCategoryUid, options = {}) {
+  const api = useAugurApi();
+  const { data, isLoading, error } = useQuery8({
+    ...itemCategoryUid ? getItemAttributesOptions(api, itemCategoryUid) : {
+      queryKey: getItemAttributesKey(null),
+      queryFn: () => Promise.reject()
+    },
+    ...options.queryFn ? { queryFn: options.queryFn } : {},
+    enabled: (options.enabled ?? true) && !!itemCategoryUid,
+    retry: 3,
+    retryDelay: (attemptIndex) => Math.min(1e3 * 2 ** attemptIndex, 1e4)
+  });
+  return {
+    attributes: data?.attributes ?? null,
+    loading: isLoading,
+    error
+  };
+}
+
+// src/hooks/use-product-search.ts
+import { useQuery as useQuery9 } from "@tanstack/react-query";
+import { CACHE_CONFIG as CACHE_CONFIG9 } from "@simpleapps-com/augur-utils";
+var getProductSearchKey = (pageData) => {
+  return [
+    "productSearch",
+    pageData.q,
+    pageData.limit,
+    pageData.offset,
+    pageData.sortBy,
+    pageData.itemCategoryUid
+  ];
+};
+var getProductSearchOptions = (api, pageData) => ({
+  queryKey: getProductSearchKey(pageData),
+  queryFn: async () => {
+    const response = await api.openSearch.itemSearch.list({
+      q: pageData.q,
+      searchType: "query",
+      size: pageData.limit,
+      from: pageData.offset,
+      classId5List: pageData.itemCategoryUid ? String(pageData.itemCategoryUid) : void 0,
+      filters: pageData.filters ? JSON.stringify(pageData.filters) : void 0
+    });
+    return response.data;
+  },
+  ...CACHE_CONFIG9.SEMI_STATIC
+});
+function useProductSearch(pageData, options = {}) {
+  const api = useAugurApi();
+  const defaultOptions = getProductSearchOptions(api, pageData);
+  const { data, isLoading, error } = useQuery9({
+    ...defaultOptions,
+    ...options.queryFn ? { queryFn: options.queryFn } : {},
+    retry: 3,
+    retryDelay: (attemptIndex) => Math.min(1e3 * 2 ** attemptIndex, 1e4)
+  });
+  return {
+    productItems: data?.items ?? null,
+    total: data?.totalResults ?? 0,
+    loading: isLoading,
+    error
+  };
+}
+
+// src/hooks/use-search-suggestions.ts
+import { useQuery as useQuery10 } from "@tanstack/react-query";
+import { CACHE_CONFIG as CACHE_CONFIG10 } from "@simpleapps-com/augur-utils";
+var SEARCH_SUGGESTIONS_CACHE_OPTIONS = CACHE_CONFIG10.STATIC;
+var getSearchSuggestionsKey = (query, limit, offset) => {
+  return ["searchSuggestions", query, limit, offset];
+};
+var getSearchSuggestionsOptions = (api, query, limit = 10, offset = 0) => ({
+  queryKey: getSearchSuggestionsKey(query, limit, offset),
+  queryFn: async () => {
+    const response = await api.openSearch.suggestions.suggest.list({
+      q: query
+    });
+    return response.data;
+  },
+  ...SEARCH_SUGGESTIONS_CACHE_OPTIONS
+});
+function useSearchSuggestions(query, options = {}) {
+  const api = useAugurApi();
+  const limit = options.limit ?? 10;
+  const offset = options.offset ?? 0;
+  const enabled = (options.enabled ?? true) && query.trim().length > 0;
+  const defaultOptions = getSearchSuggestionsOptions(api, query, limit, offset);
+  const { data, isLoading, error } = useQuery10({
+    ...defaultOptions,
+    ...options.queryFn ? { queryFn: options.queryFn } : {},
+    enabled
+  });
+  return {
+    suggestions: data?.data ?? [],
+    total: data?.total ?? 0,
+    isLoading,
+    error
+  };
+}
+
+// src/hooks/use-cart-actions.ts
+import { useCallback } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+function useCartActions(callbacks) {
+  const queryClient = useQueryClient();
+  const cartHdrUid = useCartHdrUid();
+  const cartLines = useCartLines();
+  const setCartLines = useSetCartLines();
+  const notify = callbacks.toast;
+  const cartHdrUidNum = typeof cartHdrUid === "string" ? Number(cartHdrUid) : cartHdrUid;
+  const invalidateCartCache = useCallback(() => {
+    queryClient.invalidateQueries({ queryKey: ["cartLines", cartHdrUid] });
+    queryClient.invalidateQueries({
+      queryKey: ["cart-also-bought", cartHdrUid]
+    });
+  }, [queryClient, cartHdrUid]);
+  const addToCart = useCallback(
+    async (item, options = {}) => {
+      const { showToast = true, itemId = "", onSuccess, onError } = options;
+      if (!cartHdrUidNum) throw new Error("Cart UID is not set");
+      const previousCartLines = [...cartLines];
+      const existingIndex = cartLines.findIndex(
+        (line) => line.invMastUid === item.invMastUid
+      );
+      let optimisticCartLines;
+      if (existingIndex >= 0) {
+        optimisticCartLines = cartLines.map(
+          (line, index) => index === existingIndex ? { ...line, quantity: line.quantity + item.quantity } : line
+        );
+      } else {
+        const newLine = {
+          cartHdrUid: cartHdrUidNum,
+          invMastUid: item.invMastUid,
+          invMastUidCount: 1,
+          isAssembly: "N",
+          itemId,
+          lineNo: cartLines.length + 1,
+          lineNote: null,
+          quantity: item.quantity,
+          unitOfMeasure: item.unitOfMeasure
+        };
+        optimisticCartLines = [...cartLines, newLine];
+      }
+      setCartLines(optimisticCartLines);
+      try {
+        const success = await callbacks.addToCart(cartHdrUidNum, [
+          {
+            cartHdrUid: cartHdrUidNum,
+            invMastUid: item.invMastUid,
+            quantity: item.quantity,
+            unitOfMeasure: item.unitOfMeasure
+          }
+        ]);
+        if (!success) throw new Error("Failed to add item to cart");
+        invalidateCartCache();
+        if (showToast && notify?.info) {
+          notify.info(
+            `${item.quantity} x ${itemId || "Item"} added to cart`
+          );
+        }
+        onSuccess?.();
+        return true;
+      } catch (error) {
+        setCartLines(previousCartLines);
+        if (showToast && notify?.error) {
+          notify.error("Failed to add item to cart. Please try again.");
+        }
+        onError?.(error);
+        return false;
+      }
+    },
+    [cartHdrUid, cartLines, setCartLines, invalidateCartCache, callbacks, notify]
+  );
+  const updateQuantity = useCallback(
+    async (invMastUid, newQuantity, options = {}) => {
+      const { showToast = false, onSuccess, onError } = options;
+      if (!cartHdrUidNum) throw new Error("Cart UID is not set");
+      const previousCartLines = [...cartLines];
+      const optimisticCartLines = cartLines.map(
+        (line) => line.invMastUid === invMastUid ? { ...line, quantity: newQuantity } : line
+      );
+      setCartLines(optimisticCartLines);
+      try {
+        const updatedLines = cartLines.map(
+          (line) => line.invMastUid === invMastUid ? { ...line, quantity: newQuantity } : line
+        );
+        const success = await callbacks.updateCartLines(
+          cartHdrUidNum,
+          updatedLines
+        );
+        if (!success) throw new Error("Failed to update quantity");
+        invalidateCartCache();
+        onSuccess?.();
+        return true;
+      } catch (error) {
+        setCartLines(previousCartLines);
+        if (showToast && notify?.error) {
+          notify.error("Failed to update quantity. Please try again.");
+        }
+        onError?.(error);
+        return false;
+      }
+    },
+    [cartHdrUid, cartLines, setCartLines, invalidateCartCache, callbacks, notify]
+  );
+  const removeFromCart = useCallback(
+    async (invMastUid, options = {}) => {
+      const { showToast = true, itemId = "", onSuccess, onError } = options;
+      if (!cartHdrUidNum) throw new Error("Cart UID is not set");
+      const previousCartLines = [...cartLines];
+      const optimisticCartLines = cartLines.filter(
+        (line) => line.invMastUid !== invMastUid
+      );
+      setCartLines(optimisticCartLines);
+      try {
+        const updatedLines = cartLines.map(
+          (line) => line.invMastUid === invMastUid ? { ...line, quantity: 0 } : line
+        );
+        const success = await callbacks.updateCartLines(
+          cartHdrUidNum,
+          updatedLines
+        );
+        if (!success) throw new Error("Failed to remove item");
+        invalidateCartCache();
+        if (showToast && notify?.info) {
+          notify.info(`${itemId || "Item"} removed from cart`);
+        }
+        onSuccess?.();
+        return true;
+      } catch (error) {
+        setCartLines(previousCartLines);
+        if (showToast && notify?.error) {
+          notify.error("Failed to remove item. Please try again.");
+        }
+        onError?.(error);
+        return false;
+      }
+    },
+    [cartHdrUid, cartLines, setCartLines, invalidateCartCache, callbacks, notify]
+  );
+  const clearCart = useCallback(
+    async (options = {}) => {
+      const { showToast = true, onSuccess, onError } = options;
+      if (!cartHdrUidNum) throw new Error("Cart UID is not set");
+      const previousCartLines = [...cartLines];
+      setCartLines([]);
+      try {
+        const success = await callbacks.deleteItemsFromCart(cartHdrUidNum);
+        if (!success) throw new Error("Failed to clear cart");
+        invalidateCartCache();
+        if (showToast && notify?.info) {
+          notify.info("Cart cleared");
+        }
+        onSuccess?.();
+        return true;
+      } catch (error) {
+        setCartLines(previousCartLines);
+        if (showToast && notify?.error) {
+          notify.error("Failed to clear cart. Please try again.");
+        }
+        onError?.(error);
+        return false;
+      }
+    },
+    [cartHdrUid, cartLines, setCartLines, invalidateCartCache, callbacks, notify]
+  );
+  const isInCart = useCallback(
+    (invMastUid) => {
+      return cartLines.some((line) => line.invMastUid === invMastUid);
+    },
+    [cartLines]
+  );
+  const getItemQuantity = useCallback(
+    (invMastUid) => {
+      return cartLines.find((line) => line.invMastUid === invMastUid)?.quantity ?? 0;
+    },
+    [cartLines]
+  );
+  return {
+    addToCart,
+    updateQuantity,
+    removeFromCart,
+    clearCart,
+    isInCart,
+    getItemQuantity,
+    cartHdrUid,
+    cartLines,
+    invalidateCartCache
+  };
+}
+
+// src/hooks/use-cart-initialization.ts
+import { useEffect as useEffect2, useRef } from "react";
+import { useQuery as useQuery11 } from "@tanstack/react-query";
+import { CACHE_CONFIG as CACHE_CONFIG11 } from "@simpleapps-com/augur-utils";
+var MAX_RETRY_ATTEMPTS = 7;
+var RETRY_DELAY_MS = 1e3;
+function useCartInitialization(session, callbacks) {
+  const cartHdrUid = useCartHdrUid();
+  const setCartHdrUid = useSetCartHdrUid();
+  const setCartLines = useSetCartLines();
+  const retryCountRef = useRef(0);
+  const isInitializingRef = useRef(false);
+  useEffect2(() => {
+    if (cartHdrUid || session.status === "loading") return;
+    if (session.cartHdrUid && session.status === "authenticated") {
+      setCartHdrUid(session.cartHdrUid);
+      return;
+    }
+    if (session.status === "unauthenticated" && !isInitializingRef.current) {
+      isInitializingRef.current = true;
+      retryCountRef.current = 0;
+      const initializeGuestCart = async () => {
+        const existingToken = callbacks.getCartToken();
+        const cartToken = existingToken && typeof existingToken === "string" ? existingToken : callbacks.generateCartToken();
+        while (retryCountRef.current < MAX_RETRY_ATTEMPTS) {
+          try {
+            const cartHdr = await callbacks.cartHdrLookup("0", cartToken);
+            if (cartHdr && cartHdr.cartHdrUid !== 0) {
+              callbacks.saveCartToken(cartToken);
+              setCartHdrUid(cartHdr.cartHdrUid);
+              isInitializingRef.current = false;
+              return;
+            }
+            retryCountRef.current++;
+            if (retryCountRef.current < MAX_RETRY_ATTEMPTS) {
+              const delay = Math.min(
+                RETRY_DELAY_MS * Math.pow(1.5, retryCountRef.current),
+                1e4
+              );
+              await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+          } catch (error) {
+            console.error(
+              `Cart initialization attempt ${retryCountRef.current + 1} failed:`,
+              error
+            );
+            retryCountRef.current++;
+            if (retryCountRef.current < MAX_RETRY_ATTEMPTS) {
+              const delay = Math.min(
+                RETRY_DELAY_MS * Math.pow(1.5, retryCountRef.current),
+                1e4
+              );
+              await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+          }
+        }
+        console.error(
+          `Cart initialization failed after ${MAX_RETRY_ATTEMPTS} attempts`
+        );
+        isInitializingRef.current = false;
+      };
+      initializeGuestCart();
+    }
+  }, [session, cartHdrUid, setCartHdrUid, callbacks]);
+  const { data: cartLinesData } = useQuery11({
+    queryKey: ["cartLines", cartHdrUid],
+    queryFn: () => callbacks.getCartLines(Number(cartHdrUid)),
+    enabled: !!cartHdrUid,
+    ...CACHE_CONFIG11.CART
+  });
+  useEffect2(() => {
+    if (cartLinesData) {
+      setCartLines(cartLinesData);
+    }
+  }, [cartLinesData, setCartLines]);
+  return {
+    cartHdrUid,
+    isInitializing: isInitializingRef.current,
+    retryCount: retryCountRef.current
+  };
+}
+
+// src/hooks/use-cart-pricing.ts
+import { useMemo } from "react";
+import { useQueries } from "@tanstack/react-query";
+function useCartPricing(options = {}) {
+  const api = useAugurApi();
+  const cartLines = useCartLines();
+  const { customerId } = options;
+  const priceQueries = useQueries({
+    queries: cartLines.map((line) => ({
+      ...getItemPriceOptions(api, line.itemId, customerId, line.quantity),
+      enabled: !!customerId && !!line.itemId
+    }))
+  });
+  const prices = useMemo(() => {
+    const map = {};
+    cartLines.forEach((line, index) => {
+      const queryResult = priceQueries[index];
+      if (queryResult?.data) {
+        map[line.itemId.toUpperCase()] = {
+          unitPrice: queryResult.data.unitPrice ?? 0,
+          priceData: queryResult.data
+        };
+      }
+    });
+    return map;
+  }, [cartLines, priceQueries]);
+  const getUnitPrice = useMemo(() => {
+    return (itemId) => {
+      return prices[itemId?.toUpperCase()]?.unitPrice ?? 0;
+    };
+  }, [prices]);
+  const getItemTotal = useMemo(() => {
+    return (itemId, quantity) => {
+      return getUnitPrice(itemId) * quantity;
+    };
+  }, [getUnitPrice]);
+  const subtotal = useMemo(() => {
+    return cartLines.reduce((sum, line) => {
+      const unitPrice = prices[line.itemId.toUpperCase()]?.unitPrice ?? 0;
+      return sum + unitPrice * line.quantity;
+    }, 0);
+  }, [cartLines, prices]);
+  const isLoading = priceQueries.some((q) => q.isLoading);
+  const isSuccess = priceQueries.every((q) => q.isSuccess);
+  const isError = priceQueries.some((q) => q.isError);
+  return {
+    prices,
+    getUnitPrice,
+    getItemTotal,
+    subtotal,
+    isLoading,
+    isSuccess,
+    isError
+  };
+}
+function getCartPricingQueryOptions(api, cartLines, customerId) {
+  return cartLines.map((line) => ({
+    ...getItemPriceOptions(api, line.itemId, customerId, line.quantity),
+    enabled: !!customerId && !!line.itemId
+  }));
+}
+
+// src/hooks/use-pagination-prefetch.ts
+import { useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+import { useCallback as useCallback2 } from "react";
+var usePaginationPrefetch = ({
+  queryKey,
+  queryFn,
+  pageSize,
+  staleTime = 10 * 60 * 1e3,
+  gcTime = 30 * 60 * 1e3,
+  enabled = true
+}) => {
+  const queryClient = useQueryClient2();
+  const prefetchPage = useCallback2(
+    async (page) => {
+      if (!enabled) return;
+      const offset = (page - 1) * pageSize;
+      try {
+        await queryClient.prefetchQuery({
+          queryKey: [...queryKey, offset],
+          queryFn: () => queryFn(offset),
+          staleTime,
+          gcTime
+        });
+      } catch (error) {
+        console.warn(`Error prefetching page ${page}:`, error);
+      }
+    },
+    [queryKey, queryFn, pageSize, staleTime, gcTime, queryClient, enabled]
+  );
+  const handlePaginationHover = useCallback2(
+    (page) => {
+      const timeoutId = setTimeout(() => prefetchPage(page), 150);
+      return () => clearTimeout(timeoutId);
+    },
+    [prefetchPage]
+  );
+  return {
+    prefetchPage,
+    handlePaginationHover
+  };
+};
+
+// src/hooks/use-category-items-infinite.ts
+import { useInfiniteQuery } from "@tanstack/react-query";
+import {
+  CACHE_CONFIG as CACHE_CONFIG12
+} from "@simpleapps-com/augur-utils";
+var getCategoryItemsInfiniteKey = (itemCategoryUid, itemsFilters) => {
+  return [
+    "categoryItemsInfinite",
+    itemCategoryUid,
+    JSON.stringify(itemsFilters)
+  ];
+};
+function useCategoryItemsInfinite(itemCategoryUid, itemsFilters, options = {}) {
+  const api = useAugurApi();
+  const { enabled = true } = options;
+  return useInfiniteQuery({
+    queryKey: getCategoryItemsInfiniteKey(itemCategoryUid, itemsFilters),
+    queryFn: async ({ pageParam = 0 }) => {
+      const response = await api.openSearch.itemSearch.list({
+        q: itemsFilters.q || "",
+        searchType: "query",
+        size: itemsFilters.limit,
+        from: pageParam,
+        classId5List: String(itemCategoryUid),
+        filters: itemsFilters.filters?.length ? JSON.stringify(itemsFilters.filters) : void 0
+      });
+      const items = response.data?.items ?? [];
+      const total = response.data?.totalResults ?? 0;
+      const nextOffset = pageParam + itemsFilters.limit;
+      return {
+        data: items,
+        total,
+        nextCursor: nextOffset < total ? nextOffset : void 0
+      };
+    },
+    initialPageParam: 0,
+    getNextPageParam: (lastPage) => lastPage.nextCursor,
+    ...CACHE_CONFIG12.SEMI_STATIC,
+    enabled: enabled && !!itemCategoryUid
+  });
+}
+
+// src/hooks/use-item-search-infinite.ts
+import { useInfiniteQuery as useInfiniteQuery2 } from "@tanstack/react-query";
+import {
+  CACHE_CONFIG as CACHE_CONFIG13
+} from "@simpleapps-com/augur-utils";
+var getItemSearchInfiniteKey = (itemsFilters, itemCategoryUid) => {
+  return [
+    "itemSearchInfinite",
+    JSON.stringify(itemsFilters),
+    itemCategoryUid
+  ];
+};
+function useItemSearchInfinite(itemsFilters, itemCategoryUid, options = {}) {
+  const api = useAugurApi();
+  const { enabled = true } = options;
+  return useInfiniteQuery2({
+    queryKey: getItemSearchInfiniteKey(itemsFilters, itemCategoryUid),
+    queryFn: async ({ pageParam = 0 }) => {
+      const response = await api.openSearch.itemSearch.list({
+        q: itemsFilters.q,
+        searchType: "query",
+        size: itemsFilters.limit,
+        from: pageParam,
+        classId5List: itemCategoryUid ? String(itemCategoryUid) : void 0,
+        filters: itemsFilters.filters?.length ? JSON.stringify(itemsFilters.filters) : void 0
+      });
+      const items = response.data?.items ?? [];
+      const total = response.data?.totalResults ?? 0;
+      const nextOffset = pageParam + itemsFilters.limit;
+      return {
+        data: items,
+        total,
+        nextCursor: nextOffset < total ? nextOffset : void 0
+      };
+    },
+    initialPageParam: 0,
+    getNextPageParam: (lastPage) => lastPage.nextCursor,
+    ...CACHE_CONFIG13.SEMI_STATIC,
+    enabled: enabled && !!itemsFilters.q,
+    meta: { persist: true }
+  });
+}
+export {
+  AugurHooksProvider,
+  CATEGORY_CACHE_OPTIONS,
+  INV_MAST_CACHE_OPTIONS,
+  INV_MAST_DOC_CACHE_OPTIONS,
+  PRICE_CACHE_OPTIONS,
+  getCartPricingQueryOptions,
+  getCategoryItemsInfiniteKey,
+  getInvMastDocKey,
+  getInvMastDocOptions,
+  getInvMastKey,
+  getInvMastOptions,
+  getInvMastStockKey,
+  getInvMastStockOptions,
+  getItemAttributesKey,
+  getItemAttributesOptions,
+  getItemCategoryKey,
+  getItemCategoryOptions,
+  getItemDetailsKey,
+  getItemDetailsOptions,
+  getItemPriceKey,
+  getItemPriceOptions,
+  getItemSearchInfiniteKey,
+  getProductCategoryKey,
+  getProductCategoryOptions,
+  getProductSearchKey,
+  getProductSearchOptions,
+  getSearchSuggestionsKey,
+  getSearchSuggestionsOptions,
+  useAugurApi,
+  useCartActions,
+  useCartHdrUid,
+  useCartInitialization,
+  useCartItemCount,
+  useCartLines,
+  useCartPricing,
+  useCartStore,
+  useCategoryItemsInfinite,
+  useDebounce,
+  useFormatPrice,
+  useInvMast,
+  useInvMastDoc,
+  useInvMastStock,
+  useItemAttributes,
+  useItemCategory,
+  useItemDetails,
+  useItemFiltersStore,
+  useItemPrice,
+  useItemSearchInfinite,
+  usePaginationPrefetch,
+  useProductCategory,
+  useProductSearch,
+  useSearchSuggestions,
+  useSetCartHdrUid,
+  useSetCartLines
+};
+//# sourceMappingURL=index.js.map