@simpleapps-com/augur-hooks 0.1.0

package/dist/index.cjs

@@ -0,0 +1,971 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/provider.tsx
+var _react = require('react');
+var _jsxruntime = require('react/jsx-runtime');
+var AugurApiContext = _react.createContext.call(void 0, null);
+function AugurHooksProvider({ api, children }) {
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, AugurApiContext.Provider, { value: api, children });
+}
+function useAugurApi() {
+  const api = _react.useContext.call(void 0, 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
+var _zustand = require('zustand');
+var _middleware = require('zustand/middleware');
+var useCartStore = _zustand.create.call(void 0, )(
+  _middleware.devtools.call(void 0, 
+    (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
+
+
+var DEFAULT_FILTER_STATE = {
+  filters: [],
+  limit: 12,
+  offset: 0,
+  sortBy: "asc",
+  q: "",
+  page: 1
+};
+var useItemFiltersStore = _zustand.create.call(void 0, )(
+  _middleware.devtools.call(void 0, 
+    (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
+
+function useDebounce(value, delay = 500) {
+  const [debouncedValue, setDebouncedValue] = _react.useState.call(void 0, value);
+  _react.useEffect.call(void 0, () => {
+    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
+var _reactquery = require('@tanstack/react-query');
+var _augurutils = require('@simpleapps-com/augur-utils');
+var PRICE_CACHE_OPTIONS = {
+  ..._augurutils.CACHE_CONFIG.SEMI_STATIC,
+  refetchOnReconnect: true,
+  refetchOnWindowFocus: false,
+  meta: { persist: true }
+};
+var getItemPriceKey = (itemId, customerId, quantity = 1) => {
+  return ["price", _optionalChain([itemId, 'optionalAccess', _ => _.toUpperCase, 'call', _2 => _2()]) || "", customerId, quantity];
+};
+var getItemPriceOptions = (api, itemId, customerId, quantity = 1) => ({
+  queryKey: getItemPriceKey(itemId, customerId, quantity),
+  queryFn: async () => {
+    const response = await api.pricing.priceEngine.get({
+      itemId: _optionalChain([itemId, 'optionalAccess', _3 => _3.toUpperCase, 'call', _4 => _4()]) || "",
+      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 _reactquery.useQuery.call(void 0, {
+    ...defaultOptions,
+    ...options.queryFn ? { queryFn: options.queryFn } : {},
+    enabled: _nullishCoalesce(options.enabled, () => ( (Boolean(itemId) && Boolean(customerId)))),
+    retry: 3
+  });
+}
+
+// src/hooks/use-inv-mast-doc.ts
+
+
+var INV_MAST_DOC_CACHE_OPTIONS = _augurutils.CACHE_CONFIG.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,
+    _nullishCoalesce(options.includePricing, () => ( "N"))
+  );
+  const { data, isLoading, error } = _reactquery.useQuery.call(void 0, {
+    ...queryOpts,
+    ...options.queryFn ? { queryFn: options.queryFn } : {},
+    enabled: _nullishCoalesce(options.enabled, () => ( true)),
+    initialData: options.initialData
+  });
+  return { item: data, isLoading, error };
+}
+
+// src/hooks/use-item-category.ts
+
+
+var CATEGORY_CACHE_OPTIONS = _augurutils.CACHE_CONFIG.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 } = _reactquery.useQuery.call(void 0, {
+    ...queryOpts,
+    ...options.queryFn ? { queryFn: options.queryFn } : {},
+    enabled: _nullishCoalesce(options.enabled, () => ( true))
+  });
+  return { category: data, isLoading, error };
+}
+
+// src/hooks/use-inv-mast.ts
+
+
+var INV_MAST_CACHE_OPTIONS = _augurutils.CACHE_CONFIG.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 } = _reactquery.useQuery.call(void 0, {
+    ...queryOpts,
+    ...options.queryFn ? { queryFn: options.queryFn } : {},
+    enabled: _nullishCoalesce(options.enabled, () => ( true))
+  });
+  return { item: data, isLoading, error };
+}
+
+// src/hooks/use-inv-mast-stock.ts
+
+
+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 = _nullishCoalesce(_optionalChain([response, 'access', _5 => _5.data, 'optionalAccess', _6 => _6.stockData]), () => ( []));
+    return stockData.reduce(
+      (qty, stock) => qty + stock.qtyOnHand,
+      0
+    );
+  },
+  ..._augurutils.CACHE_CONFIG.SEMI_STATIC
+});
+function useInvMastStock(invMastUid, options = {}) {
+  const api = useAugurApi();
+  const queryOpts = getInvMastStockOptions(api, invMastUid);
+  const { data, isLoading, error } = _reactquery.useQuery.call(void 0, {
+    ...queryOpts,
+    ...options.queryFn ? { queryFn: options.queryFn } : {},
+    enabled: (_nullishCoalesce(options.enabled, () => ( true))) && !!invMastUid,
+    retry: 3,
+    retryDelay: (attemptIndex) => Math.min(1e3 * 2 ** attemptIndex, 1e4)
+  });
+  return {
+    qtyOnHand: _nullishCoalesce(data, () => ( null)),
+    loading: isLoading,
+    error
+  };
+}
+
+// src/hooks/use-product-category.ts
+
+
+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;
+  },
+  ..._augurutils.CACHE_CONFIG.STATIC
+});
+function useProductCategory(itemCategoryUid, options = {}) {
+  const api = useAugurApi();
+  const { data, isLoading, error } = _reactquery.useQuery.call(void 0, {
+    ...itemCategoryUid ? getProductCategoryOptions(api, itemCategoryUid) : { queryKey: getProductCategoryKey(null), queryFn: () => Promise.reject() },
+    ...options.queryFn ? { queryFn: options.queryFn } : {},
+    enabled: (_nullishCoalesce(options.enabled, () => ( true))) && !!itemCategoryUid,
+    retry: 3,
+    retryDelay: (attemptIndex) => Math.min(1e3 * 2 ** attemptIndex, 1e4)
+  });
+  return {
+    childrenTotal: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _7 => _7.childrenTotal]), () => ( 0)),
+    itemCategoryDesc: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _8 => _8.itemCategoryDesc]), () => ( "")),
+    productCategories: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _9 => _9.children]), () => ( null)),
+    productCategoryImage: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _10 => _10.categoryImage]), () => ( null)),
+    loading: isLoading,
+    error
+  };
+}
+
+// src/hooks/use-item-details.ts
+
+
+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;
+  },
+  ..._augurutils.CACHE_CONFIG.STATIC
+});
+function useItemDetails(itemId, options = {}) {
+  const api = useAugurApi();
+  const { data, isLoading, error } = _reactquery.useQuery.call(void 0, {
+    ...itemId ? getItemDetailsOptions(api, itemId) : { queryKey: getItemDetailsKey(""), queryFn: () => Promise.reject() },
+    ...options.queryFn ? { queryFn: options.queryFn } : {},
+    enabled: (_nullishCoalesce(options.enabled, () => ( true))) && !!itemId,
+    retry: 3,
+    retryDelay: (attemptIndex) => Math.min(1e3 * 2 ** attemptIndex, 1e4)
+  });
+  const categoryList = _nullishCoalesce(_optionalChain([data, 'optionalAccess', _11 => _11.categoryList]), () => ( []));
+  return {
+    itemCategoryUid: categoryList.length > 0 ? categoryList[categoryList.length - 1] : null,
+    itemDetails: _nullishCoalesce(data, () => ( null)),
+    loading: isLoading,
+    error
+  };
+}
+
+// src/hooks/use-item-attributes.ts
+
+
+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;
+  },
+  ..._augurutils.CACHE_CONFIG.STATIC
+});
+function useItemAttributes(itemCategoryUid, options = {}) {
+  const api = useAugurApi();
+  const { data, isLoading, error } = _reactquery.useQuery.call(void 0, {
+    ...itemCategoryUid ? getItemAttributesOptions(api, itemCategoryUid) : {
+      queryKey: getItemAttributesKey(null),
+      queryFn: () => Promise.reject()
+    },
+    ...options.queryFn ? { queryFn: options.queryFn } : {},
+    enabled: (_nullishCoalesce(options.enabled, () => ( true))) && !!itemCategoryUid,
+    retry: 3,
+    retryDelay: (attemptIndex) => Math.min(1e3 * 2 ** attemptIndex, 1e4)
+  });
+  return {
+    attributes: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _12 => _12.attributes]), () => ( null)),
+    loading: isLoading,
+    error
+  };
+}
+
+// src/hooks/use-product-search.ts
+
+
+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;
+  },
+  ..._augurutils.CACHE_CONFIG.SEMI_STATIC
+});
+function useProductSearch(pageData, options = {}) {
+  const api = useAugurApi();
+  const defaultOptions = getProductSearchOptions(api, pageData);
+  const { data, isLoading, error } = _reactquery.useQuery.call(void 0, {
+    ...defaultOptions,
+    ...options.queryFn ? { queryFn: options.queryFn } : {},
+    retry: 3,
+    retryDelay: (attemptIndex) => Math.min(1e3 * 2 ** attemptIndex, 1e4)
+  });
+  return {
+    productItems: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _13 => _13.items]), () => ( null)),
+    total: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _14 => _14.totalResults]), () => ( 0)),
+    loading: isLoading,
+    error
+  };
+}
+
+// src/hooks/use-search-suggestions.ts
+
+
+var SEARCH_SUGGESTIONS_CACHE_OPTIONS = _augurutils.CACHE_CONFIG.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 = _nullishCoalesce(options.limit, () => ( 10));
+  const offset = _nullishCoalesce(options.offset, () => ( 0));
+  const enabled = (_nullishCoalesce(options.enabled, () => ( true))) && query.trim().length > 0;
+  const defaultOptions = getSearchSuggestionsOptions(api, query, limit, offset);
+  const { data, isLoading, error } = _reactquery.useQuery.call(void 0, {
+    ...defaultOptions,
+    ...options.queryFn ? { queryFn: options.queryFn } : {},
+    enabled
+  });
+  return {
+    suggestions: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _15 => _15.data]), () => ( [])),
+    total: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _16 => _16.total]), () => ( 0)),
+    isLoading,
+    error
+  };
+}
+
+// src/hooks/use-cart-actions.ts
+
+
+function useCartActions(callbacks) {
+  const queryClient = _reactquery.useQueryClient.call(void 0, );
+  const cartHdrUid = useCartHdrUid();
+  const cartLines = useCartLines();
+  const setCartLines = useSetCartLines();
+  const notify = callbacks.toast;
+  const cartHdrUidNum = typeof cartHdrUid === "string" ? Number(cartHdrUid) : cartHdrUid;
+  const invalidateCartCache = _react.useCallback.call(void 0, () => {
+    queryClient.invalidateQueries({ queryKey: ["cartLines", cartHdrUid] });
+    queryClient.invalidateQueries({
+      queryKey: ["cart-also-bought", cartHdrUid]
+    });
+  }, [queryClient, cartHdrUid]);
+  const addToCart = _react.useCallback.call(void 0, 
+    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 && _optionalChain([notify, 'optionalAccess', _17 => _17.info])) {
+          notify.info(
+            `${item.quantity} x ${itemId || "Item"} added to cart`
+          );
+        }
+        _optionalChain([onSuccess, 'optionalCall', _18 => _18()]);
+        return true;
+      } catch (error) {
+        setCartLines(previousCartLines);
+        if (showToast && _optionalChain([notify, 'optionalAccess', _19 => _19.error])) {
+          notify.error("Failed to add item to cart. Please try again.");
+        }
+        _optionalChain([onError, 'optionalCall', _20 => _20(error)]);
+        return false;
+      }
+    },
+    [cartHdrUid, cartLines, setCartLines, invalidateCartCache, callbacks, notify]
+  );
+  const updateQuantity = _react.useCallback.call(void 0, 
+    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();
+        _optionalChain([onSuccess, 'optionalCall', _21 => _21()]);
+        return true;
+      } catch (error) {
+        setCartLines(previousCartLines);
+        if (showToast && _optionalChain([notify, 'optionalAccess', _22 => _22.error])) {
+          notify.error("Failed to update quantity. Please try again.");
+        }
+        _optionalChain([onError, 'optionalCall', _23 => _23(error)]);
+        return false;
+      }
+    },
+    [cartHdrUid, cartLines, setCartLines, invalidateCartCache, callbacks, notify]
+  );
+  const removeFromCart = _react.useCallback.call(void 0, 
+    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 && _optionalChain([notify, 'optionalAccess', _24 => _24.info])) {
+          notify.info(`${itemId || "Item"} removed from cart`);
+        }
+        _optionalChain([onSuccess, 'optionalCall', _25 => _25()]);
+        return true;
+      } catch (error) {
+        setCartLines(previousCartLines);
+        if (showToast && _optionalChain([notify, 'optionalAccess', _26 => _26.error])) {
+          notify.error("Failed to remove item. Please try again.");
+        }
+        _optionalChain([onError, 'optionalCall', _27 => _27(error)]);
+        return false;
+      }
+    },
+    [cartHdrUid, cartLines, setCartLines, invalidateCartCache, callbacks, notify]
+  );
+  const clearCart = _react.useCallback.call(void 0, 
+    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 && _optionalChain([notify, 'optionalAccess', _28 => _28.info])) {
+          notify.info("Cart cleared");
+        }
+        _optionalChain([onSuccess, 'optionalCall', _29 => _29()]);
+        return true;
+      } catch (error) {
+        setCartLines(previousCartLines);
+        if (showToast && _optionalChain([notify, 'optionalAccess', _30 => _30.error])) {
+          notify.error("Failed to clear cart. Please try again.");
+        }
+        _optionalChain([onError, 'optionalCall', _31 => _31(error)]);
+        return false;
+      }
+    },
+    [cartHdrUid, cartLines, setCartLines, invalidateCartCache, callbacks, notify]
+  );
+  const isInCart = _react.useCallback.call(void 0, 
+    (invMastUid) => {
+      return cartLines.some((line) => line.invMastUid === invMastUid);
+    },
+    [cartLines]
+  );
+  const getItemQuantity = _react.useCallback.call(void 0, 
+    (invMastUid) => {
+      return _nullishCoalesce(_optionalChain([cartLines, 'access', _32 => _32.find, 'call', _33 => _33((line) => line.invMastUid === invMastUid), 'optionalAccess', _34 => _34.quantity]), () => ( 0));
+    },
+    [cartLines]
+  );
+  return {
+    addToCart,
+    updateQuantity,
+    removeFromCart,
+    clearCart,
+    isInCart,
+    getItemQuantity,
+    cartHdrUid,
+    cartLines,
+    invalidateCartCache
+  };
+}
+
+// src/hooks/use-cart-initialization.ts
+
+
+
+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 = _react.useRef.call(void 0, 0);
+  const isInitializingRef = _react.useRef.call(void 0, false);
+  _react.useEffect.call(void 0, () => {
+    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 } = _reactquery.useQuery.call(void 0, {
+    queryKey: ["cartLines", cartHdrUid],
+    queryFn: () => callbacks.getCartLines(Number(cartHdrUid)),
+    enabled: !!cartHdrUid,
+    ..._augurutils.CACHE_CONFIG.CART
+  });
+  _react.useEffect.call(void 0, () => {
+    if (cartLinesData) {
+      setCartLines(cartLinesData);
+    }
+  }, [cartLinesData, setCartLines]);
+  return {
+    cartHdrUid,
+    isInitializing: isInitializingRef.current,
+    retryCount: retryCountRef.current
+  };
+}
+
+// src/hooks/use-cart-pricing.ts
+
+
+function useCartPricing(options = {}) {
+  const api = useAugurApi();
+  const cartLines = useCartLines();
+  const { customerId } = options;
+  const priceQueries = _reactquery.useQueries.call(void 0, {
+    queries: cartLines.map((line) => ({
+      ...getItemPriceOptions(api, line.itemId, customerId, line.quantity),
+      enabled: !!customerId && !!line.itemId
+    }))
+  });
+  const prices = _react.useMemo.call(void 0, () => {
+    const map = {};
+    cartLines.forEach((line, index) => {
+      const queryResult = priceQueries[index];
+      if (_optionalChain([queryResult, 'optionalAccess', _35 => _35.data])) {
+        map[line.itemId.toUpperCase()] = {
+          unitPrice: _nullishCoalesce(queryResult.data.unitPrice, () => ( 0)),
+          priceData: queryResult.data
+        };
+      }
+    });
+    return map;
+  }, [cartLines, priceQueries]);
+  const getUnitPrice = _react.useMemo.call(void 0, () => {
+    return (itemId) => {
+      return _nullishCoalesce(_optionalChain([prices, 'access', _36 => _36[_optionalChain([itemId, 'optionalAccess', _37 => _37.toUpperCase, 'call', _38 => _38()])], 'optionalAccess', _39 => _39.unitPrice]), () => ( 0));
+    };
+  }, [prices]);
+  const getItemTotal = _react.useMemo.call(void 0, () => {
+    return (itemId, quantity) => {
+      return getUnitPrice(itemId) * quantity;
+    };
+  }, [getUnitPrice]);
+  const subtotal = _react.useMemo.call(void 0, () => {
+    return cartLines.reduce((sum, line) => {
+      const unitPrice = _nullishCoalesce(_optionalChain([prices, 'access', _40 => _40[line.itemId.toUpperCase()], 'optionalAccess', _41 => _41.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
+
+
+var usePaginationPrefetch = ({
+  queryKey,
+  queryFn,
+  pageSize,
+  staleTime = 10 * 60 * 1e3,
+  gcTime = 30 * 60 * 1e3,
+  enabled = true
+}) => {
+  const queryClient = _reactquery.useQueryClient.call(void 0, );
+  const prefetchPage = _react.useCallback.call(void 0, 
+    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 = _react.useCallback.call(void 0, 
+    (page) => {
+      const timeoutId = setTimeout(() => prefetchPage(page), 150);
+      return () => clearTimeout(timeoutId);
+    },
+    [prefetchPage]
+  );
+  return {
+    prefetchPage,
+    handlePaginationHover
+  };
+};
+
+// src/hooks/use-category-items-infinite.ts
+
+
+
+
+var getCategoryItemsInfiniteKey = (itemCategoryUid, itemsFilters) => {
+  return [
+    "categoryItemsInfinite",
+    itemCategoryUid,
+    JSON.stringify(itemsFilters)
+  ];
+};
+function useCategoryItemsInfinite(itemCategoryUid, itemsFilters, options = {}) {
+  const api = useAugurApi();
+  const { enabled = true } = options;
+  return _reactquery.useInfiniteQuery.call(void 0, {
+    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: _optionalChain([itemsFilters, 'access', _42 => _42.filters, 'optionalAccess', _43 => _43.length]) ? JSON.stringify(itemsFilters.filters) : void 0
+      });
+      const items = _nullishCoalesce(_optionalChain([response, 'access', _44 => _44.data, 'optionalAccess', _45 => _45.items]), () => ( []));
+      const total = _nullishCoalesce(_optionalChain([response, 'access', _46 => _46.data, 'optionalAccess', _47 => _47.totalResults]), () => ( 0));
+      const nextOffset = pageParam + itemsFilters.limit;
+      return {
+        data: items,
+        total,
+        nextCursor: nextOffset < total ? nextOffset : void 0
+      };
+    },
+    initialPageParam: 0,
+    getNextPageParam: (lastPage) => lastPage.nextCursor,
+    ..._augurutils.CACHE_CONFIG.SEMI_STATIC,
+    enabled: enabled && !!itemCategoryUid
+  });
+}
+
+// src/hooks/use-item-search-infinite.ts
+
+
+
+
+var getItemSearchInfiniteKey = (itemsFilters, itemCategoryUid) => {
+  return [
+    "itemSearchInfinite",
+    JSON.stringify(itemsFilters),
+    itemCategoryUid
+  ];
+};
+function useItemSearchInfinite(itemsFilters, itemCategoryUid, options = {}) {
+  const api = useAugurApi();
+  const { enabled = true } = options;
+  return _reactquery.useInfiniteQuery.call(void 0, {
+    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: _optionalChain([itemsFilters, 'access', _48 => _48.filters, 'optionalAccess', _49 => _49.length]) ? JSON.stringify(itemsFilters.filters) : void 0
+      });
+      const items = _nullishCoalesce(_optionalChain([response, 'access', _50 => _50.data, 'optionalAccess', _51 => _51.items]), () => ( []));
+      const total = _nullishCoalesce(_optionalChain([response, 'access', _52 => _52.data, 'optionalAccess', _53 => _53.totalResults]), () => ( 0));
+      const nextOffset = pageParam + itemsFilters.limit;
+      return {
+        data: items,
+        total,
+        nextCursor: nextOffset < total ? nextOffset : void 0
+      };
+    },
+    initialPageParam: 0,
+    getNextPageParam: (lastPage) => lastPage.nextCursor,
+    ..._augurutils.CACHE_CONFIG.SEMI_STATIC,
+    enabled: enabled && !!itemsFilters.q,
+    meta: { persist: true }
+  });
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.AugurHooksProvider = AugurHooksProvider; exports.CATEGORY_CACHE_OPTIONS = CATEGORY_CACHE_OPTIONS; exports.INV_MAST_CACHE_OPTIONS = INV_MAST_CACHE_OPTIONS; exports.INV_MAST_DOC_CACHE_OPTIONS = INV_MAST_DOC_CACHE_OPTIONS; exports.PRICE_CACHE_OPTIONS = PRICE_CACHE_OPTIONS; exports.getCartPricingQueryOptions = getCartPricingQueryOptions; exports.getCategoryItemsInfiniteKey = getCategoryItemsInfiniteKey; exports.getInvMastDocKey = getInvMastDocKey; exports.getInvMastDocOptions = getInvMastDocOptions; exports.getInvMastKey = getInvMastKey; exports.getInvMastOptions = getInvMastOptions; exports.getInvMastStockKey = getInvMastStockKey; exports.getInvMastStockOptions = getInvMastStockOptions; exports.getItemAttributesKey = getItemAttributesKey; exports.getItemAttributesOptions = getItemAttributesOptions; exports.getItemCategoryKey = getItemCategoryKey; exports.getItemCategoryOptions = getItemCategoryOptions; exports.getItemDetailsKey = getItemDetailsKey; exports.getItemDetailsOptions = getItemDetailsOptions; exports.getItemPriceKey = getItemPriceKey; exports.getItemPriceOptions = getItemPriceOptions; exports.getItemSearchInfiniteKey = getItemSearchInfiniteKey; exports.getProductCategoryKey = getProductCategoryKey; exports.getProductCategoryOptions = getProductCategoryOptions; exports.getProductSearchKey = getProductSearchKey; exports.getProductSearchOptions = getProductSearchOptions; exports.getSearchSuggestionsKey = getSearchSuggestionsKey; exports.getSearchSuggestionsOptions = getSearchSuggestionsOptions; exports.useAugurApi = useAugurApi; exports.useCartActions = useCartActions; exports.useCartHdrUid = useCartHdrUid; exports.useCartInitialization = useCartInitialization; exports.useCartItemCount = useCartItemCount; exports.useCartLines = useCartLines; exports.useCartPricing = useCartPricing; exports.useCartStore = useCartStore; exports.useCategoryItemsInfinite = useCategoryItemsInfinite; exports.useDebounce = useDebounce; exports.useFormatPrice = useFormatPrice; exports.useInvMast = useInvMast; exports.useInvMastDoc = useInvMastDoc; exports.useInvMastStock = useInvMastStock; exports.useItemAttributes = useItemAttributes; exports.useItemCategory = useItemCategory; exports.useItemDetails = useItemDetails; exports.useItemFiltersStore = useItemFiltersStore; exports.useItemPrice = useItemPrice; exports.useItemSearchInfinite = useItemSearchInfinite; exports.usePaginationPrefetch = usePaginationPrefetch; exports.useProductCategory = useProductCategory; exports.useProductSearch = useProductSearch; exports.useSearchSuggestions = useSearchSuggestions; exports.useSetCartHdrUid = useSetCartHdrUid; exports.useSetCartLines = useSetCartLines;
+//# sourceMappingURL=index.cjs.map