@classytic/pos-ui 0.1.0

package/dist/hooks/usePosPayment.js

@@ -0,0 +1,194 @@
+"use client";
+
+import { usePosAuth } from "../runtime/auth-port.js";
+import { calculateAmountDue, calculateChange, parseCashReceived, parsePositiveNumber } from "../utils/pos-helpers.js";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { usePaymentMethods } from "@classytic/commerce-sdk/platform";
+
+//#region src/hooks/usePosPayment.ts
+function getPaymentKey(method, index) {
+	return method._id || `${method.type}:${method.provider || ""}:${method.name}:${index}`;
+}
+function mapPlatformMethodToPosMethod(method) {
+	switch (method.type) {
+		case "cash": return "cash";
+		case "mfs": {
+			const provider = (method.provider || "").toLowerCase();
+			if (provider === "bkash" || provider === "nagad" || provider === "rocket" || provider === "upay") return provider;
+			return null;
+		}
+		case "bank_transfer": return "bank_transfer";
+		case "card": return "card";
+		default: return null;
+	}
+}
+function paymentNeedsReference(posMethod) {
+	return posMethod !== "cash";
+}
+function createSplitEntry(option) {
+	const suffix = Math.random().toString(16).slice(2);
+	return {
+		id: `split_${Date.now()}_${suffix}`,
+		paymentKey: option.key,
+		posMethod: option.posMethod,
+		amount: "",
+		reference: "",
+		error: void 0
+	};
+}
+function usePosPayment(token, total = 0) {
+	usePosAuth().getToken();
+	const [selectedKey, setSelectedKey] = useState(null);
+	const [cashReceived, setCashReceived] = useState("");
+	const [reference, setReference] = useState("");
+	const [mode, setMode] = useState("single");
+	const [splitEntries, setSplitEntries] = useState([]);
+	const { paymentMethods: platformMethods, isLoading } = usePaymentMethods();
+	const options = useMemo(() => {
+		return (platformMethods || []).filter((m) => m?.isActive !== false).map((m, idx) => {
+			const posMethod = mapPlatformMethodToPosMethod(m);
+			if (!posMethod) return null;
+			return {
+				key: getPaymentKey(m, idx),
+				posMethod,
+				label: m.name,
+				needsReference: paymentNeedsReference(posMethod),
+				note: m.note,
+				walletNumber: m.type === "mfs" ? m.walletNumber : void 0
+			};
+		}).filter(Boolean);
+	}, [platformMethods]);
+	useEffect(() => {
+		if (selectedKey || options.length === 0) return;
+		const cash = options.find((o) => o.posMethod === "cash");
+		setSelectedKey((cash || options[0])?.key ?? null);
+	}, [options, selectedKey]);
+	const selectedOption = useMemo(() => {
+		if (options.length === 0) return null;
+		return options.find((o) => o.key === selectedKey) || options[0];
+	}, [options, selectedKey]);
+	const selectedMethod = selectedOption?.posMethod || "cash";
+	useEffect(() => {
+		if (mode !== "single") return;
+		setReference("");
+		setCashReceived("");
+	}, [selectedMethod, mode]);
+	useEffect(() => {
+		if (mode !== "split" || splitEntries.length > 0) return;
+		const opt = selectedOption || options[0];
+		if (opt) setSplitEntries([createSplitEntry(opt)]);
+	}, [
+		mode,
+		splitEntries.length,
+		selectedOption,
+		options
+	]);
+	const cashReceivedNumber = useMemo(() => parseCashReceived(cashReceived), [cashReceived]);
+	const changeAmount = useMemo(() => {
+		if (selectedMethod !== "cash") return 0;
+		return calculateChange(cashReceivedNumber, total);
+	}, [
+		cashReceivedNumber,
+		total,
+		selectedMethod
+	]);
+	const amountDue = useMemo(() => {
+		if (selectedMethod !== "cash") return 0;
+		return calculateAmountDue(cashReceivedNumber, total);
+	}, [
+		cashReceivedNumber,
+		total,
+		selectedMethod
+	]);
+	const splitTotal = useMemo(() => splitEntries.reduce((sum, e) => sum + parsePositiveNumber(e.amount), 0), [splitEntries]);
+	const splitRemaining = total - splitTotal;
+	const splitIsBalanced = Math.abs(splitRemaining) < .01 && splitTotal > 0;
+	const validateSplitEntry = useCallback((id) => {
+		const entry = splitEntries.find((e) => e.id === id);
+		if (!entry) return void 0;
+		const opt = options.find((o) => o.key === entry.paymentKey);
+		if (!opt) return "Invalid payment method";
+		if (parsePositiveNumber(entry.amount) <= 0) return "Amount required";
+		if (opt.needsReference && !entry.reference.trim()) return `Reference required for ${opt.label}`;
+	}, [splitEntries, options]);
+	const validateAllSplits = useCallback(() => {
+		let hasError = false;
+		setSplitEntries((prev) => prev.map((entry) => {
+			const opt = options.find((o) => o.key === entry.paymentKey);
+			let error;
+			if (!opt) error = "Invalid method";
+			else if (parsePositiveNumber(entry.amount) <= 0) error = "Amount required";
+			else if (opt.needsReference && !entry.reference.trim()) error = "Reference required";
+			if (error) hasError = true;
+			return {
+				...entry,
+				error
+			};
+		}));
+		return !hasError;
+	}, [options]);
+	const selectPayment = useCallback((key) => setSelectedKey(key), []);
+	const addSplit = useCallback((paymentKey) => {
+		const opt = paymentKey ? options.find((o) => o.key === paymentKey) : selectedOption || options[0];
+		if (!opt) return;
+		setSplitEntries((prev) => [...prev, createSplitEntry(opt)]);
+	}, [options, selectedOption]);
+	const updateSplit = useCallback((id, patch) => {
+		setSplitEntries((prev) => prev.map((entry) => {
+			if (entry.id !== id) return entry;
+			const updated = {
+				...entry,
+				...patch,
+				error: void 0
+			};
+			if (patch.paymentKey) {
+				const opt = options.find((o) => o.key === patch.paymentKey);
+				if (opt) {
+					updated.posMethod = opt.posMethod;
+					if (patch.paymentKey !== entry.paymentKey) updated.reference = "";
+				}
+			}
+			return updated;
+		}));
+	}, [options]);
+	const removeSplit = useCallback((id) => {
+		setSplitEntries((prev) => prev.filter((e) => e.id !== id));
+	}, []);
+	const reset = useCallback(() => {
+		setReference("");
+		setCashReceived("");
+		setMode("single");
+		setSplitEntries([]);
+	}, []);
+	return {
+		options,
+		isLoading,
+		state: {
+			mode,
+			selectedKey,
+			selectedMethod,
+			reference,
+			cashReceived,
+			changeAmount,
+			amountDue,
+			splitEntries,
+			splitTotal,
+			splitRemaining,
+			splitIsBalanced
+		},
+		selectedOption,
+		selectPayment,
+		setMode,
+		setCashReceived,
+		setReference,
+		addSplit,
+		updateSplit,
+		removeSplit,
+		validateSplitEntry,
+		validateAllSplits,
+		reset
+	};
+}
+
+//#endregion
+export { paymentNeedsReference, usePosPayment };

