@classytic/commerce-sdk 0.1.2 → 0.2.1

package/dist/chunk-4IYW6RF3.js

@@ -1,862 +0,0 @@
-import { posApi } from './chunk-CILP56G2.js';
-import { BaseApi } from './chunk-QCTXAMLA.js';
-import { createQueryKeys, createCrudHooks } from './chunk-B6MPVOV7.js';
-import { getToastHandler } from './chunk-U3XT35GZ.js';
-import { handleApiRequest } from './chunk-IHCBBLLW.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 });
-    /**
-     * Guest checkout - create order without authentication
-     * POST /api/v1/orders/guest
-     *
-     * Items are sent in the request body (from FE localStorage).
-     * Guest identity is provided via { name, phone, email }.
-     */
-    this.guestCheckout = ({ data, organizationId }) => this.request("POST", `${this.baseUrl}/guest`, {
-      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 useGuestCheckout() {
-  const queryClient = useQueryClient();
-  const toast = getToastHandler();
-  const mutation = useMutation({
-    mutationFn: async (data) => {
-      const response = await orderApi.guestCheckout({ data });
-      return response.data;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ORDER_KEYS.all });
-      toast.success("Order placed successfully!");
-    },
-    onError: (error) => {
-      toast.error(error.message || "Failed to place order");
-    }
-  });
-  return {
-    guestCheckout: mutation.mutateAsync,
-    isCheckingOut: mutation.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, useGuestCheckout, useMyOrderDetail, useMyOrders, useOrderActions, useOrderDetail, useOrderNavigation, useOrders, usePosLookup, usePosLookupMutation, usePosOrders, usePosProducts, usePosReceipt, usePosStockActions };
-//# sourceMappingURL=chunk-4IYW6RF3.js.map
-//# sourceMappingURL=chunk-4IYW6RF3.js.map