@classytic/pos-ui 0.1.0

package/dist/hardware/web-adapter.js

@@ -0,0 +1,80 @@
+import { createTauriHardware, isTauri } from "./tauri-adapter.js";
+import { printDocument } from "@classytic/fluid/client/core";
+
+//#region src/hardware/web-adapter.ts
+/**
+* Web (browser) hardware adapter — the default for the dashboard POS.
+*
+*   Printer  → `window.print()` with print isolation (existing behavior).
+*              Future: POST to `@classytic/pos-agent` on `localhost:9100`
+*              for real ESC/POS thermal printing.
+*   Drawer   → not available; logs a warning. Real drawer needs the agent.
+*   Scanner  → handled at the consumer layer via fluid's `useBarcodeScan`
+*              hook (capture-phase HID burst detector with prefix routing).
+*              The port adapter here is a NO-OP stub kept for parity with
+*              the Tauri / RN shells that wire native scanners.
+*   Terminal → not available; charges go through bank standalone terminals
+*              with cashier-typed reference (out-of-PCI-scope by design).
+*
+* The Tauri / React Native shells will replace this with native adapters
+* implementing the same `PosHardware` shape. Same React tree, different
+* hardware backend.
+*/
+/** DOM id of the rendered receipt — used by `printDocument` for print isolation. */
+const RECEIPT_DOM_ID = "pos-receipt";
+var WebReceiptPrinter = class {
+	async print() {
+		if (typeof window === "undefined") throw new Error("WebReceiptPrinter requires a browser window");
+		printDocument(RECEIPT_DOM_ID);
+	}
+	async isAvailable() {
+		return typeof window !== "undefined";
+	}
+};
+var WebCashDrawer = class {
+	async open() {
+		console.warn("[pos/hardware] Cash drawer kick is unavailable in the browser adapter. Install @classytic/pos-agent or use the Tauri shell.");
+	}
+	async isAvailable() {
+		return false;
+	}
+};
+var WebBarcodeScannerStub = class {
+	onScan() {
+		return () => {};
+	}
+	async isAvailable() {
+		return typeof window !== "undefined";
+	}
+};
+var WebPaymentTerminal = class {
+	async charge() {
+		throw new Error("[pos/hardware] EMV payment terminal not available in browser adapter — capture cashier-typed reference instead.");
+	}
+	async refund() {
+		throw new Error("[pos/hardware] EMV payment terminal not available in browser adapter.");
+	}
+	async cancel() {}
+	async isAvailable() {
+		return false;
+	}
+};
+/**
+* Auto-detects the host: returns native Tauri adapters when the React
+* tree is running inside the `cashier-tauri` webview, otherwise returns
+* the browser stubs. Consumers stay agnostic — `<HardwareProvider>` in
+* `pos-shell.tsx` calls this once at mount and the same React tree
+* works on both surfaces with no per-component branching.
+*/
+function createWebHardware() {
+	if (isTauri()) return createTauriHardware();
+	return {
+		printer: new WebReceiptPrinter(),
+		drawer: new WebCashDrawer(),
+		scanner: new WebBarcodeScannerStub(),
+		terminal: new WebPaymentTerminal()
+	};
+}
+
+//#endregion
+export { RECEIPT_DOM_ID, createWebHardware };

package/dist/hooks/useManagerAuth.js

