@classytic/pos-ui 0.1.0 → 1.2.0

package/dist/hooks/usePosCart.js

@@ -1,140 +1,247 @@
 "use client";
 
+import { minorToMajor } from "../lib/money.js";
+import { UNRESOLVED_BRANCH, branchScopedKey } from "./branch-scoped-key.js";
+import { resolveSaleAttemptKey } from "./sale-attempt.js";
 import { useCallback } from "react";
 import { useLocalStorage } from "@classytic/fluid/client/hooks";
-import { calculateVariantPrice, formatVariantLabel, getPosPrice, getPosProductImage, getVariantStock } from "@classytic/commerce-sdk/sales";
+import { calculateVariantPrice, formatVariantLabel, getPosPrice, getPosProductImage, isInStock } from "@classytic/commerce-sdk/sales";
 import { toast } from "sonner";
 
 //#region src/hooks/usePosCart.ts
-const CART_TTL = 1440 * 60 * 1e3;
+const CART_TTL = 864e5;
 function usePosCart(branchId) {
-	const suffix = branchId ?? "default";
-	const [cart, setCart, clearStoredCart] = useLocalStorage(`pos:cart:${suffix}`, [], CART_TTL);
+	/**
+	* The cart namespace is per-BRANCH, and an unresolved branch is NOT a branch —
+	* see `branch-scoped-key.ts` for the full account of what `?? "default"` cost
+	* here (a cart that vanished the moment the branch context resolved, behind an
+	* "Added to cart" toast). `ready === false` means every mutator below refuses,
+	* so nothing is ever written to a namespace that is about to be abandoned.
+	*/
+	const { key: cartKey, ready } = branchScopedKey("pos:cart", branchId);
+	const suffix = ready ? branchId : UNRESOLVED_BRANCH;
+	const [cart, setCart, clearStoredCart] = useLocalStorage(cartKey, [], CART_TTL);
+	/**
+	* The one guard every mutator calls FIRST.
+	*
+	* Loud on purpose: the alternative is what shipped — a success toast over a
+	* write that is about to be orphaned. The cashier is told to wait a moment
+	* instead of being told the item was added.
+	*/
+	const refuseIfBranchUnresolved = useCallback(() => {
+		if (ready) return false;
+		toast.error("Branch not ready", { description: "The register is still resolving its branch. Try again in a moment." });
+		return true;
+	}, [ready]);
 	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)
