@liiift-studio/sales-portal 1.2.1

package/utils/salesDataProcessing.js

@@ -0,0 +1,596 @@
+/**
+ * Process raw sales data into chart-ready format
+ * @param {Array} sales - Raw sales data
+ * @param {Date} date - Current date being displayed
+ * @returns {Object} Processed chart data
+ */
+export function processChartData(sales, date) {
+	const daysInMonth = new Date(date.getUTCFullYear(), date.getUTCMonth() + 1, 0).getDate();
+
+	// Initialize data arrays with actual days in month
+	let tmpXAxis = Array.from({ length: daysInMonth }, (_, i) => i + 1);
+	let tmpSalesData = Array(daysInMonth).fill(0);
+	let tmpDiscountLossData = Array(daysInMonth).fill(0);
+	let tmpTotalSalesData = Array(daysInMonth).fill(0);
+	let tmpOrderData = Array(daysInMonth).fill(0);
+	let tmpRegularOrderData = Array(daysInMonth).fill(0);
+	let tmpRefundData = Array(daysInMonth).fill(0);
+	let tmpRefundTotal = 0;
+	let tmpDiscountData = Array(daysInMonth).fill(0);
+	let tmpFirstOrderData = Array(daysInMonth).fill(0);
+	let tmpDiscountFirstOrderData = Array(daysInMonth).fill(0);
+	let tmpTaxData = Array(daysInMonth).fill(0);
+	let tmpShippingData = Array(daysInMonth).fill(0);
+	let tmpShippedOrdersData = Array(daysInMonth).fill(0);
+	let grandTotal = 0;
+	let grandTax = 0;
+	let grandShipping = 0;
+
+
+	// Process data day by day
+	for (let day = 1; day <= daysInMonth; day++) {
+		// Skip future dates
+		if (
+			new Date(date).getUTCFullYear() > new Date().getUTCFullYear() ||
+			(new Date(date).getUTCFullYear() >= new Date().getUTCFullYear() &&
+				new Date(date).getUTCMonth() > new Date().getUTCMonth()) ||
+			(day > new Date().getDate() &&
+				new Date(date).getUTCMonth() >= new Date().getUTCMonth() &&
+				new Date(date).getUTCFullYear() >= new Date().getUTCFullYear())
+		) {
+			continue;
+		}
+
+		// Get day's sales
+		let todaySales = sales?.filter(
+			(item) => new Date(item.created * 1000).getUTCDate() === day
+		);
+
+		let total = 0;
+		let discountLost = 0;
+		let orders = 0;
+		let regularOrders = 0;
+		let refunds = 0;
+		let refundAmount = 0;
+		let discounts = 0;
+		let firstOrders = 0;
+		let firstOrderDiscounts = 0;
+		let tax = 0;
+		let shipping = 0;
+		let shippedOrders = 0;
+
+		// Create a map to track unique sales by ID to prevent duplicates
+		const processedSales = new Map();
+		
+		// Process each sale
+		todaySales?.forEach((item) => {
+			// Create a unique identifier for this sale
+			const saleKey = `${item.saleType || ''}-${item.id}-${item.lineId || ''}`;
+			
+			// Skip if we've already processed this exact sale
+			if (processedSales.has(saleKey)) {
+				return;
+			}
+			
+			// Mark as processed
+			processedSales.set(saleKey, true);
+			
+			if (item?.shippingProvision) {
+				shipping += item.total;
+				shippedOrders++;
+			} else {
+				total += item.total;
+				orders++;
+				regularOrders++;
+			}
+
+			// Process tax
+			if (item?.taxAmounts?.length) {
+				item.taxAmounts.forEach((taxItem) => {
+					tax += taxItem.amount;
+				});
+			}
+
+			// Process discounts
+			if (!item?.shippingProvision) {
+				if (item?.discountAmounts.length) {
+					item.discountAmounts.forEach((discount) => {
+						discountLost += discount.amount;
+						if (item?.customer?.next_invoice_sequence <= 2) firstOrderDiscounts++;
+						else discounts++;
+						regularOrders--;
+					});
+				} else if (item?.customer?.next_invoice_sequence <= 2) {
+					firstOrders++;
+					regularOrders--;
+				}
+			}
+
+			// Process refunds and disputes
+			if (item?.disputed) {
+				refunds++;
+				const disputeAmount = item.totalWithTax - item.total;
+				refundAmount += disputeAmount;
+				total -= disputeAmount;
+			}
+			item?.refunds?.forEach((refund) => {
+				total -= refund.adjustedTotal;
+				refundAmount += refund.adjustedTotal;
+				refunds++;
+			});
+		});
+
+		// Update running totals
+		shipping = shipping / 100;
+		grandShipping += shipping;
+		tax = tax / 100;
+		grandTax += tax;
+		discountLost = discountLost / 100;
+		total = total / 100;
+		grandTotal += total;
+
+		// Update arrays at index day-1
+		const idx = day - 1;
+		tmpOrderData[idx] = orders;
+		tmpRegularOrderData[idx] = regularOrders;
+		tmpFirstOrderData[idx] = firstOrders;
+		tmpDiscountData[idx] = discounts;
+		tmpDiscountFirstOrderData[idx] = firstOrderDiscounts;
+		tmpRefundData[idx] = refunds;
+		tmpShippingData[idx] = grandShipping;
+		tmpShippedOrdersData[idx] = shippedOrders;
+		tmpTaxData[idx] = grandTax;
+		tmpDiscountLossData[idx] = discountLost;
+		tmpSalesData[idx] = total;
+		tmpTotalSalesData[idx] = grandTotal + grandShipping + grandTax;
+		tmpRefundTotal += refundAmount;
+	}
+
+	// Calculate changeMax for bar chart scaling
+	const changeMax = Math.max(
+		Math.max(...tmpOrderData) || 0,
+		Math.max(...tmpRegularOrderData) || 0,
+		Math.max(...tmpFirstOrderData) || 0,
+		Math.max(...tmpDiscountData) || 0,
+		Math.max(...tmpDiscountFirstOrderData) || 0,
+		Math.max(...tmpShippedOrdersData) || 0,
+		Math.max(...tmpRefundData) || 0
+	);
+
+	return {
+		xAxis: tmpXAxis,
+		discountLostData: tmpDiscountLossData,
+		salesData: tmpSalesData,
+		totalSalesData: tmpTotalSalesData,
+		salesMax: Math.max(...tmpTotalSalesData) || 0,
+		orderData: tmpOrderData,
+		orderMax: Math.max(...tmpOrderData) || 0,
+		regularOrderData: tmpRegularOrderData,
+		regularOrderMax: Math.max(...tmpRegularOrderData) || 0,
+		discountData: tmpDiscountData,
+		discountMax: Math.max(...tmpDiscountData) || 0,
+		discountFirstOrderData: tmpDiscountFirstOrderData,
+		firstOrderDiscountMax: Math.max(...tmpDiscountFirstOrderData) || 0,
+		firstOrderData: tmpFirstOrderData,
+		firstOrderMax: Math.max(...tmpFirstOrderData) || 0,
+		refundData: tmpRefundData,
+		refundMax: Math.max(...tmpRefundData) || 0,
+		refundTotal: tmpRefundTotal / 100,
+		taxData: tmpTaxData,
+		shippingData: tmpShippingData,
+		shippedOrdersData: tmpShippedOrdersData,
+		shippedOrdersMax: Math.max(...tmpShippedOrdersData) || 0,
+		changeMax: changeMax,
+	};
+}
+
+/**
+ * Process sales data into typeface-specific data with detailed financial breakdowns
+ * @param {Array} sales - Raw sales data
+ * @param {Array} designers - Designer information
+ * @returns {Array} Processed typeface data with various financial totals
+ */
+export function processTypefaceData(sales, designers) {
+	let typefaceData = [];
+	
+	// Create a map to track unique sales by ID to prevent duplicates
+	const processedSales = new Map();
+
+	sales?.forEach((sale) => {
+		// Create a unique identifier for this sale
+		const saleKey = `${sale.saleType || ''}-${sale.id}-${sale.lineId || ''}`;
+		
+		// Skip if we've already processed this exact sale
+		if (processedSales.has(saleKey)) {
+			return;
+		}
+		
+		// Mark as processed
+		processedSales.set(saleKey, true);
+		
+		// Extract typeface title
+		var title = '';
+		if (sale.description) {
+			title = sale.description.substring(0, sale.description.indexOf(' ('));
+			if (title === '') title = sale.description.substring(0, sale.description.indexOf(' —'));
+			if (title === '') title = sale.description.substring(0, sale.description.indexOf('.'));
+			if (title === '') title = sale.description;
+		} else {
+			title = 'Unknown Typeface';
+		}
+
+		// Calculate tax amounts for this sale
+		let saleTax = 0;
+		if (sale?.taxAmounts?.length) {
+			sale.taxAmounts.forEach((taxItem) => {
+				saleTax += taxItem.amount;
+			});
+		}
+
+		// Calculate discount amounts for this sale
+		let saleDiscounts = 0;
+		if (sale?.discountAmounts?.length) {
+			sale.discountAmounts.forEach((discount) => {
+				saleDiscounts += discount.amount;
+			});
+		}
+
+		// Calculate refund amounts for this sale
+		let saleRefunds = 0;
+		if (sale?.disputed) {
+			const disputeAmount = sale.totalWithTax - sale.total;
+			saleRefunds += disputeAmount;
+		}
+		if (sale?.refunds?.length) {
+			sale.refunds.forEach((refund) => {
+				saleRefunds += refund.adjustedTotal;
+			});
+		}
+
+		// Find or create typeface entry
+		let existingTypeface = typefaceData.find(item => item.title === title);
+		if (existingTypeface) {
+			// Update existing typeface data
+			existingTypeface.grossTotal += sale.total;
+			existingTypeface.taxTotal += saleTax;
+			existingTypeface.discountTotal += saleDiscounts;
+			existingTypeface.refundTotal += saleRefunds;
+			existingTypeface.total += sale.total;
+			existingTypeface.orders += 1;
+		} else {
+			// Create new typeface entry with detailed financials
+			typefaceData.push({
+				title: title,
+				total: sale.total,
+				grossTotal: sale.total, // Total before any adjustments
+				taxTotal: saleTax,
+				discountTotal: saleDiscounts,
+				refundTotal: saleRefunds,
+				orders: 1,
+				author: designers && designers.find(designer => designer._id === sale.author || designer._id === sale?.author?._id) ?
+					designers.find(designer => (designer._id === sale.author || designer._id === sale?.author?._id))
+					:
+					{
+						firstName: undefined,
+						lastName: undefined,
+						_id: sale.author?._id || sale?.author,
+					}
+			});
+		}
+
+		// Apply discounts and refunds to the adjusted total
+		existingTypeface = typefaceData.find(item => item.title === title);
+		sale?.discountAmounts?.forEach(discountAmount => {
+			existingTypeface.total -= discountAmount.amount;
+		});
+
+		sale?.refunds?.forEach(refund => {
+			existingTypeface.total -= refund.adjustedTotal;
+		});
+	});
+
+	// Calculate derived totals
+	typefaceData.forEach(typeface => {
+		// Total with discounts applied, but before tax and refunds
+		typeface.totalWithDiscounts = typeface.grossTotal - typeface.discountTotal;
+		
+		// Total before tax, but after discounts and refunds
+		typeface.pretaxTotal = typeface.totalWithDiscounts - typeface.refundTotal;
+		
+		// Net total after all adjustments (same as typeface.total)
+		typeface.netTotal = typeface.total;
+		
+		// Convert cents to dollars for all monetary values
+		typeface.grossTotal = typeface.grossTotal;
+		typeface.taxTotal = typeface.taxTotal;
+		typeface.discountTotal = typeface.discountTotal;
+		typeface.refundTotal = typeface.refundTotal;
+		typeface.totalWithDiscounts = typeface.totalWithDiscounts;
+		typeface.pretaxTotal = typeface.pretaxTotal;
+		typeface.total = typeface.total;
+		typeface.netTotal = typeface.netTotal;
+	});
+
+	// Sort by title
+	return typefaceData.sort((a, b) => a.title.localeCompare(b.title));
+}
+
+/**
+ * Process typeface data into designer-specific data
+ * @param {Array} typefaceData - Processed typeface data
+ * @returns {Array} Processed designer data
+ */
+/**
+ * Process sales data into license-type-specific data with financial breakdowns
+ * @param {Array} sales - Raw sales data
+ * @returns {Array} Processed license type data with financial totals
+ */
+export function processLicenseTypeData(sales) {
+	let licenseTypeData = [];
+
+	// Create a map to track unique sales by ID to prevent duplicates
+	const processedSales = new Map();
+	
+	sales?.forEach((sale) => {
+		// Create a unique identifier for this sale
+		const saleKey = `${sale.saleType || ''}-${sale.id}-${sale.lineId || ''}`;
+		
+		// Skip if we've already processed this exact sale
+		if (processedSales.has(saleKey)) {
+			return;
+		}
+		
+		// Mark as processed
+		processedSales.set(saleKey, true);
+		
+		// Extract license type from description
+		let licenseName = 'Unknown';
+		
+		// Try to extract license type from description using various patterns
+		// Pattern 1: "Typeface Name (License Type)"
+		const parenthesisMatch = sale.description && sale.description.match(/\((.*?)\)/);
+		if (parenthesisMatch && parenthesisMatch[1]) {
+			licenseName = parenthesisMatch[1].trim();
+		} 
+		// Pattern 2: "Typeface Name — License Type"
+		else if (sale.description && sale.description.includes('—')) {
+			const parts = sale.description.split('—');
+			if (parts.length > 1) {
+				licenseName = parts[1].trim();
+			}
+		}
+		// Pattern 3: If license is explicitly provided in a license property
+		else if (sale.license) {
+			licenseName = sale.license;
+		}
+		
+		// Calculate tax amounts for this sale
+		let saleTax = 0;
+		if (sale?.taxAmounts?.length) {
+			sale.taxAmounts.forEach((taxItem) => {
+				saleTax += taxItem.amount;
+			});
+		}
+
+		// Calculate discount amounts for this sale
+		let saleDiscounts = 0;
+		if (sale?.discountAmounts?.length) {
+			sale.discountAmounts.forEach((discount) => {
+				saleDiscounts += discount.amount;
+			});
+		}
+
+		// Calculate refund amounts for this sale
+		let saleRefunds = 0;
+		if (sale?.disputed) {
+			const disputeAmount = sale.totalWithTax - sale.total;
+			saleRefunds += disputeAmount;
+		}
+		if (sale?.refunds?.length) {
+			sale.refunds.forEach((refund) => {
+				saleRefunds += refund.adjustedTotal;
+			});
+		}
+
+		// Find or create license type entry
+		let existingLicense = licenseTypeData.find(item => item.name === licenseName);
+		if (existingLicense) {
+			// Update existing license data
+			existingLicense.grossTotal += sale.total;
+			existingLicense.taxTotal += saleTax;
+			existingLicense.discountTotal += saleDiscounts;
+			existingLicense.refundTotal += saleRefunds;
+			existingLicense.total += sale.total;
+			existingLicense.orders += 1;
+		} else {
+			// Create new license entry with detailed financials
+			licenseTypeData.push({
+				name: licenseName,
+				total: sale.total,
+				grossTotal: sale.total, // Total before any adjustments
+				taxTotal: saleTax,
+				discountTotal: saleDiscounts,
+				refundTotal: saleRefunds,
+				orders: 1
+			});
+		}
+
+		// Apply discounts and refunds to the adjusted total
+		existingLicense = licenseTypeData.find(item => item.name === licenseName);
+		sale?.discountAmounts?.forEach(discountAmount => {
+			existingLicense.total -= discountAmount.amount;
+		});
+
+		sale?.refunds?.forEach(refund => {
+			existingLicense.total -= refund.adjustedTotal;
+		});
+	});
+
+	// Calculate derived totals
+	licenseTypeData.forEach(license => {
+		// Total with discounts applied, but before tax and refunds
+		license.totalWithDiscounts = license.grossTotal - license.discountTotal;
+		
+		// Total before tax, but after discounts and refunds
+		license.pretaxTotal = license.totalWithDiscounts - license.refundTotal;
+		
+		// Net total after all adjustments (same as license.total)
+		license.netTotal = license.total;
+	});
+
+	// Sort by name
+	return licenseTypeData.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function processDesignersData(typefaceData) {
+	let designersData = [];
+
+	typefaceData?.forEach(typeface => {
+		let designer = designersData.find(author => author._id === typeface.author._id);
+		if (designer) {
+			designer.total += typeface.total;
+			designer.orders += typeface.orders;
+		} else {
+			designersData.push({
+				_id: typeface.author._id,
+				firstName: typeface.author.firstName,
+				lastName: typeface.author.lastName,
+				total: typeface.total,
+				orders: typeface.orders,
+			});
+		}
+	});
+
+	return designersData;
+}
+
+/**
+ * Generate chart series data
+ * @param {Object} chartState - Current chart state
+ * @param {boolean} displayLosses - Whether to display loss data
+ * @returns {Array} Chart series data
+ */
+export function generateSeriesData(chartState, displayLosses) {
+	const {
+		discountData,
+		discountFirstOrderData,
+		firstOrderData,
+		regularOrderData,
+		shippedOrdersData,
+		refundData,
+		shippingData,
+		taxData,
+		totalSalesData,
+		salesData,
+		discountLostData,
+		changeMax,
+		salesMax,
+		xAxis
+	} = chartState;
+
+	// Calculate start date as first day of the selected month
+	const startDate = new Date(chartState.xAxis[0]);
+
+	return [
+		!!(discountData?.length > 0 && discountData.some(value => value !== 0)) && {
+			type: 'bar',
+			data: (discountData && changeMax && salesMax) ? discountData.map((v) => (v / changeMax) * salesMax) : [0],
+			valueFormatter: (v) => v != null ? `${Math.round((v * changeMax) / salesMax)}` : '0',
+			color: 'url(#discountHatch) rgba(var(--blackRGB, 0,0,0), 0.1)',
+			label: 'Discounted Orders',
+			id: 'discountsId',
+			stack: 'total',
+			startDate: startDate
+		},
+		!!(discountFirstOrderData?.length > 0 && discountFirstOrderData.some(value => value !== 0)) && {
+			type: 'bar',
+			data: (discountFirstOrderData && changeMax && salesMax) ? discountFirstOrderData.map((v) => (v / changeMax) * salesMax) : [0],
+			valueFormatter: (v) => v != null ? `${Math.round((v * changeMax) / salesMax)}` : '0',
+			color: 'url(#discountFirstOrderHatch) rgba(var(--blueRGB, 0,0,255), .25)',
+			label: 'Discounted First Orders',
+			id: 'discountFirstOrderId',
+			stack: 'total',
+			startDate: startDate
+		},
+		!!(firstOrderData?.length > 0 && firstOrderData.some(value => value !== 0)) && {
+			type: 'bar',
+			data: (firstOrderData && changeMax && salesMax) ? firstOrderData.map((v) => (v / changeMax) * salesMax) : [0],
+			valueFormatter: (v) => v != null ? `${Math.round((v * changeMax) / salesMax)}` : '0',
+			color: 'rgba(var(--blueRGB, 0,0,255), .25)',
+			label: 'First Orders',
+			id: 'firstOrderId',
+			stack: 'total',
+			startDate: startDate
+		},
+		!!(regularOrderData?.length > 0 && regularOrderData.some(value => value !== 0)) && {
+			type: 'bar',
+			data: (regularOrderData && changeMax && salesMax) ? regularOrderData.map((v) => (v / changeMax) * salesMax) : [0],
+			valueFormatter: (v) => v != null ? `${Math.round((v * changeMax) / salesMax)}` : '0',
+			color: 'rgba(var(--blackRGB, 0,0,0), 0.25)',
+			label: 'Orders',
+			id: 'ordersId',
+			stack: 'total',
+			startDate: startDate
+		},
+		!!(shippedOrdersData?.length > 0 && shippedOrdersData.some(value => value !== 0)) && {
+			type: 'bar',
+			data: (shippedOrdersData && changeMax && salesMax) ? shippedOrdersData.map((v) => (v / changeMax) * salesMax) : [0],
+			valueFormatter: (v) => v != null ? `${Math.round((v * changeMax) / salesMax)}` : '0',
+			color: 'rgba(var(--orangeRGB, 255,165,0), .75)',
+			label: 'Shipped Orders',
+			id: 'shippedOrdersId',
+			stack: 'total',
+			startDate: startDate
+		},
+		!!(refundData?.length > 0 && refundData.some(value => value !== 0)) && {
+			type: 'bar',
+			data: (refundData && changeMax && salesMax) ? refundData.map((v) => -((v / changeMax) * salesMax)) : [0],
+			valueFormatter: (v) => v != null ? `${-1 * Math.round((v * changeMax) / salesMax)}` : '0',
+			color: 'rgba(var(--redRGB, 255,0,0), .75)',
+			label: 'Refunds & Disputes',
+			id: 'refundsId',
+			stack: 'total',
+			startDate: startDate
+		},
+		!!(shippingData?.length > 0 && shippingData.some(value => value !== 0)) && {
+			type: 'line',
+			data: shippingData,
+			valueFormatter: (v) => v != null ? `$${v.toLocaleString('en-US', { minimumFractionDigits: 2 })}` : '$0.00',
+			color: 'var(--orange, orange)',
+			label: 'Accrued Shipping',
+			startDate: startDate
+		},
+		!!(taxData?.length > 0 && taxData.some(value => value !== 0)) && {
+			type: 'line',
+			data: taxData,
+			valueFormatter: (v) => v != null ? `$${v.toLocaleString('en-US', { minimumFractionDigits: 2 })}` : '$0.00',
+			color: 'var(--red, red)',
+			label: 'Accrued Tax',
+			startDate: startDate
+		},
+		{
+			type: 'line',
+			data: totalSalesData,
+			valueFormatter: (v) => v != null ? `$${v.toLocaleString('en-US', { minimumFractionDigits: 2 })}` : '$0.00',
+			color: 'var(--green, green)',
+			label: 'Gross Accrued Sales',
+			startDate: startDate
+		},
+		{
+			type: 'line',
+			data: salesData,
+			valueFormatter: (v) => v != null ? `$${v.toLocaleString('en-US', { minimumFractionDigits: 2 })}` : '$0.00',
+			color: 'var(--blue, blue)',
+			label: "Day's Net Sales",
+			startDate: startDate
+		},
+		!!(displayLosses) && {
+			type: 'line',
+			data: discountLostData,
+			valueFormatter: (v) => v != null ? `$${v.toLocaleString('en-US', { minimumFractionDigits: 2 })}` : '$0.00',
+			color: 'var(--black, black)',
+			label: 'Missed Discounted Earnings',
+			startDate: startDate
+		},
+	].filter(Boolean);
+}

package/utils/useSalesDateQuery.js

@@ -0,0 +1,71 @@
+// Hook for managing sales date filtering via URL query parameters
+import { useRouter } from 'next/router';
+import { useState, useEffect } from 'react';
+
+/**
+ * Custom hook that manages month/year selection via URL query parameters
+ * Provides synchronized state for date selection and URL updates
+ * @returns {Object} Date state and update function
+ */
+export function useSalesDateQuery() {
+	const router = useRouter();
+	
+	// State for date management
+	const [month, setMonth] = useState(-1);
+	const [year, setYear] = useState(-1);
+	const [date, setDate] = useState(null);
+	
+	// Initialize from URL query parameters when router is ready
+	useEffect(() => {
+		if (!router.isReady) return;
+		
+		const queryMonth = router.query.month !== undefined ? parseInt(router.query.month) : -1;
+		const queryYear = router.query.year !== undefined ? parseInt(router.query.year) : -1;
+		
+		// If we have valid query params, use them
+		if (queryMonth >= 0 && queryMonth <= 11 && queryYear > 2000) {
+			setMonth(queryMonth);
+			setYear(queryYear);
+		} else if (month === -1 || year === -1) {
+			// Otherwise use current date (only if not already set)
+			const currentDate = new Date();
+			setMonth(currentDate.getUTCMonth());
+			setYear(currentDate.getUTCFullYear());
+		}
+	}, [router.isReady, router.query]);
+	
+	// Update date object when month/year change
+	useEffect(() => {
+		if (month >= 0 && year > 0) {
+			const newDate = new Date(Date.UTC(year, month, 1));
+			setDate(newDate);
+		}
+	}, [month, year]);
+	
+	/**
+	 * Updates the date state and URL query parameters
+	 * @param {Date} newDate - The new date to set
+	 */
+	const updateDate = (newDate) => {
+		const newMonth = new Date(newDate).getUTCMonth();
+		const newYear = new Date(newDate).getUTCFullYear();
+		
+		// Update state
+		setMonth(newMonth);
+		setYear(newYear);
+		
+		// Update URL query parameters without page reload
+		router.push(
+			{
+				pathname: router.pathname,
+				query: { ...router.query, month: newMonth, year: newYear }
+			},
+			undefined,
+			{ shallow: true }
+		);
+	};
+	
+	return { month, year, date, updateDate };
+}
+
+export default useSalesDateQuery;