@@ -0,0 +1,83 @@
+"use client";
+
+import { usePosAuth } from "../runtime/auth-port.js";
+import { useCallback, useState } from "react";
+import { useMutation } from "@tanstack/react-query";
+
+//#region src/hooks/useManagerAuth.ts
+/** Roles allowed to authorize discounts */
+const DISCOUNT_ALLOWED_ROLES = [
+	"superadmin",
+	"admin",
+	"branch_manager"
+];
+/**
+* Hook for temporary manager authentication in POS.
+* Uses Better Auth's signIn.email() directly — same as the sign-in page.
+* Does NOT create a persistent session (the token is discarded).
+*/
+function useManagerAuth(options = {}) {
+	const { allowedRoles = DISCOUNT_ALLOWED_ROLES, sessionDuration = 30 } = options;
+	const { signInManager } = usePosAuth();
+	const [authState, setAuthState] = useState({
+		isAuthorized: false,
+		authorizedBy: null,
+		authorizedAt: null,
+		authorizedAtMono: null
+	});
+	const isSessionValid = useCallback(() => {
+		if (!authState.isAuthorized || authState.authorizedAtMono === null) return false;
+		return performance.now() - authState.authorizedAtMono < sessionDuration * 60 * 1e3;
+	}, [
+		authState.isAuthorized,
+		authState.authorizedAtMono,
+		sessionDuration
+	]);
+	const verifyMutation = useMutation({
+		mutationFn: async (credentials) => {
+			const { user: sessionUser } = await signInManager({
+				email: credentials.email,
+				password: credentials.password
+			});
+			const user = sessionUser;
+			if (!user) throw new Error("Authentication failed");
+			if (!(Array.isArray(user.role) ? user.role : []).some((role) => allowedRoles.includes(role))) throw new Error("You don't have permission to authorize discounts");
+			return user;
+		},
+		onSuccess: (user) => {
+			setAuthState({
+				isAuthorized: true,
+				authorizedBy: user,
+				authorizedAt: /* @__PURE__ */ new Date(),
+				authorizedAtMono: performance.now()
+			});
+		}
+	});
+	const clearAuth = useCallback(() => {
+		setAuthState({
+			isAuthorized: false,
+			authorizedBy: null,
+			authorizedAt: null,
+			authorizedAtMono: null
+		});
+	}, []);
+	const authorize = useCallback(async (email, password) => {
+		return verifyMutation.mutateAsync({
+			email,
+			password
+		});
+	}, [verifyMutation]);
+	return {
+		isAuthorized: authState.isAuthorized && isSessionValid(),
+		authorizedBy: authState.authorizedBy,
+		authorizedAt: authState.authorizedAt,
+		authorize,
+		clearAuth,
+		isPending: verifyMutation.isPending,
+		error: verifyMutation.error?.message || null,
+		reset: verifyMutation.reset
+	};
+}
+
+//#endregion
+export { DISCOUNT_ALLOWED_ROLES, useManagerAuth };

package/dist/hooks/usePosCart.js