+	const [, setSaleAttempt, clearSaleAttempt] = useLocalStorage(`pos:attempt:${suffix}`, "", CART_TTL);
+	/**
+	* The ONE seam every cart mutation goes through.
+	*
+	* Not a style preference — it is what keeps the guard and the writer from
+	* drifting apart. `setCart` is `useCallback([key, notifyChange])` inside
+	* fluid's `useLocalStorage`, so its identity CHANGES whenever the branch key
+	* changes, and `refuseIfBranchUnresolved` changes when `ready` does. Callbacks
+	* that captured either one without depending on it went stale in two ways
+	* that both fail silently:
+	*
+	*   - `updateQuantity` and `removeItem` declared `[]`, so on a mount where the
+	*     branch had not resolved yet they froze `ready === false` FOREVER: the
+	*     quantity steppers and the remove button refused every tap for the life
+	*     of that mount, with a "branch not ready" toast that was true once and a
+	*     lie thereafter.
+	*   - After a branch switch (A → B) they still held branch A's `setCart` and
+	*     wrote A's cart while the screen displayed B's.
+	*
+	* With one guarded writer there is exactly one dependency list to get right,
+	* and every mutator below depends on `mutateCart` alone.
+	*/
+	const mutateCart = useCallback((updater) => {
+		if (refuseIfBranchUnresolved()) return false;
+		setCart(updater);
+		return true;
+	}, [refuseIfBranchUnresolved, setCart]);
+	const addToCart = useCallback((product, variantSku) => {
+		if (refuseIfBranchUnresolved()) return;
+		const variant = variantSku ? product.variants?.find((v) => v.sku === variantSku) : null;
+		/**
+		* ONE stock predicate — `isInStock`, not a third copy of the rule.
+		*
+		* This re-derived it inline (`getVariantStock(...) <= 0`, else `!branchStock.inStock`)
+		* and so never consulted `inventory.stockTracked`. That made it the THIRD place the
+		* same decision lived — the product card, the variant dialog, and here — and the only
+		* one still refusing a membership, which holds no stock and cannot be out of it. Fixing
+		* the card and the dialog did nothing for the actual tap, because the tap asked this.
+		*
+		* `isInStock` already handles the untracked case and the variant case; a tracked good
+		* with no quantity is still correctly refused.
+		*/
+		if (!isInStock(product, variantSku)) {
+			toast.error("Out of stock");
+			return;
+		}
+		const basePrice = getPosPrice(product);
+		/**
+		* An ABSOLUTE variant price wins over base-plus-modifier — and this one moves MONEY.
+		*
+		* `priceModifier` models a variant as an uplift ("Large: +৳50"), but a subscription
+		* PLAN carries its own price and `getPosPrice` resolves the product to `plans[0]`. With
+		* the modifier form a Yearly membership entered the cart at the MONTHLY price: ৳3,000
+		* charged for a ৳30,000 plan, with the receipt and the entitlement both agreeing on the
+		* wrong number. The variant dialog displayed it correctly by then, so the quote and the
+		* charge disagreed — the worst version of this bug.
+		*/
+		const absolutePrice = variant?.price;
+		const unitPrice = typeof absolutePrice === "number" && absolutePrice > 0 ? minorToMajor(absolutePrice) : variant ? calculateVariantPrice(basePrice, variant.priceModifier ?? 0) : basePrice;
+		if (mutateCart((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 [...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;
+				return next;
 			}
-			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 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");
+	}, [refuseIfBranchUnresolved, mutateCart]);
+	const addCharge = useCallback((label, amountMajor) => {
+		if (refuseIfBranchUnresolved()) return;
+		const trimmedLabel = label.trim();
+		if (!trimmedLabel) {
+			toast.error("Label is required");
+			return;
+		}
+		if (!Number.isFinite(amountMajor) || amountMajor < 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";
+		if (mutateCart((prev) => {
+			const existingIndex = prev.findIndex((item) => item.kind === "service-fee" && item.serviceCode === code);
+			if (existingIndex >= 0) {
 				const next = [...prev];
-				const item = next[index];
-				if (!item) return prev;
-				const quantity = Math.max(1, item.quantity + delta);
-				next[index] = {
-					...item,
+				const existing = next[existingIndex];
+				const quantity = existing.quantity + 1;
+				next[existingIndex] = {
+					...existing,
 					quantity,
-					lineTotal: quantity * item.unitPrice
+					lineTotal: quantity * existing.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();
+			const newItem = {
+				kind: "service-fee",
+				serviceCode: code,
+				productId: `service:${code}`,
+				productName: trimmedLabel,
+				quantity: 1,
+				unitPrice: amountMajor,
+				lineTotal: amountMajor
+			};
+			return [...prev, newItem];
+		})) toast.success(`Added ${trimmedLabel}`);
+	}, [refuseIfBranchUnresolved, mutateCart]);
+	const updateQuantity = useCallback((index, delta) => {
+		mutateCart((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;
+		});
+	}, [mutateCart]);
+	const removeItem = useCallback((index) => {
+		mutateCart((prev) => prev.filter((_, i) => i !== index));
+	}, [mutateCart]);
+	const clearCart = useCallback(() => {
+		if (refuseIfBranchUnresolved()) return;
+		if (window.confirm("Clear all items from cart?")) {
+			mutateCart(() => []);
 			clearPointsToRedeem();
-		}, [
-			clearStoredCart,
-			clearDiscountInput,
-			clearMembershipCardId,
-			clearPointsToRedeem
-		]),
+		}
+	}, [
+		refuseIfBranchUnresolved,
+		mutateCart,
+		clearPointsToRedeem
+	]);
+	/**
+	* End of sale. Clears the attempt key LAST and only here — `resetCart` runs
+	* after a confirmed success, so up to that point every retry keeps sending the
+	* same key and the server keeps replaying the same order. Dropping the key on
+	* failure instead is precisely the double-charge path.
+	*/
+	const resetCart = useCallback(() => {
+		clearStoredCart();
+		clearDiscountInput();
+		clearMembershipCardId();
+		clearPointsToRedeem();
+		clearSaleAttempt();
+	}, [
+		clearStoredCart,
+		clearDiscountInput,
+		clearMembershipCardId,
+		clearPointsToRedeem,
+		clearSaleAttempt
+	]);
+	const beginSaleAttempt = useCallback(() => {
+		if (!ready) return null;
+		/**
+		* Read-and-mint in ONE storage pass. `setValue`'s updater is invoked
+		* synchronously against the value freshly read from localStorage (see
+		* fluid's `useLocalStorage`), which matters because `beginSaleAttempt` is
+		* called during a submit handler where this hook's rendered state may be a
+		* tick behind. Reading the rendered value instead would mint a second key
+		* for a retry that fired before React re-rendered — the exact case this
+		* function exists for.
+		*/
+		let key = "";
+		setSaleAttempt((prev) => {
+			key = resolveSaleAttemptKey(prev);
+			return key;
+		});
+		return key;
+	}, [ready, setSaleAttempt]);
+	return {
+		cart,
+		membershipCardId,
+		pointsToRedeemInput,
+		discountInput,
+		setDiscountInput,
+		setMembershipCardId,
+		setPointsToRedeemInput,
+		addToCart,
+		addCharge,
+		updateQuantity,
+		removeItem,
+		clearCart,
+		resetCart,
 		replaceCart: useCallback((items) => {
-			setCart(items);
-		}, [setCart])
+			mutateCart(() => items);
+		}, [mutateCart]),
+		beginSaleAttempt,
+		ready
 	};
 }
 

package/dist/hooks/usePosCustomer.d.ts

@@ -0,0 +1,31 @@
+import { Customer } from "@classytic/commerce-sdk/sales";
+//#region src/hooks/usePosCustomer.d.ts
+interface UsePosCustomerReturn {
+  selectedCustomer: Customer | null;
+  customerName: string;
+  customerPhone: string;
+  membershipCardId: string;
+  membershipLookupStatus: "idle" | "searching" | "found" | "not_found";
+  createDialogOpen: boolean;
+  lookupDialogOpen: boolean;
+  setCustomerName: (value: string) => void;
+  setCustomerPhone: (value: string) => void;
+  setMembershipCardId: (value: string) => void;
+  setCreateDialogOpen: (open: boolean) => void;
+  setLookupDialogOpen: (open: boolean) => void;
+  selectCustomer: (customer: Customer) => void;
+  clearCustomer: () => void;
+  handleCustomerCreated: (customer: Customer) => void;
+  triggerMembershipLookup: () => Promise<void>;
+  resetCustomer: () => void;
+}
+/**
+ * `token` is accepted and unused: the SDK injects auth from `configureAuth()`,
+ * and the only consumer of an explicit token here was the customer SEARCH,
+ * which has moved into `CustomerLookupDialog`. Kept in the signature because
+ * both screens pass it and dropping it is a breaking change for no gain —
+ * marked so the next reader does not go looking for where it is threaded.
+ */
+declare function usePosCustomer(_token?: string): UsePosCustomerReturn;
+//#endregion
+export { UsePosCustomerReturn, usePosCustomer };

package/dist/hooks/usePosCustomer.js

@@ -1,67 +1,46 @@
 "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 { useCallback, useState } from "react";
 import { useLocalStorage } from "@classytic/fluid/client/hooks";
-import { useCustomers, useLookupMemberByCard } from "@classytic/commerce-sdk/sales";
+import { useLookupMemberByCard } from "@classytic/commerce-sdk/sales";
 import { toast } from "sonner";
-import { buildFilterParams, getApiParams } from "@classytic/fluid";
+import { presentError } from "@classytic/fluid/error-contract";
 
 //#region src/hooks/usePosCustomer.ts
-const CUSTOMER_TTL = 1440 * 60 * 1e3;
-function usePosCustomer(token) {
-	const authToken = usePosAuth().getToken();
-	const resolvedToken = token || authToken || "";
+const CUSTOMER_TTL = 864e5;
+/**
+* `token` is accepted and unused: the SDK injects auth from `configureAuth()`,
+* and the only consumer of an explicit token here was the customer SEARCH,
+* which has moved into `CustomerLookupDialog`. Kept in the signature because
+* both screens pass it and dropping it is a breaking change for no gain —
+* marked so the next reader does not go looking for where it is threaded.
+*/
+function usePosCustomer(_token) {
 	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]);
+	/**
+	* Searching used to live here: ~50 lines that guessed the field from the text
+	* (`isValidPhone` → exact phone, `/^\d{4,}$/` → phone contains, else name) and
+	* hand-built the query with `buildFilterParams`.
+	*
+	* It now lives in `CustomerLookupDialog`, composed from fluid's picker parts
+	* over `useLocalSearch`, for two reasons. The guess had a silent failure mode
+	* — a wrong inference returns an empty list, which reads as "not a customer"
+	* and gets a duplicate created. And the accounting picker searched customers
+	* through a different grammar, so one product held two answers to "how do I
+	* find a customer" and only one of them could be right.
+	*
+	* What is left here is what this hook is actually for: WHICH customer is
+	* attached to the sale, and keeping that across the products→payment screen
+	* swap.
+	*/
 	const setCustomerName = useCallback((value) => {
 		setCustomerNameState(value);
 		if (selectedCustomer) setSelectedCustomer(null);
@@ -80,8 +59,6 @@ function usePosCustomer(token) {
 		setCustomerPhoneState(customerDisplayPhone(customer) ?? "");
 		setMembershipCardIdState(customer.membership?.cardId || "");
 		setMembershipLookupStatus(customer.membership?.cardId ? "found" : "idle");
-		setCustomerSearch("");
-		setSearchApplied("");
 		setLookupDialogOpen(false);
 	}, []);
 	const clearCustomer = useCallback(() => {
@@ -90,8 +67,6 @@ function usePosCustomer(token) {
 		setCustomerPhoneState("");
 		setMembershipCardIdState("");
 		setMembershipLookupStatus("idle");
-		setCustomerSearch("");
-		setSearchApplied("");
 	}, []);
 	const handleCustomerCreated = useCallback((customer) => {
 		setSelectedCustomer(customer);
@@ -99,23 +74,8 @@ function usePosCustomer(token) {
 		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
@@ -144,9 +104,10 @@ function usePosCustomer(token) {
 		} 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);
+			const raw = err instanceof Error ? err.message : "Card not found";
+			if (raw.includes("404") || /not found/i.test(raw)) return;
+			const { title, message } = presentError(err, "The card could not be checked. Try again.", { fallbackTitle: "Card lookup failed" });
+			toast.error(title, { description: message });
 		}
 	}, [
 		membershipCardId,
@@ -159,8 +120,6 @@ function usePosCustomer(token) {
 		setCustomerPhoneState("");
 		setMembershipCardIdState("");
 		setMembershipLookupStatus("idle");
-		setCustomerSearch("");
-		setSearchApplied("");
 	}, []);
 	return {
 		selectedCustomer,
@@ -168,21 +127,16 @@ function usePosCustomer(token) {
 		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
 	};

package/dist/hooks/usePosDelivery.d.ts

@@ -0,0 +1,28 @@
+//#region src/hooks/usePosDelivery.d.ts
+type PosDeliveryMethod = "pickup" | "delivery";
+type PosPaymentTerm = "prepaid" | "collect_on_delivery";
+interface PosDeliveryAddress {
+  recipientName: string;
+  recipientPhone: string;
+  addressLine1: string;
+  city: string;
+  area: string;
+  note: string;
+}
+interface UsePosDeliveryReturn {
+  method: PosDeliveryMethod;
+  address: PosDeliveryAddress;
+  /** Delivery fee in MAJOR units, as typed. Empty string means none. */
+  feeInput: string;
+  paymentTerm: PosPaymentTerm;
+  setMethod: (method: PosDeliveryMethod) => void;
+  setAddressField: (field: keyof PosDeliveryAddress, value: string) => void;
+  setFeeInput: (value: string) => void;
+  setPaymentTerm: (term: PosPaymentTerm) => void;
+  reset: () => void;
+  /** Parsed fee in major units, `0` when blank or unparseable. */
+  fee: number;
+}
+declare function usePosDelivery(branchId?: string): UsePosDeliveryReturn;
+//#endregion
+export { PosDeliveryAddress, PosDeliveryMethod, PosPaymentTerm, UsePosDeliveryReturn, usePosDelivery };