@classytic/commerce-sdk 0.1.1 → 0.2.1

package/dist/sales/hooks/order.js

@@ -0,0 +1,401 @@
+"use client";
+
+import { getToastHandler } from "../../core/react/mutation.factory.js";
+import { createCrudHooks } from "../../core/react/crud.factory.js";
+import orderApi from "../api/order.js";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+
+//#region src/sales/hooks/order.ts
+/**
+* Order Hooks
+*
+* React hooks for order CRUD operations using the factory pattern.
+* Includes customer-facing and admin-specific hooks.
+*/
+/**
+* Extended order query keys
+*/
+const createOrderKeys = () => ({
+	all: ["orders"],
+	lists: () => [...createOrderKeys().all, "list"],
+	list: (params) => [...createOrderKeys().lists(), params],
+	details: () => [...createOrderKeys().all, "detail"],
+	detail: (id) => [...createOrderKeys().details(), id],
+	myOrders: (params) => [
+		...createOrderKeys().all,
+		"my",
+		params
+	],
+	myDetail: (id) => [
+		...createOrderKeys().all,
+		"my",
+		"detail",
+		id
+	]
+});
+/**
+* Order hooks using createCrudHooks factory
+*
+* Provides:
+* - useOrders: List orders with filtering/pagination
+* - useOrderDetail: Get single order
+* - useOrderActions: Create, update, delete mutations
+* - useOrderNavigation: Navigation between orders
+*/
+const orderHooks = createCrudHooks({
+	api: orderApi,
+	entityKey: "orders",
+	singular: "Order",
+	plural: "Orders",
+	defaults: { staleTime: 60 * 1e3 }
+});
+const ORDER_KEYS = createOrderKeys();
+const { useList: useOrders, useDetail: useOrderDetail, useActions: useOrderActions, useNavigation: useOrderNavigation } = orderHooks;
+/**
+* Get customer's own orders
+*
+* @param token - Auth token
+* @param params - Query params { page, limit, status, sort }
+* @param options - Query options
+*
+* @example
+* ```tsx
+* function MyOrdersPage() {
+*   const { orders, isLoading, hasMore } = useMyOrders(token, { limit: 10 });
+*
+*   return (
+*     <OrderList orders={orders} loading={isLoading} />
+*   );
+* }
+* ```
+*/
+function useMyOrders(token, params = {}, options = {}) {
+	const { data, isLoading, isFetching, error, refetch } = useQuery({
+		queryKey: ORDER_KEYS.myOrders(params),
+		queryFn: async () => {
+			return await orderApi.getMyOrders({
+				token,
+				params
+			});
+		},
+		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
+	};
+}
+/**
+* Get customer's own order detail
+*
+* @param token - Auth token
+* @param orderId - Order ID
+* @param options - Query options
+*
+* @example
+* ```tsx
+* function OrderDetailPage({ orderId }) {
+*   const { data: order, isLoading } = useMyOrderDetail(token, orderId);
+*
+*   if (isLoading) return <Skeleton />;
+*   return <OrderDetail order={order} />;
+* }
+* ```
+*/
+function useMyOrderDetail(token, orderId, options = {}) {
+	return useQuery({
+		queryKey: ORDER_KEYS.myDetail(orderId),
+		queryFn: async () => {
+			return (await orderApi.getMyOrder({
+				token,
+				id: orderId
+			})).data;
+		},
+		enabled: !!token && !!orderId && options.enabled !== false,
+		staleTime: options.staleTime ?? 30 * 1e3
+	});
+}
+/**
+* Customer order actions (checkout, request cancellation)
+*
+* @param token - Customer auth token
+*
+* @example
+* ```tsx
+* function CheckoutButton({ cart }) {
+*   const { checkout, isCheckingOut } = useCustomerOrderActions(token);
+*
+*   const handleCheckout = async () => {
+*     const order = await checkout({
+*       items: cart.items,
+*       shipping: shippingAddress,
+*       payment: { method: 'bkash' },
+*     });
+*     router.push(`/orders/${order._id}`);
+*   };
+*
+*   return (
+*     <Button onClick={handleCheckout} disabled={isCheckingOut}>
+*       {isCheckingOut ? 'Processing...' : 'Place Order'}
+*     </Button>
+*   );
+* }
+* ```
+*/
+function useCustomerOrderActions(token) {
+	const queryClient = useQueryClient();
+	const toast = getToastHandler();
+	const checkoutMutation = useMutation({
+		mutationFn: async (data) => {
+			return (await orderApi.checkout({
+				token,
+				data
+			})).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 }) => {
+			return (await orderApi.requestCancellation({
+				token,
+				id: orderId,
+				reason
+			})).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
+	};
+}
+/**
+* Guest checkout mutation (no auth required)
+*
+* For unauthenticated users. Items are sent from FE localStorage.
+*
+* @example
+* ```tsx
+* function GuestCheckoutButton({ cartItems, guestInfo, address }) {
+*   const { guestCheckout, isCheckingOut } = useGuestCheckout();
+*
+*   const handleCheckout = async () => {
+*     const order = await guestCheckout({
+*       items: cartItems,
+*       guest: guestInfo,
+*       deliveryAddress: address,
+*       delivery: { method: 'standard', price: 80 },
+*     });
+*     router.push(`/order-confirmation/${order._id}`);
+*   };
+*
+*   return (
+*     <Button onClick={handleCheckout} disabled={isCheckingOut}>
+*       {isCheckingOut ? 'Processing...' : 'Place Order'}
+*     </Button>
+*   );
+* }
+* ```
+*/
+function useGuestCheckout() {
+	const queryClient = useQueryClient();
+	const toast = getToastHandler();
+	const mutation = useMutation({
+		mutationFn: async (data) => {
+			return (await orderApi.guestCheckout({ data })).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
+	};
+}
+/**
+* Admin order actions (status, fulfill, refund, cancel, shipping)
+*
+* @param token - Admin auth token
+*
+* @example
+* ```tsx
+* function OrderActions({ order }) {
+*   const {
+*     updateStatus,
+*     fulfillOrder,
+*     cancelOrder,
+*     isLoading,
+*   } = useAdminOrderActions(token);
+*
+*   return (
+*     <>
+*       <Button onClick={() => updateStatus({ orderId: order._id, status: 'processing' })}>
+*         Mark Processing
+*       </Button>
+*       <Button onClick={() => fulfillOrder({ orderId: order._id, branchId: 'branch_123' })}>
+*         Fulfill Order
+*       </Button>
+*     </>
+*   );
+* }
+* ```
+*/
+function useAdminOrderActions(token) {
+	const queryClient = useQueryClient();
+	const toast = getToastHandler();
+	const updateStatusMutation = useMutation({
+		mutationFn: async ({ orderId, status, note }) => {
+			return (await orderApi.updateStatus({
+				token,
+				id: orderId,
+				data: {
+					status,
+					note
+				}
+			})).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 }) => {
+			return (await orderApi.fulfill({
+				token,
+				id: orderId,
+				data
+			})).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 }) => {
+			return (await orderApi.refund({
+				token,
+				id: orderId,
+				data: {
+					amount,
+					reason
+				}
+			})).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 }) => {
+			return (await orderApi.cancel({
+				token,
+				id: orderId,
+				reason,
+				refund
+			})).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 }) => {
+			return (await orderApi.requestShipping({
+				token,
+				id: orderId,
+				data
+			})).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 }) => {
+			return (await orderApi.updateShipping({
+				token,
+				id: orderId,
+				data
+			})).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
+	};
+}
+
+//#endregion
+export { ORDER_KEYS, orderHooks, useAdminOrderActions, useCustomerOrderActions, useGuestCheckout, useMyOrderDetail, useMyOrders, useOrderActions, useOrderDetail, useOrderNavigation, useOrders };

package/dist/sales/hooks/pos.d.ts

@@ -0,0 +1,87 @@
+import { ProductVariant } from "../../catalog/types/product.js";
+import { PosLookupResponse, PosOrderPayload, PosProduct, PosProductsResponse, PosReceiptResponse } from "../types/pos.js";
+import { BulkAdjustmentPayload, CreateAdjustmentPayload } from "../../inventory/types/inventory.js";
+import * as _tanstack_react_query0 from "@tanstack/react-query";
+
+//#region src/sales/hooks/pos.d.ts
+declare const POS_KEYS: {
+  all: readonly ["pos"];
+  products: (branchId?: string) => readonly ["pos", "products", string | undefined];
+  productsList: (branchId?: string, params?: Record<string, unknown>) => readonly ["pos", "products", string | undefined, Record<string, unknown> | undefined];
+  lookup: (code: string, branchId?: string) => readonly ["pos", "lookup", string, string | undefined];
+  orders: () => readonly ["pos", "orders"];
+  receipt: (orderId: string) => readonly ["pos", "orders", string, "receipt"];
+};
+interface PosProductFilters {
+  category?: string;
+  search?: string;
+  inStockOnly?: boolean;
+  lowStockOnly?: boolean;
+  after?: string;
+  limit?: number;
+  sort?: string;
+  [key: string]: unknown;
+}
+interface UsePosProductsReturn {
+  products: PosProduct[];
+  summary: PosProductsResponse["summary"];
+  branch: PosProductsResponse["branch"];
+  hasMore: boolean;
+  nextCursor: string | null;
+  isLoading: boolean;
+  isFetching: boolean;
+  error: Error | null;
+  refetch: () => void;
+}
+interface QueryOptions {
+  enabled?: boolean;
+}
+interface UsePosOrdersReturn {
+  createOrder: (data: PosOrderPayload) => Promise<unknown>;
+  isCreatingOrder: boolean;
+}
+interface UsePosStockActionsReturn {
+  adjustStock: (data: CreateAdjustmentPayload) => Promise<unknown>;
+  isAdjusting: boolean;
+  setStock: (params: {
+    productId: string;
+    quantity: number;
+    branchId?: string;
+    variantSku?: string;
+    reason?: string;
+  }) => Promise<unknown>;
+  isSetting: boolean;
+  bulkAdjust: (data: BulkAdjustmentPayload) => Promise<unknown>;
+  isBulkAdjusting: boolean;
+  isLoading: boolean;
+}
+/** Fetch POS products with branch-specific stock */
+declare function usePosProducts(token: string, branchId: string | undefined, filters?: PosProductFilters, options?: QueryOptions): UsePosProductsReturn;
+/** Lookup product by barcode/SKU (query-based) */
+declare function usePosLookup(token: string, code: string, branchId?: string, options?: QueryOptions): _tanstack_react_query0.UseQueryResult<PosLookupResponse, Error>;
+/** Lookup product by barcode/SKU (mutation-based, for scan-and-act) */
+declare function usePosLookupMutation(token: string): {
+  lookup: _tanstack_react_query0.UseMutateAsyncFunction<PosLookupResponse, Error, {
+    code: string;
+    branchId?: string;
+  }, unknown>;
+  isLooking: boolean;
+  error: Error | null;
+};
+/** Get receipt for an order */
+declare function usePosReceipt(token: string, orderId: string, options?: QueryOptions): _tanstack_react_query0.UseQueryResult<PosReceiptResponse, Error>;
+/** POS order operations */
+declare function usePosOrders(token: string): UsePosOrdersReturn;
+/** POS stock adjustment actions */
+declare function usePosStockActions(token: string, branchId?: string): UsePosStockActionsReturn;
+declare function generateIdempotencyKey(terminalId?: string): string;
+declare function calculateVariantPrice(basePrice: number, priceModifier?: number): number;
+declare function formatVariantLabel(attributes?: Record<string, string>): string;
+declare function isVariantProduct(product: PosProduct): boolean;
+declare function getAvailableVariants(product: PosProduct): ProductVariant[];
+declare function findVariantBySku(product: PosProduct, sku: string): ProductVariant | null;
+declare function getVariantStock(product: PosProduct, variantSku: string): number;
+declare function isInStock(product: PosProduct, variantSku?: string): boolean;
+declare function getPosProductImage(product: PosProduct): string;
+//#endregion
+export { POS_KEYS, PosProductFilters, UsePosOrdersReturn, UsePosProductsReturn, UsePosStockActionsReturn, calculateVariantPrice, findVariantBySku, formatVariantLabel, generateIdempotencyKey, getAvailableVariants, getPosProductImage, getVariantStock, isInStock, isVariantProduct, usePosLookup, usePosLookupMutation, usePosOrders, usePosProducts, usePosReceipt, usePosStockActions };

package/dist/sales/hooks/pos.js

@@ -0,0 +1,222 @@
+"use client";
+
+import { useMutationWithTransition } from "../../core/react/mutation.factory.js";
+import posApi from "../api/pos.js";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+
+//#region src/sales/hooks/pos.ts
+/**
+* POS Hooks
+*
+* React hooks for Point of Sale operations.
+*/
+const 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"
+	]
+};
+/** Fetch POS products with branch-specific stock */
+function usePosProducts(token, branchId, filters = {}, options = {}) {
+	const { data, isLoading, isFetching, error, refetch } = useQuery({
+		queryKey: POS_KEYS.productsList(branchId, filters),
+		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: 3e4,
+		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
+	};
+}
+/** Lookup product by barcode/SKU (query-based) */
+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: 1e4,
+		retry: false
+	});
+}
+/** Lookup product by barcode/SKU (mutation-based, for scan-and-act) */
+function usePosLookupMutation(token) {
+	const mutation = useMutationWithTransition({
+		mutationFn: ({ code, branchId }) => posApi.lookup({
+			token,
+			code,
+			branchId
+		}),
+		messages: { error: "Lookup failed" }
+	});
+	return {
+		lookup: mutation.mutateAsync,
+		isLooking: mutation.isPending,
+		error: mutation.error
+	};
+}
+/** Get receipt for an order */
+function usePosReceipt(token, orderId, options = {}) {
+	return useQuery({
+		queryKey: POS_KEYS.receipt(orderId),
+		queryFn: async () => {
+			return await posApi.getReceipt({
+				token,
+				orderId
+			});
+		},
+		enabled: !!token && !!orderId && options.enabled !== false,
+		staleTime: Infinity
+	});
+}
+/** POS order operations */
+function usePosOrders(token) {
+	const queryClient = useQueryClient();
+	const createOrderMutation = useMutationWithTransition({
+		mutationFn: (data) => posApi.createOrder({
+			token,
+			data
+		}),
+		onSuccess: (_result, variables) => {
+			queryClient.invalidateQueries({ queryKey: POS_KEYS.products(variables.branchId) });
+		}
+	});
+	return {
+		createOrder: createOrderMutation.mutateAsync,
+		isCreatingOrder: createOrderMutation.isPending
+	};
+}
+/** POS stock adjustment actions */
+function usePosStockActions(token, branchId) {
+	const adjustMutation = useMutationWithTransition({
+		mutationFn: (data) => posApi.adjustStock({
+			token,
+			data
+		}),
+		invalidateQueries: [POS_KEYS.products(branchId)],
+		messages: {
+			success: "Stock adjusted",
+			error: "Failed to adjust stock"
+		}
+	});
+	const setMutation = useMutationWithTransition({
+		mutationFn: (params) => posApi.setStock({
+			token,
+			productId: params.productId,
+			data: {
+				quantity: params.quantity,
+				branchId: params.branchId || branchId,
+				variantSku: params.variantSku,
+				reason: params.reason
+			}
+		}),
+		invalidateQueries: [POS_KEYS.products(branchId)],
+		messages: {
+			success: "Stock updated",
+			error: "Failed to set stock"
+		}
+	});
+	const bulkMutation = useMutationWithTransition({
+		mutationFn: (data) => posApi.bulkAdjust({
+			token,
+			data
+		}),
+		invalidateQueries: [POS_KEYS.products(branchId)],
+		messages: {
+			success: "Bulk adjustment complete",
+			error: "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) {
+	return `pos_${terminalId || "default"}_${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}_${Math.floor(Math.random() * 1e4).toString().padStart(4, "0")}`;
+}
+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;
+	return product.branchStock.variants.find((v) => v.sku === variantSku)?.quantity || 0;
+}
+function isInStock(product, variantSku) {
+	if (variantSku) return getVariantStock(product, variantSku) > 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;
+}
+
+//#endregion
+export { POS_KEYS, calculateVariantPrice, findVariantBySku, formatVariantLabel, generateIdempotencyKey, getAvailableVariants, getPosProductImage, getVariantStock, isInStock, isVariantProduct, usePosLookup, usePosLookupMutation, usePosOrders, usePosProducts, usePosReceipt, usePosStockActions };