@@ -0,0 +1,142 @@
+"use client";
+
+import { useCallback } from "react";
+import { useLocalStorage } from "@classytic/fluid/client/hooks";
+import { calculateVariantPrice, formatVariantLabel, getPosPrice, getPosProductImage, getVariantStock } from "@classytic/commerce-sdk/sales";
+import { toast } from "sonner";
+
+//#region src/hooks/usePosCart.ts
+const CART_TTL = 1440 * 60 * 1e3;
+function usePosCart(branchId) {
+	const suffix = branchId ?? "default";
+	const [cart, setCart, clearStoredCart] = useLocalStorage(`pos:cart:${suffix}`, [], CART_TTL);
+	const [discountInput, setDiscountInput, clearDiscountInput] = useLocalStorage(`pos:discount:${suffix}`, "", CART_TTL);
+	const [membershipCardId, setMembershipCardId, clearMembershipCardId] = useLocalStorage(`pos:membership:${suffix}`, "", CART_TTL);
+	const [pointsToRedeemInput, setPointsToRedeemInput, clearPointsToRedeem] = useLocalStorage(`pos:points:${suffix}`, "", CART_TTL);
+	return {
+		cart,
+		membershipCardId,
+		pointsToRedeemInput,
+		discountInput,
+		setDiscountInput,
+		setMembershipCardId,
+		setPointsToRedeemInput,
+		addToCart: useCallback((product, variantSku) => {
+			const variant = variantSku ? product.variants?.find((v) => v.sku === variantSku) : null;
+			if (variantSku) {
+				if (getVariantStock(product, variantSku) <= 0) {
+					toast.error("Out of stock");
+					return;
+				}
+			} else if (!product.branchStock?.inStock) {
+				toast.error("Out of stock");
+				return;
+			}
+			const basePrice = getPosPrice(product);
+			const unitPrice = variant ? calculateVariantPrice(basePrice, variant.priceModifier ?? 0) : basePrice;
+			setCart((prev) => {
+				const existingIndex = prev.findIndex((item) => item.productId === product._id && item.variantSku === variantSku);
+				if (existingIndex >= 0) {
+					const next = [...prev];
+					const existing = next[existingIndex];
+					const quantity = existing.quantity + 1;
+					next[existingIndex] = {
+						...existing,
+						quantity,
+						lineTotal: quantity * unitPrice
+					};
+					return next;
+				}
+				const newItem = {
+					productId: product._id,
+					productName: product.name,
+					variantSku,
+					variantLabel: variant?.attributes ? formatVariantLabel(variant.attributes) : void 0,
+					quantity: 1,
+					unitPrice,
+					lineTotal: unitPrice,
+					image: getPosProductImage(product)
+				};
+				return [...prev, newItem];
+			});
+			toast.success("Added to cart");
+		}, []),
+		addCharge: useCallback((label, amountBdt) => {
+			const trimmedLabel = label.trim();
+			if (!trimmedLabel) {
+				toast.error("Label is required");
+				return;
+			}
+			if (!Number.isFinite(amountBdt) || amountBdt < 0) {
+				toast.error("Amount must be 0 or greater");
+				return;
+			}
+			const code = trimmedLabel.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "misc";
+			setCart((prev) => {
+				const existingIndex = prev.findIndex((item) => item.kind === "service-fee" && item.serviceCode === code);
+				if (existingIndex >= 0) {
+					const next = [...prev];
+					const existing = next[existingIndex];
+					const quantity = existing.quantity + 1;
+					next[existingIndex] = {
+						...existing,
+						quantity,
+						lineTotal: quantity * existing.unitPrice
+					};
+					return next;
+				}
+				const newItem = {
+					kind: "service-fee",
+					serviceCode: code,
+					productId: `service:${code}`,
+					productName: trimmedLabel,
+					quantity: 1,
+					unitPrice: amountBdt,
+					lineTotal: amountBdt
+				};
+				return [...prev, newItem];
+			});
+			toast.success(`Added ${trimmedLabel}`);
+		}, [setCart]),
+		updateQuantity: useCallback((index, delta) => {
+			setCart((prev) => {
+				const next = [...prev];
+				const item = next[index];
+				if (!item) return prev;
+				const quantity = Math.max(1, item.quantity + delta);
+				next[index] = {
+					...item,
+					quantity,
+					lineTotal: quantity * item.unitPrice
+				};
+				return next;
+			});
+		}, []),
+		removeItem: useCallback((index) => {
+			setCart((prev) => prev.filter((_, i) => i !== index));
+		}, []),
+		clearCart: useCallback(() => {
+			if (window.confirm("Clear all items from cart?")) {
+				setCart([]);
+				clearPointsToRedeem();
+			}
+		}, [setCart, clearPointsToRedeem]),
+		resetCart: useCallback(() => {
+			clearStoredCart();
+			clearDiscountInput();
+			clearMembershipCardId();
+			clearPointsToRedeem();
+		}, [
+			clearStoredCart,
+			clearDiscountInput,
+			clearMembershipCardId,
+			clearPointsToRedeem
+		]),
+		replaceCart: useCallback((items) => {
+			setCart(items);
+		}, [setCart])
+	};
+}
+
+//#endregion
+export { usePosCart };

package/dist/hooks/usePosCustomer.js