package/dist/lib/cn.js

@@ -0,0 +1,12 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+//#region src/lib/cn.ts
+/** Tailwind-aware className merge — same `cn` contract as `@classytic/fluid` and
+*  host shadcn, so components compose predictably. */
+function cn(...inputs) {
+	return twMerge(clsx(inputs));
+}
+
+//#endregion
+export { cn };

package/dist/lib/loyalty.js

@@ -0,0 +1,30 @@
+//#region src/lib/loyalty.ts
+/**
+* Loyalty display helpers — pure functions for tier colors and readable
+* contrast text. Copied verbatim from the host (no `@/` deps) so the POS
+* package stays self-contained.
+*/
+const DEFAULT_TIER_COLORS = {
+	bronze: "#CD7F32",
+	silver: "#C0C0C0",
+	gold: "#FFD700",
+	platinum: "#E5E4E2"
+};
+function getTierColor(tierName) {
+	if (!tierName) return null;
+	const normalized = tierName.toLowerCase();
+	return DEFAULT_TIER_COLORS[normalized] || null;
+}
+function getReadableTextColor(background) {
+	if (!background) return "#111827";
+	if (!background.startsWith("#")) return "#111827";
+	const hex = background.replace("#", "");
+	if (hex.length !== 6) return "#111827";
+	const r = parseInt(hex.slice(0, 2), 16);
+	const g = parseInt(hex.slice(2, 4), 16);
+	const b = parseInt(hex.slice(4, 6), 16);
+	return (.299 * r + .587 * g + .114 * b) / 255 > .6 ? "#111827" : "#FFFFFF";
+}
+
+//#endregion
+export { getReadableTextColor, getTierColor };

package/dist/lib/money.js

@@ -0,0 +1,41 @@
+import { MinorUnits, money, toMajor } from "@classytic/primitives/money";
+
+//#region src/lib/money.ts
+/**
+* Money for POS — composed on `@classytic/primitives` (the canonical Money type
+* + arithmetic authority), with thin BDT display formatters on top. The package
+* is BD-tenant (BDT / `৳` / `en-BD`); a non-BD deployment forks these three
+* constants. Arithmetic and the `Money` type always come from primitives — this
+* module never re-implements them.
+*/
+const TENANT_CURRENCY = "BDT";
+/** Cast a raw number to `Paisa`. Use at SDK boundaries when the response
+*  type isn't yet branded, or for arithmetic results that guarantee minor
+*  units. One cast per source — not per callsite. */
+function Paisa(n) {
+	return MinorUnits(n, TENANT_CURRENCY);
+}
+const TENANT_LOCALE = "en-BD";
+const TENANT_SYMBOL = "৳";
+/** Adapt a paisa (minor-unit) wire value into a structured `Money`. */
+function paisaToMoney(paisa, currency = TENANT_CURRENCY) {
+	return money(paisa, currency);
+}
+/** Canonical formatter — structured `Money` → `৳1,234.00`. */
+function formatMoney(m) {
+	return new Intl.NumberFormat(TENANT_LOCALE, {
+		style: "currency",
+		currency: m.currency
+	}).format(toMajor(m));
+}
+/** Format a wire-format paisa value: `formatPaisa(489900)` → `৳4,899.00`. */
+function formatPaisa(paisa, currency = TENANT_CURRENCY) {
+	return formatMoney(paisaToMoney(paisa, currency));
+}
+/** Compact major-unit formatter, no forced decimals: `formatBdt(4899)` → `৳4,899`. */
+function formatBdt(bdt) {
+	return `${TENANT_SYMBOL}${(Number.isFinite(bdt) ? bdt : 0).toLocaleString(TENANT_LOCALE)}`;
+}
+
+//#endregion
+export { Paisa, formatBdt, formatMoney, formatPaisa, paisaToMoney };