@classytic/commerce-sdk 0.1.0

package/dist/chunk-UGELTUIZ.js

@@ -0,0 +1,830 @@
+import { posApi } from './chunk-66OQAZSL.js';
+import { BaseApi } from './chunk-I5TIKUIQ.js';
+import { createQueryKeys, createCrudHooks } from './chunk-B6MPVOV7.js';
+import { getToastHandler } from './chunk-U3XT35GZ.js';
+import { handleApiRequest } from './chunk-VR36QVX2.js';
+import { useQueryClient, useQuery, useMutation } from '@tanstack/react-query';
+
+// src/sales/types/order.ts
+var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
+  OrderStatus2["PENDING"] = "pending";
+  OrderStatus2["PROCESSING"] = "processing";
+  OrderStatus2["CONFIRMED"] = "confirmed";
+  OrderStatus2["SHIPPED"] = "shipped";
+  OrderStatus2["DELIVERED"] = "delivered";
+  OrderStatus2["CANCELLED"] = "cancelled";
+  return OrderStatus2;
+})(OrderStatus || {});
+var PaymentStatus = /* @__PURE__ */ ((PaymentStatus2) => {
+  PaymentStatus2["PENDING"] = "pending";
+  PaymentStatus2["VERIFIED"] = "verified";
+  PaymentStatus2["FAILED"] = "failed";
+  PaymentStatus2["REFUNDED"] = "refunded";
+  PaymentStatus2["PARTIALLY_REFUNDED"] = "partially_refunded";
+  PaymentStatus2["CANCELLED"] = "cancelled";
+  return PaymentStatus2;
+})(PaymentStatus || {});
+
+// src/sales/api/cart.ts
+var ENDPOINT = "/api/v1/cart";
+var cartApi = {
+  /**
+   * Get current user's cart
+   * GET /api/v1/cart
+   *
+   * Auto-creates cart if it doesn't exist for the user.
+   * Returns cart with fully populated product details.
+   *
+   * @param token - User authentication token
+   * @returns Cart with items array
+   */
+  getCart: async (token) => {
+    const response = await handleApiRequest("GET", ENDPOINT, { token });
+    return response.data;
+  },
+  /**
+   * Add item to cart
+   * POST /api/v1/cart/items
+   *
+   * @param token - User authentication token
+   * @param data - Product ID, quantity, and optional variant SKU
+   * @returns Updated cart
+   */
+  addToCart: async (token, data) => {
+    const response = await handleApiRequest("POST", `${ENDPOINT}/items`, {
+      token,
+      body: data
+    });
+    return response.data;
+  },
+  /**
+   * Update cart item quantity
+   * PATCH /api/v1/cart/items/:itemId
+   *
+   * @param token - User authentication token
+   * @param itemId - Cart item ID (from cart.items[]._id)
+   * @param quantity - New quantity (minimum: 1)
+   * @returns Updated cart
+   */
+  updateCartItem: async (token, itemId, quantity) => {
+    const response = await handleApiRequest("PATCH", `${ENDPOINT}/items/${itemId}`, {
+      token,
+      body: { quantity }
+    });
+    return response.data;
+  },
+  /**
+   * Remove item from cart
+   * DELETE /api/v1/cart/items/:itemId
+   *
+   * @param token - User authentication token
+   * @param itemId - Cart item ID (from cart.items[]._id)
+   * @returns Updated cart
+   */
+  removeCartItem: async (token, itemId) => {
+    const response = await handleApiRequest("DELETE", `${ENDPOINT}/items/${itemId}`, {
+      token
+    });
+    return response.data;
+  },
+  /**
+   * Clear all items from cart
+   * DELETE /api/v1/cart
+   *
+   * @param token - User authentication token
+   * @returns Empty cart
+   */
+  clearCart: async (token) => {
+    const response = await handleApiRequest("DELETE", ENDPOINT, { token });
+    return response.data;
+  }
+};
+
+// src/sales/api/order.ts
+var OrderApi = class extends BaseApi {
+  constructor() {
+    super(...arguments);
+    // ============ Customer ============
+    /**
+     * Checkout - create order from cart
+     * POST /api/v1/orders
+     */
+    this.checkout = ({ token, organizationId, data }) => this.create({ token, organizationId, data });
+    /** Get my orders */
+    this.getMyOrders = ({ token, params = {} }) => this.request("GET", `${this.baseUrl}/my`, { token, params });
+    /** Get my order detail */
+    this.getMyOrder = ({ token, id }) => this.request("GET", `${this.baseUrl}/my/${id}`, { token });
+    /** Cancel order */
+    this.cancel = ({ token, id, reason, refund = false }) => this.request("POST", `${this.baseUrl}/${id}/cancel`, {
+      token,
+      data: { reason, refund }
+    });
+    /** Request cancellation (awaits admin review) */
+    this.requestCancellation = ({ token, id, reason }) => this.request("POST", `${this.baseUrl}/${id}/cancel-request`, {
+      token,
+      data: { reason }
+    });
+    // ============ Admin ============
+    /** Update order status */
+    this.updateStatus = ({ token, organizationId, id, data }) => this.request("PATCH", `${this.baseUrl}/${id}/status`, {
+      token,
+      organizationId,
+      data
+    });
+    /**
+     * Fulfill order (ship)
+     * - Decrements inventory from branch
+     * - recordCogs: true -> also creates COGS expense transaction
+     */
+    this.fulfill = ({ token, organizationId, id, data = {} }) => this.request("POST", `${this.baseUrl}/${id}/fulfill`, {
+      token,
+      organizationId,
+      data
+    });
+    /** Refund order */
+    this.refund = ({ token, organizationId, id, data = {} }) => this.request("POST", `${this.baseUrl}/${id}/refund`, {
+      token,
+      organizationId,
+      data
+    });
+    // ============ Shipping ============
+    /** Get shipping info */
+    this.getShipping = ({ token, id }) => this.request("GET", `${this.baseUrl}/${id}/shipping`, { token });
+    /** Request shipping pickup */
+    this.requestShipping = ({ token, organizationId, id, data }) => this.request("POST", `${this.baseUrl}/${id}/shipping`, {
+      token,
+      organizationId,
+      data
+    });
+    /** Update shipping status */
+    this.updateShipping = ({ token, organizationId, id, data }) => this.request("PATCH", `${this.baseUrl}/${id}/shipping`, {
+      token,
+      organizationId,
+      data
+    });
+  }
+};
+var orderApi = new OrderApi("orders");
+var order_default = orderApi;
+
+// src/sales/api/customer.ts
+var CustomerApi = class extends BaseApi {
+  constructor(config = {}) {
+    super("customers", config);
+  }
+  /**
+   * Get current user's customer profile
+   * GET /customers/me
+   */
+  async getMe({
+    token,
+    options = {}
+  }) {
+    if (!token) {
+      throw new Error("Authentication required");
+    }
+    return handleApiRequest("GET", `${this.baseUrl}/me`, {
+      token,
+      cache: this.config.cache,
+      ...options
+    });
+  }
+  /**
+   * Membership actions
+   * POST /customers/:id/membership
+   */
+  async membershipAction({
+    token,
+    id,
+    data
+  }) {
+    if (!token) {
+      throw new Error("Authentication required");
+    }
+    return handleApiRequest("POST", `${this.baseUrl}/${id}/membership`, {
+      token,
+      body: data,
+      cache: this.config.cache
+    });
+  }
+};
+var customerApi = new CustomerApi();
+var CART_KEYS = createQueryKeys("cart");
+function calculateItemPrice(item) {
+  if (!item?.product) return 0;
+  const product = item.product;
+  const basePrice = product.currentPrice ?? product.basePrice ?? 0;
+  if (item.variantSku && product.variants && product.variants.length > 0) {
+    const variant = product.variants.find((v) => v.sku === item.variantSku);
+    if (variant) {
+      return basePrice + (variant.priceModifier || 0);
+    }
+  }
+  return basePrice;
+}
+function calculateItemTotal(item) {
+  return calculateItemPrice(item) * (item.quantity || 1);
+}
+function calculateCartSubtotal(items) {
+  return items?.reduce((total, item) => total + calculateItemTotal(item), 0) || 0;
+}
+function getCartItemCount(items) {
+  return items?.reduce((count, item) => count + (item.quantity || 0), 0) || 0;
+}
+function getCartItemVariant(item) {
+  if (!item?.variantSku || !item?.product?.variants) return null;
+  return item.product.variants.find((v) => v.sku === item.variantSku) || null;
+}
+function formatVariantAttributes(attributes) {
+  if (!attributes || Object.keys(attributes).length === 0) return "";
+  return Object.entries(attributes).map(([key, value]) => `${key.charAt(0).toUpperCase() + key.slice(1)}: ${value}`).join(", ");
+}
+var CART_QUERY_KEY = ["cart"];
+function useCart(token, options = {}) {
+  const queryClient = useQueryClient();
+  const toast = getToastHandler();
+  const { enabled = true, staleTime = 2 * 60 * 1e3, gcTime = 10 * 60 * 1e3 } = options;
+  const {
+    data: cart,
+    isLoading,
+    error,
+    isFetching,
+    refetch
+  } = useQuery({
+    queryKey: CART_QUERY_KEY,
+    queryFn: () => cartApi.getCart(token),
+    enabled: enabled && !!token,
+    staleTime,
+    gcTime
+  });
+  const addMutation = useMutation({
+    mutationFn: (data) => cartApi.addToCart(token, data),
+    onMutate: async () => {
+      await queryClient.cancelQueries({ queryKey: CART_QUERY_KEY });
+      return { previousCart: queryClient.getQueryData(CART_QUERY_KEY) };
+    },
+    onError: (err, _, context) => {
+      if (context?.previousCart) {
+        queryClient.setQueryData(CART_QUERY_KEY, context.previousCart);
+      }
+      toast.error?.(err.message || "Failed to add item to cart");
+    },
+    onSuccess: (data) => {
+      queryClient.setQueryData(CART_QUERY_KEY, data);
+      toast.success?.("Added to cart!");
+    }
+  });
+  const updateMutation = useMutation({
+    mutationFn: ({ itemId, quantity }) => cartApi.updateCartItem(token, itemId, quantity),
+    onMutate: async ({ itemId, quantity }) => {
+      await queryClient.cancelQueries({ queryKey: CART_QUERY_KEY });
+      const previousCart = queryClient.getQueryData(CART_QUERY_KEY);
+      queryClient.setQueryData(
+        CART_QUERY_KEY,
+        (old) => old ? {
+          ...old,
+          items: old.items.map(
+            (i) => i._id === itemId ? { ...i, quantity } : i
+          )
+        } : old
+      );
+      return { previousCart };
+    },
+    onError: (err, _, context) => {
+      if (context?.previousCart) {
+        queryClient.setQueryData(CART_QUERY_KEY, context.previousCart);
+      }
+      toast.error?.(err.message || "Failed to update cart");
+    },
+    onSuccess: (data) => {
+      queryClient.setQueryData(CART_QUERY_KEY, data);
+    }
+  });
+  const removeMutation = useMutation({
+    mutationFn: (itemId) => cartApi.removeCartItem(token, itemId),
+    onMutate: async (itemId) => {
+      await queryClient.cancelQueries({ queryKey: CART_QUERY_KEY });
+      const previousCart = queryClient.getQueryData(CART_QUERY_KEY);
+      queryClient.setQueryData(
+        CART_QUERY_KEY,
+        (old) => old ? { ...old, items: old.items.filter((i) => i._id !== itemId) } : old
+      );
+      return { previousCart };
+    },
+    onError: (err, _, context) => {
+      if (context?.previousCart) {
+        queryClient.setQueryData(CART_QUERY_KEY, context.previousCart);
+      }
+      toast.error?.(err.message || "Failed to remove item");
+    },
+    onSuccess: (data) => {
+      queryClient.setQueryData(CART_QUERY_KEY, data);
+      toast.success?.("Item removed");
+    }
+  });
+  const clearMutation = useMutation({
+    mutationFn: () => cartApi.clearCart(token),
+    onMutate: async () => {
+      await queryClient.cancelQueries({ queryKey: CART_QUERY_KEY });
+      const previousCart = queryClient.getQueryData(CART_QUERY_KEY);
+      queryClient.setQueryData(
+        CART_QUERY_KEY,
+        (old) => old ? { ...old, items: [] } : old
+      );
+      return { previousCart };
+    },
+    onError: (err, _, context) => {
+      if (context?.previousCart) {
+        queryClient.setQueryData(CART_QUERY_KEY, context.previousCart);
+      }
+      toast.error?.(err.message || "Failed to clear cart");
+    },
+    onSuccess: (data) => {
+      queryClient.setQueryData(CART_QUERY_KEY, data);
+      toast.success?.("Cart cleared");
+    }
+  });
+  const items = cart?.items || [];
+  const isUpdating = addMutation.isPending || updateMutation.isPending || removeMutation.isPending || clearMutation.isPending;
+  return {
+    cart,
+    items,
+    itemCount: getCartItemCount(items),
+    subtotal: calculateCartSubtotal(items),
+    isLoading,
+    isFetching,
+    isUpdating,
+    error,
+    addToCart: (data) => addMutation.mutate(data),
+    addToCartAsync: (data) => addMutation.mutateAsync(data),
+    updateCartItem: (data) => updateMutation.mutate(data),
+    updateCartItemAsync: (data) => updateMutation.mutateAsync(data),
+    removeCartItem: (itemId) => removeMutation.mutate(itemId),
+    removeCartItemAsync: (itemId) => removeMutation.mutateAsync(itemId),
+    clearCart: () => clearMutation.mutate(),
+    clearCartAsync: () => clearMutation.mutateAsync(),
+    refetch: () => refetch(),
+    getItemPrice: calculateItemPrice
+  };
+}
+function useCartCount(token, options = {}) {
+  const { enabled = true, staleTime = 2 * 60 * 1e3, gcTime = 10 * 60 * 1e3 } = options;
+  const { data: cart, isLoading } = useQuery({
+    queryKey: CART_QUERY_KEY,
+    queryFn: () => cartApi.getCart(token),
+    enabled: enabled && !!token,
+    staleTime,
+    gcTime
+  });
+  return {
+    count: getCartItemCount(cart?.items || []),
+    isLoading
+  };
+}
+var createOrderKeys = () => ({
+  all: ["orders"],
+  lists: () => [...createOrderKeys().all, "list"],
+  list: (params) => [...createOrderKeys().lists(), params],
+  details: () => [...createOrderKeys().all, "detail"],
+  detail: (id) => [...createOrderKeys().details(), id],
+  // Customer-specific keys
+  myOrders: (params) => [...createOrderKeys().all, "my", params],
+  myDetail: (id) => [...createOrderKeys().all, "my", "detail", id]
+});
+var orderHooks = createCrudHooks({
+  api: orderApi,
+  entityKey: "orders",
+  singular: "Order",
+  plural: "Orders",
+  defaults: {
+    staleTime: 1 * 60 * 1e3
+    // 1 minute (orders change frequently)
+  }
+});
+var ORDER_KEYS = createOrderKeys();
+var {
+  useList: useOrders,
+  useDetail: useOrderDetail,
+  useActions: useOrderActions,
+  useNavigation: useOrderNavigation
+} = orderHooks;
+function useMyOrders(token, params = {}, options = {}) {
+  const { data, isLoading, isFetching, error, refetch } = useQuery({
+    queryKey: ORDER_KEYS.myOrders(params),
+    queryFn: async () => {
+      const response = await orderApi.getMyOrders({ token, params });
+      return response;
+    },
+    enabled: !!token && options.enabled !== false,
+    staleTime: options.staleTime ?? 30 * 1e3
+  });
+  const orders = data?.data || data?.docs || [];
+  const pagination = data?.pagination;
+  return {
+    orders,
+    total: pagination?.total || orders.length,
+    page: pagination?.page || 1,
+    limit: pagination?.limit || 10,
+    hasMore: pagination?.hasMore ?? false,
+    isLoading,
+    isFetching,
+    error,
+    refetch
+  };
+}
+function useMyOrderDetail(token, orderId, options = {}) {
+  return useQuery({
+    queryKey: ORDER_KEYS.myDetail(orderId),
+    queryFn: async () => {
+      const response = await orderApi.getMyOrder({ token, id: orderId });
+      return response.data;
+    },
+    enabled: !!token && !!orderId && options.enabled !== false,
+    staleTime: options.staleTime ?? 30 * 1e3
+  });
+}
+function useCustomerOrderActions(token) {
+  const queryClient = useQueryClient();
+  const toast = getToastHandler();
+  const checkoutMutation = useMutation({
+    mutationFn: async (data) => {
+      const response = await orderApi.checkout({ token, data });
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.setQueryData(["cart"], null);
+      queryClient.invalidateQueries({ queryKey: ["cart"] });
+      queryClient.invalidateQueries({ queryKey: ORDER_KEYS.all });
+      toast.success("Order placed successfully!");
+    },
+    onError: (error) => {
+      toast.error(error.message || "Failed to place order");
+    }
+  });
+  const requestCancelMutation = useMutation({
+    mutationFn: async ({ orderId, reason }) => {
+      const response = await orderApi.requestCancellation({ token, id: orderId, reason });
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ORDER_KEYS.all });
+      toast.success("Cancellation request submitted");
+    },
+    onError: (error) => {
+      toast.error(error.message || "Failed to request cancellation");
+    }
+  });
+  return {
+    checkout: checkoutMutation.mutateAsync,
+    isCheckingOut: checkoutMutation.isPending,
+    requestCancel: requestCancelMutation.mutateAsync,
+    isRequestingCancel: requestCancelMutation.isPending,
+    isLoading: checkoutMutation.isPending || requestCancelMutation.isPending
+  };
+}
+function useAdminOrderActions(token) {
+  const queryClient = useQueryClient();
+  const toast = getToastHandler();
+  const updateStatusMutation = useMutation({
+    mutationFn: async ({ orderId, status, note }) => {
+      const response = await orderApi.updateStatus({
+        token,
+        id: orderId,
+        data: { status, note }
+      });
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ORDER_KEYS.all });
+      toast.success("Order status updated");
+    },
+    onError: (error) => {
+      toast.error(error.message || "Failed to update status");
+    }
+  });
+  const fulfillMutation = useMutation({
+    mutationFn: async ({ orderId, ...data }) => {
+      const response = await orderApi.fulfill({ token, id: orderId, data });
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ORDER_KEYS.all });
+      queryClient.invalidateQueries({ queryKey: ["branches"] });
+      queryClient.invalidateQueries({ queryKey: ["stock"] });
+      toast.success("Order fulfilled successfully");
+    },
+    onError: (error) => {
+      toast.error(error.message || "Failed to fulfill order");
+    }
+  });
+  const refundMutation = useMutation({
+    mutationFn: async ({ orderId, amount, reason }) => {
+      const response = await orderApi.refund({ token, id: orderId, data: { amount, reason } });
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ORDER_KEYS.all });
+      toast.success("Refund processed successfully");
+    },
+    onError: (error) => {
+      toast.error(error.message || "Failed to process refund");
+    }
+  });
+  const cancelMutation = useMutation({
+    mutationFn: async ({ orderId, reason, refund }) => {
+      const response = await orderApi.cancel({ token, id: orderId, reason, refund });
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ORDER_KEYS.all });
+      toast.success("Order cancelled");
+    },
+    onError: (error) => {
+      toast.error(error.message || "Failed to cancel order");
+    }
+  });
+  const requestShippingMutation = useMutation({
+    mutationFn: async ({ orderId, ...data }) => {
+      const response = await orderApi.requestShipping({ token, id: orderId, data });
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ORDER_KEYS.all });
+      toast.success("Shipping pickup requested");
+    },
+    onError: (error) => {
+      toast.error(error.message || "Failed to request shipping");
+    }
+  });
+  const updateShippingMutation = useMutation({
+    mutationFn: async ({ orderId, ...data }) => {
+      const response = await orderApi.updateShipping({ token, id: orderId, data });
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ORDER_KEYS.all });
+      toast.success("Shipping status updated");
+    },
+    onError: (error) => {
+      toast.error(error.message || "Failed to update shipping");
+    }
+  });
+  return {
+    updateStatus: updateStatusMutation.mutateAsync,
+    isUpdatingStatus: updateStatusMutation.isPending,
+    fulfillOrder: fulfillMutation.mutateAsync,
+    isFulfilling: fulfillMutation.isPending,
+    refundOrder: refundMutation.mutateAsync,
+    isRefunding: refundMutation.isPending,
+    cancelOrder: cancelMutation.mutateAsync,
+    isCancelling: cancelMutation.isPending,
+    requestShipping: requestShippingMutation.mutateAsync,
+    isRequestingShipping: requestShippingMutation.isPending,
+    updateShipping: updateShippingMutation.mutateAsync,
+    isUpdatingShipping: updateShippingMutation.isPending,
+    isLoading: updateStatusMutation.isPending || fulfillMutation.isPending || refundMutation.isPending || cancelMutation.isPending || requestShippingMutation.isPending || updateShippingMutation.isPending
+  };
+}
+var customerHooks = createCrudHooks({
+  api: customerApi,
+  entityKey: "customers",
+  singular: "Customer",
+  plural: "Customers",
+  defaults: {
+    staleTime: 5 * 60 * 1e3
+    // 5 minutes
+  }
+});
+var {
+  KEYS: CUSTOMER_KEYS,
+  useList: useCustomers,
+  useDetail: useCustomerDetail,
+  useActions: useCustomerActions,
+  useNavigation: useCustomerNavigation
+} = customerHooks;
+function useCurrentCustomer(token, options = {}) {
+  return useQuery({
+    queryKey: [...CUSTOMER_KEYS.all, "me"],
+    queryFn: async () => {
+      const response = await customerApi.getMe({ token });
+      return response.data;
+    },
+    enabled: !!token && options.enabled !== false,
+    staleTime: options.staleTime ?? 5 * 60 * 1e3
+  });
+}
+function useCustomerMembership(token) {
+  const queryClient = useQueryClient();
+  const toast = getToastHandler();
+  const mutation = useMutation({
+    mutationFn: async ({ id, action, points, reason, type }) => {
+      const response = await customerApi.membershipAction({
+        token,
+        id,
+        data: { action, points, reason, type }
+      });
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: CUSTOMER_KEYS.lists() });
+      queryClient.invalidateQueries({ queryKey: CUSTOMER_KEYS.details() });
+      toast.success("Membership updated successfully");
+    },
+    onError: (error) => {
+      toast.error(error.message || "Failed to update membership");
+    }
+  });
+  return {
+    membershipAction: mutation.mutateAsync,
+    isPending: mutation.isPending
+  };
+}
+var POS_KEYS = {
+  all: ["pos"],
+  products: (branchId) => [...POS_KEYS.all, "products", branchId],
+  productsList: (branchId, params) => [...POS_KEYS.products(branchId), params],
+  lookup: (code, branchId) => [...POS_KEYS.all, "lookup", code, branchId],
+  orders: () => [...POS_KEYS.all, "orders"],
+  receipt: (orderId) => [...POS_KEYS.orders(), orderId, "receipt"]
+};
+function usePosProducts(token, branchId, filters = {}, options = {}) {
+  const queryKey = POS_KEYS.productsList(branchId, filters);
+  const { data, isLoading, isFetching, error, refetch } = useQuery({
+    queryKey,
+    queryFn: () => posApi.getProducts({
+      token,
+      branchId,
+      category: filters.category,
+      search: filters.search,
+      inStockOnly: filters.inStockOnly,
+      lowStockOnly: filters.lowStockOnly,
+      after: filters.after,
+      limit: filters.limit || 50,
+      sort: filters.sort || "name"
+    }),
+    enabled: !!token && options.enabled !== false,
+    staleTime: 30 * 1e3,
+    // 30 seconds
+    refetchOnWindowFocus: true
+  });
+  return {
+    products: data?.docs || [],
+    summary: data?.summary || { totalItems: 0, totalQuantity: 0, lowStockCount: 0, outOfStockCount: 0 },
+    branch: data?.branch || { _id: "", code: "", name: "" },
+    hasMore: data?.hasMore || false,
+    nextCursor: data?.next || null,
+    isLoading,
+    isFetching,
+    error,
+    refetch
+  };
+}
+function usePosLookup(token, code, branchId, options = {}) {
+  return useQuery({
+    queryKey: POS_KEYS.lookup(code, branchId),
+    queryFn: () => posApi.lookup({ token, code, branchId }),
+    enabled: !!token && !!code && code.length >= 2 && options.enabled !== false,
+    staleTime: 10 * 1e3,
+    // 10 seconds
+    retry: false
+    // Don't retry failed lookups
+  });
+}
+function usePosLookupMutation(token) {
+  const toast = getToastHandler();
+  const mutation = useMutation({
+    mutationFn: ({ code, branchId }) => posApi.lookup({ token, code, branchId }),
+    onError: (error) => {
+      toast.error(error.message || "Lookup failed");
+    }
+  });
+  return {
+    lookup: mutation.mutateAsync,
+    isLooking: mutation.isPending,
+    error: mutation.error
+  };
+}
+function usePosReceipt(token, orderId, options = {}) {
+  return useQuery({
+    queryKey: POS_KEYS.receipt(orderId),
+    queryFn: async () => {
+      const result = await posApi.getReceipt({ token, orderId });
+      return result;
+    },
+    enabled: !!token && !!orderId && options.enabled !== false,
+    staleTime: Infinity
+    // Receipts don't change
+  });
+}
+function usePosOrders(token) {
+  const queryClient = useQueryClient();
+  const createOrderMutation = useMutation({
+    mutationFn: (data) => posApi.createOrder({ token, data }),
+    onSuccess: (_result, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: POS_KEYS.products(variables.branchId)
+      });
+    }
+  });
+  return {
+    createOrder: createOrderMutation.mutateAsync,
+    isCreatingOrder: createOrderMutation.isPending
+  };
+}
+function usePosStockActions(token, branchId) {
+  const queryClient = useQueryClient();
+  const toast = getToastHandler();
+  const adjustMutation = useMutation({
+    mutationFn: (data) => posApi.adjustStock({ token, data }),
+    onSuccess: () => {
+      toast.success("Stock adjusted");
+      queryClient.invalidateQueries({ queryKey: POS_KEYS.products(branchId) });
+    },
+    onError: (error) => {
+      toast.error(error.message || "Failed to adjust stock");
+    }
+  });
+  const setMutation = useMutation({
+    mutationFn: (params) => posApi.setStock({
+      token,
+      productId: params.productId,
+      data: {
+        quantity: params.quantity,
+        branchId: params.branchId || branchId,
+        variantSku: params.variantSku,
+        reason: params.reason
+      }
+    }),
+    onSuccess: () => {
+      toast.success("Stock updated");
+      queryClient.invalidateQueries({ queryKey: POS_KEYS.products(branchId) });
+    },
+    onError: (error) => {
+      toast.error(error.message || "Failed to set stock");
+    }
+  });
+  const bulkMutation = useMutation({
+    mutationFn: (data) => posApi.bulkAdjust({ token, data }),
+    onSuccess: () => {
+      toast.success("Bulk adjustment complete");
+      queryClient.invalidateQueries({ queryKey: POS_KEYS.products(branchId) });
+    },
+    onError: (error) => {
+      toast.error(error.message || "Failed to bulk adjust");
+    }
+  });
+  return {
+    adjustStock: adjustMutation.mutateAsync,
+    isAdjusting: adjustMutation.isPending,
+    setStock: setMutation.mutateAsync,
+    isSetting: setMutation.isPending,
+    bulkAdjust: bulkMutation.mutateAsync,
+    isBulkAdjusting: bulkMutation.isPending,
+    isLoading: adjustMutation.isPending || setMutation.isPending || bulkMutation.isPending
+  };
+}
+function generateIdempotencyKey(terminalId) {
+  const terminal = terminalId || "default";
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const counter = Math.floor(Math.random() * 1e4).toString().padStart(4, "0");
+  return `pos_${terminal}_${timestamp}_${counter}`;
+}
+function calculateVariantPrice(basePrice, priceModifier = 0) {
+  return basePrice + priceModifier;
+}
+function formatVariantLabel(attributes) {
+  if (!attributes || Object.keys(attributes).length === 0) return "";
+  return Object.entries(attributes).map(([key, value]) => `${key.charAt(0).toUpperCase() + key.slice(1)}: ${value}`).join(", ");
+}
+function isVariantProduct(product) {
+  return product.productType === "variant" || !!product.variants && product.variants.length > 0;
+}
+function getAvailableVariants(product) {
+  if (!product.variants) return [];
+  return product.variants.filter((v) => v.isActive);
+}
+function findVariantBySku(product, sku) {
+  if (!product.variants) return null;
+  return product.variants.find((v) => v.sku === sku) || null;
+}
+function getVariantStock(product, variantSku) {
+  if (!product.branchStock?.variants) return 0;
+  const variantStock = product.branchStock.variants.find((v) => v.sku === variantSku);
+  return variantStock?.quantity || 0;
+}
+function isInStock(product, variantSku) {
+  if (variantSku) {
+    const stock = getVariantStock(product, variantSku);
+    return stock > 0;
+  }
+  return product.branchStock?.inStock ?? false;
+}
+function getPosProductImage(product) {
+  const firstImage = product.images?.[0];
+  if (!firstImage) return "/placeholder.png";
+  return firstImage.variants?.thumbnail || firstImage.url;
+}
+
+export { CART_KEYS, CUSTOMER_KEYS, CustomerApi, ORDER_KEYS, OrderStatus, POS_KEYS, PaymentStatus, calculateCartSubtotal, calculateItemPrice, calculateItemTotal, calculateVariantPrice, cartApi, customerApi, customerHooks, findVariantBySku, formatVariantAttributes, formatVariantLabel, generateIdempotencyKey, getAvailableVariants, getCartItemCount, getCartItemVariant, getPosProductImage, getVariantStock, isInStock, isVariantProduct, orderApi, orderHooks, order_default, useAdminOrderActions, useCart, useCartCount, useCurrentCustomer, useCustomerActions, useCustomerDetail, useCustomerMembership, useCustomerNavigation, useCustomerOrderActions, useCustomers, useMyOrderDetail, useMyOrders, useOrderActions, useOrderDetail, useOrderNavigation, useOrders, usePosLookup, usePosLookupMutation, usePosOrders, usePosProducts, usePosReceipt, usePosStockActions };
+//# sourceMappingURL=chunk-UGELTUIZ.js.map
+//# sourceMappingURL=chunk-UGELTUIZ.js.map