@@ -0,0 +1,192 @@
+"use client";
+
+import { usePosAuth } from "../runtime/auth-port.js";
+import { isPhoneSearch } from "../utils/pos-helpers.js";
+import { customerDisplayName, customerDisplayPhone } from "../utils/customer-display.js";
+import { useCallback, useMemo, useState } from "react";
+import { useLocalStorage } from "@classytic/fluid/client/hooks";
+import { useCustomers, useLookupMemberByCard } from "@classytic/commerce-sdk/sales";
+import { toast } from "sonner";
+import { buildFilterParams, getApiParams } from "@classytic/fluid";
+
+//#region src/hooks/usePosCustomer.ts
+const CUSTOMER_TTL = 1440 * 60 * 1e3;
+function usePosCustomer(token) {
+	const authToken = usePosAuth().getToken();
+	const resolvedToken = token || authToken || "";
+	const [selectedCustomer, setSelectedCustomer] = useLocalStorage("pos:customer:selected", null, CUSTOMER_TTL);
+	const [customerName, setCustomerNameState] = useLocalStorage("pos:customer:name", "", CUSTOMER_TTL);
+	const [customerPhone, setCustomerPhoneState] = useLocalStorage("pos:customer:phone", "", CUSTOMER_TTL);
+	const [membershipCardId, setMembershipCardIdState] = useLocalStorage("pos:customer:membershipCard", "", CUSTOMER_TTL);
+	const [membershipLookupStatus, setMembershipLookupStatus] = useState("idle");
+	const [customerSearch, setCustomerSearch] = useState("");
+	const [searchApplied, setSearchApplied] = useState("");
+	const [createDialogOpen, setCreateDialogOpen] = useState(false);
+	const [lookupDialogOpen, setLookupDialogOpen] = useState(false);
+	const { lookup: lookupMemberByCard, isLooking: membershipLookupPending } = useLookupMemberByCard();
+	const normalizedSearch = searchApplied.trim();
+	const phoneCheck = isPhoneSearch(normalizedSearch);
+	const { items: customerResultsRaw, isLoading: customersLoading, isFetching: customersFetching, refetch: refetchCustomers } = useCustomers(resolvedToken, useMemo(() => {
+		const params = new URLSearchParams();
+		params.set("limit", "5");
+		if (!normalizedSearch) return getApiParams(params);
+		if (phoneCheck.exact) {
+			const filterParams = buildFilterParams({ phone: normalizedSearch }, { phone: {
+				paramName: "contact.phone",
+				type: "string",
+				defaultValue: ""
+			} });
+			for (const [key, value] of filterParams) params.set(key, value);
+		} else if (phoneCheck.likely) {
+			const phoneParams = buildFilterParams({ phone: normalizedSearch }, { phone: {
+				paramName: "contact.phone[contains]",
+				type: "string",
+				defaultValue: ""
+			} });
+			for (const [key, value] of phoneParams) params.set(key, value);
+		} else {
+			const nameParams = buildFilterParams({ name: normalizedSearch }, { name: {
+				paramName: "name.given[contains]",
+				type: "string",
+				defaultValue: ""
+			} });
+			for (const [key, value] of nameParams) params.set(key, value);
+		}
+		return getApiParams(params);
+	}, [
+		normalizedSearch,
+		phoneCheck.exact,
+		phoneCheck.likely
+	]), {
+		enabled: !!resolvedToken && normalizedSearch.length >= 2,
+		refetchOnWindowFocus: false
+	});
+	const customerResults = useMemo(() => normalizedSearch.length >= 2 ? customerResultsRaw || [] : [], [customerResultsRaw, normalizedSearch.length]);
+	const setCustomerName = useCallback((value) => {
+		setCustomerNameState(value);
+		if (selectedCustomer) setSelectedCustomer(null);
+	}, [selectedCustomer]);
+	const setCustomerPhone = useCallback((value) => {
+		setCustomerPhoneState(value);
+		if (selectedCustomer) setSelectedCustomer(null);
+	}, [selectedCustomer]);
+	const setMembershipCardId = useCallback((value) => {
+		setMembershipCardIdState(value);
+		setMembershipLookupStatus("idle");
+	}, []);
+	const selectCustomer = useCallback((customer) => {
+		setSelectedCustomer(customer);
+		setCustomerNameState(customerDisplayName(customer));
+		setCustomerPhoneState(customerDisplayPhone(customer) ?? "");
+		setMembershipCardIdState(customer.membership?.cardId || "");
+		setMembershipLookupStatus(customer.membership?.cardId ? "found" : "idle");
+		setCustomerSearch("");
+		setSearchApplied("");
+		setLookupDialogOpen(false);
+	}, []);
+	const clearCustomer = useCallback(() => {
+		setSelectedCustomer(null);
+		setCustomerNameState("");
+		setCustomerPhoneState("");
+		setMembershipCardIdState("");
+		setMembershipLookupStatus("idle");
+		setCustomerSearch("");
+		setSearchApplied("");
+	}, []);
+	const handleCustomerCreated = useCallback((customer) => {
+		setSelectedCustomer(customer);
+		setCustomerNameState(customerDisplayName(customer));
+		setCustomerPhoneState(customerDisplayPhone(customer) ?? "");
+		setMembershipCardIdState(customer.membership?.cardId || "");
+		setMembershipLookupStatus(customer.membership?.cardId ? "found" : "idle");
+		setCustomerSearch("");
+		setSearchApplied("");
+		setLookupDialogOpen(false);
+	}, []);
+	const triggerSearch = useCallback(() => {
+		const trimmed = customerSearch.trim();
+		if (trimmed.length < 2) {
+			toast.error("Enter at least 2 characters to search");
+			return;
+		}
+		setSearchApplied(trimmed);
+		if (trimmed === searchApplied) refetchCustomers();
+	}, [
+		customerSearch,
+		searchApplied,
+		refetchCustomers
+	]);
+	/**
+	* POS card-scan path. Hardware barcode scanners type the card id and emit
+	* Enter, so this is invoked from the input's onKeyDown=Enter or the
+	* adjacent Lookup button. Calls the dedicated
+	* `GET /loyalty/members/by-card/:cardId` endpoint and reuses
+	* `selectCustomer()` so the cart-attach behavior is identical to picking
+	* a customer from the search dialog.
+	*/
+	const triggerMembershipLookup = useCallback(async () => {
+		const trimmed = membershipCardId.trim();
+		if (!trimmed) {
+			setMembershipLookupStatus("idle");
+			return;
+		}
+		setMembershipLookupStatus("searching");
+		try {
+			const customer = (await lookupMemberByCard(trimmed))?.customer;
+			if (!customer) {
+				setMembershipLookupStatus("not_found");
+				setMembershipCardIdState("");
+				toast.error("Card not found");
+				return;
+			}
+			selectCustomer(customer);
+			setMembershipLookupStatus("found");
+		} catch (err) {
+			setMembershipLookupStatus("not_found");
+			setMembershipCardIdState("");
+			const message = err instanceof Error ? err.message : "Card not found";
+			if (message.includes("404") || /not found/i.test(message)) return;
+			toast.error(message);
+		}
+	}, [
+		membershipCardId,
+		lookupMemberByCard,
+		selectCustomer
+	]);
+	const resetCustomer = useCallback(() => {
+		setSelectedCustomer(null);
+		setCustomerNameState("");
+		setCustomerPhoneState("");
+		setMembershipCardIdState("");
+		setMembershipLookupStatus("idle");
+		setCustomerSearch("");
+		setSearchApplied("");
+	}, []);
+	return {
+		selectedCustomer,
+		customerName,
+		customerPhone,
+		membershipCardId,
+		membershipLookupStatus: membershipLookupPending ? "searching" : membershipLookupStatus,
+		customerSearch,
+		customerResults,
+		isSearching: customersLoading || customersFetching,
+		createDialogOpen,
+		lookupDialogOpen,
+		setCustomerName,
+		setCustomerPhone,
+		setMembershipCardId,
+		setCustomerSearch,
+		setCreateDialogOpen,
+		setLookupDialogOpen,
+		selectCustomer,
+		clearCustomer,
+		handleCustomerCreated,
+		triggerSearch,
+		triggerMembershipLookup,
+		resetCustomer
+	};
+}
+
+//#endregion
+export { usePosCustomer };

package/dist/hooks/usePosMultiOrder.js

@@ -0,0 +1,48 @@
+"use client";
+
+import { useCallback } from "react";
+import { useLocalStorage } from "@classytic/fluid/client/hooks";
+
+//#region src/hooks/usePosMultiOrder.ts
+/**
+* usePosMultiOrder — Park and resume multiple orders.
+*
+* Max 5 parked orders stored in localStorage per branch.
+* Each parked order saves: cart items, customer info, discount state.
+*/
+const MAX_PARKED_ORDERS = 5;
+const PARKED_TTL = 480 * 60 * 1e3;
+function usePosMultiOrder(branchId) {
+	const [orders, setOrders] = useLocalStorage(branchId ? `pos:parked:${branchId}` : "pos:parked:default", [], PARKED_TTL);
+	const canPark = orders.length < MAX_PARKED_ORDERS;
+	return {
+		orders,
+		parkOrder: useCallback((order) => {
+			const id = `parked_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+			const parked = {
+				...order,
+				id,
+				parkedAt: Date.now()
+			};
+			setOrders((prev) => [...prev, parked]);
+			return id;
+		}, [setOrders]),
+		resumeOrder: useCallback((id) => {
+			let found = null;
+			setOrders((prev) => {
+				const idx = prev.findIndex((o) => o.id === id);
+				if (idx === -1) return prev;
+				found = prev[idx];
+				return prev.filter((_, i) => i !== idx);
+			});
+			return found;
+		}, [setOrders]),
+		deleteOrder: useCallback((id) => {
+			setOrders((prev) => prev.filter((o) => o.id !== id));
+		}, [setOrders]),
+		canPark
+	};
+}
+
+//#endregion
+export { usePosMultiOrder };