react-shopwave-connect 0.1.1

package/dist/hooks/index.js

@@ -0,0 +1,749 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+
+//#region src/core/request.ts
+function resolveFetch(options) {
+	const f = options.fetch ?? (typeof fetch !== "undefined" ? fetch : void 0);
+	if (!f) throw new Error("No fetch implementation available. Pass `options.fetch` (e.g. node-fetch / undici) when running outside the browser.");
+	return f;
+}
+function buildExtras(extras, options) {
+	const merged = {
+		"Content-Type": "application/json",
+		...extras
+	};
+	if (options.token != null && merged.token == null) merged.token = options.token;
+	return merged;
+}
+/**
+* Returns a JSON string of API errors if the response carries any, otherwise
+* `null`. Mirrors the original `!responseJson.api.message.errors` checks.
+*/
+function getApiErrors(api) {
+	const errors = api?.message?.errors;
+	if (errors && Object.keys(errors).length > 0) return JSON.stringify(errors);
+	return null;
+}
+/**
+* GET helper. Sends request metadata via the `extras` header exactly like the
+* original hooks did, parses JSON, and returns the typed payload.
+*/
+async function apiGet(path, extras, options = {}) {
+	const doFetch = resolveFetch(options);
+	const url = (options.baseUrl ?? "") + path;
+	const headers = { extras: JSON.stringify(buildExtras(extras, options)) };
+	console.log("[API GET]", {
+		url,
+		headers
+	});
+	const response = await doFetch(url, {
+		method: "GET",
+		headers,
+		signal: options.signal
+	});
+	if (!response.ok) throw new Error(`Network response was not ok (${response.status})`);
+	return await response.json();
+}
+/**
+* JSON body helper for POST/PUT mutations.
+*/
+async function apiSend(path, method, payload, options = {}) {
+	const doFetch = resolveFetch(options);
+	const url = (options.baseUrl ?? "") + path;
+	const headers = { "Content-Type": "application/json" };
+	if (options.token != null) headers.token = options.token;
+	console.log(`[API ${method}]`, {
+		url,
+		headers,
+		payload
+	});
+	const response = await doFetch(url, {
+		method,
+		headers,
+		body: JSON.stringify(payload),
+		signal: options.signal
+	});
+	if (!response.ok) throw new Error(`Failed to ${method.toLowerCase()}: ${response.statusText}`);
+	return await response.json();
+}
+/**
+* DELETE helper.
+*/
+async function apiDelete(path, options = {}) {
+	const doFetch = resolveFetch(options);
+	const url = (options.baseUrl ?? "") + path;
+	const headers = {};
+	if (options.token != null) headers.token = options.token;
+	console.log("[API DELETE]", {
+		url,
+		headers
+	});
+	const response = await doFetch(url, {
+		method: "DELETE",
+		headers,
+		signal: options.signal
+	});
+	if (!response.ok) throw new Error(`Failed to delete: ${response.statusText}`);
+}
+
+//#endregion
+//#region src/core/category.ts
+/**
+* Fetches categories. Framework-agnostic: returns the flattened `Category[]`
+* or throws on API errors.
+*/
+async function fetchCategories(params = {}, options = {}) {
+	const extras = { deleted: params.deleted ?? false };
+	if (params.categoryIds) extras.categoryIds = params.categoryIds;
+	if (params.token) extras.token = params.token;
+	const json = await apiGet("/api/categories", extras, options);
+	const error = getApiErrors(json.api);
+	if (error) throw new Error(error);
+	return Object.values(json.categories ?? {});
+}
+
+//#endregion
+//#region src/core/consumer.ts
+/**
+* Fetches consumers by id. Returns an empty array when no ids are supplied
+* (the original hook short-circuited in that case).
+*/
+async function fetchConsumers(consumerIds, options = {}) {
+	if (!consumerIds || consumerIds.length === 0) return [];
+	const json = await apiGet("/api/consumer", { ids: consumerIds.join(",") }, options);
+	const error = getApiErrors(json.api);
+	if (error) throw new Error(error);
+	return Object.values(json.consumers ?? {});
+}
+
+//#endregion
+//#region src/core/employee.ts
+/**
+* Fetches employees. Returns the flattened `Employee[]`.
+*/
+async function fetchEmployees(params = {}, options = {}) {
+	const extras = { deleted: params.deleted ?? false };
+	if (params.employeeIds) extras.employeeIds = params.employeeIds;
+	const json = await apiGet("/api/employees", extras, options);
+	const error = getApiErrors(json.api);
+	if (error) throw new Error(error);
+	return Object.values(json.employees ?? {});
+}
+
+//#endregion
+//#region src/core/product.ts
+/**
+* Fetches products. Returns the flattened `Product[]`.
+*/
+async function fetchProducts(params = {}, options = {}) {
+	const extras = { deleted: params.deleted ?? false };
+	if (params.productIds) extras.productIds = params.productIds;
+	if (params.storeId) extras.storeId = params.storeId;
+	if (params.token) extras.token = params.token;
+	const json = await apiGet("/api/products", extras, options);
+	const error = getApiErrors(json.api);
+	if (error) throw new Error(error);
+	return Object.values(json.products ?? {});
+}
+/**
+* Fetches products by id and returns them keyed by id, transparently batching
+* the request (default 200 ids per call) to stay within API limits. Extracted
+* from the original `useBasketReport` inline batching loop so it can be reused
+* outside React.
+*/
+async function fetchProductsMap(productIds, options = {}, batchSize = 200) {
+	const result = {};
+	if (!productIds || productIds.length === 0) return result;
+	for (let i = 0; i < productIds.length; i += batchSize) {
+		const products = await fetchProducts({ productIds: productIds.slice(i, i + batchSize) }, options);
+		for (const product of products) result[product.id] = product;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/core/promotion.ts
+/**
+* Fetches promotions. Returns the flattened `Promotion[]`.
+*/
+async function fetchPromotions(params = {}, options = {}) {
+	const extras = { deleted: params.deleted ?? false };
+	if (params.promotionIds) extras.promotionIds = params.promotionIds;
+	if (params.token) extras.token = params.token;
+	const json = await apiGet("/api/promotions", extras, options);
+	const error = getApiErrors(json.api);
+	if (error) throw new Error(error);
+	return Object.values(json.promotions ?? {});
+}
+
+//#endregion
+//#region src/core/store.ts
+/**
+* Fetches stores. Returns the flattened `Store[]`.
+*/
+async function fetchStores(params = {}, options = {}) {
+	const json = await apiGet("/api/stores", { deleted: params.deleted ?? false }, options);
+	const error = getApiErrors(json.api);
+	if (error) throw new Error(error);
+	return Object.values(json.stores ?? {});
+}
+
+//#endregion
+//#region src/core/report.ts
+/**
+* Runs one or more report queries and returns the `reports` map keyed by query
+* name. The query is JSON-encoded into the `extras.query` header, matching the
+* original endpoint contract.
+*/
+async function fetchReport(query, options = {}) {
+	const json = await apiGet("/api/report", { query: JSON.stringify(query) }, options);
+	const error = getApiErrors(json.api);
+	if (error) throw new Error(error);
+	return json.reports ?? {};
+}
+
+//#endregion
+//#region src/core/session.ts
+/**
+* Ends the current server session.
+*
+* This is the framework-agnostic half of the original `useLogout` hook. The
+* Next.js-specific redirect logic (router.push to the auth server logout URL,
+* built from server actions) is intentionally NOT included here because it is
+* tied to `next/navigation` and `'use server'` actions — see the README.
+*/
+async function logout(options = {}) {
+	await apiDelete("/api/session?action=logout", options);
+}
+
+//#endregion
+//#region src/core/entity.ts
+/**
+* Generic CRUD-style mutations extracted from `useHandleDelete` /
+* `useHandleSubmit`. The original hooks also surfaced notistack snackbars; that
+* UI concern is deliberately left to the hooks/host layer so core stays
+* dependency-free.
+*/
+/**
+* Deletes `/api/{resourcePath}/{entityId}`.
+*/
+async function deleteEntity(resourcePath, entityId, options = {}) {
+	if (entityId == null || entityId === "") throw new Error("entityId is missing");
+	await apiDelete(`/api/${resourcePath}/${entityId}`, options);
+}
+/**
+* Sends a create/update mutation and returns the parsed `result` field
+* (matching the original `result.result` access).
+*/
+async function submitEntity({ endpoint, method = "POST", payload }, options = {}) {
+	return (await apiSend(endpoint, method, payload, options)).result;
+}
+
+//#endregion
+//#region src/core/basket.ts
+const DEFAULT_BASKET_FILTERS = {
+	search: "",
+	dateRange: {
+		start: null,
+		end: null
+	},
+	consumerId: null,
+	status: "all"
+};
+const DEFAULT_PAGINATION = {
+	page: 0,
+	pageSize: 25,
+	total: 0
+};
+/** Formats a date as `YYYY-MM-DD HH:mm:ss` for the report query. */
+function formatDateForQuery(date, isEndOfDay = false) {
+	return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")} ${isEndOfDay ? "23:59:59" : "00:00:00"}`;
+}
+/** Builds the `Basket` report query from a set of filters. */
+function buildBasketReportQuery(filters) {
+	const whereConditions = [];
+	const today = /* @__PURE__ */ new Date();
+	const startDate = filters.dateRange.start ?? today;
+	const endDate = filters.dateRange.end ?? today;
+	whereConditions.push(`Basket.completeDate > '${formatDateForQuery(startDate, false)}'`);
+	whereConditions.push(`Basket.completeDate < '${formatDateForQuery(endDate, true)}'`);
+	if (filters.consumerId) whereConditions.push(`Basket.consumerId = ${filters.consumerId}`);
+	if (filters.status !== "all") whereConditions.push(`Basket.status = '${filters.status}'`);
+	return { baskets: {
+		FROM: "Basket",
+		WHERE: whereConditions.length > 0 ? { AND: whereConditions } : void 0
+	} };
+}
+/** Flattens the raw report rows/keys into structured baskets. */
+function parseBasketReportData(reports) {
+	if (!reports?.baskets?.data || !reports?.baskets?.keys) return [];
+	const { keys, data } = reports.baskets;
+	const keyIndices = {};
+	keys.forEach((key, index) => {
+		keyIndices[key.name] = index;
+	});
+	const productKey = keys.find((k) => k.name === "Basket.Product");
+	const productSubKeys = {};
+	if (productKey?.item) productKey.item.forEach((subKey, index) => {
+		productSubKeys[subKey.name] = index;
+	});
+	return data.map((row) => {
+		const products = (row[keyIndices["Basket.Product"]] || []).map((productRow) => ({
+			productId: productRow[productSubKeys["Basket.Product.productId"]],
+			productName: `Product #${productRow[productSubKeys["Basket.Product.productId"]]}`,
+			quantity: productRow[productSubKeys["Basket.Product.quantity"]] || 1,
+			price: productRow[productSubKeys["Basket.Product.productPrice"]] || 0,
+			tax: productRow[productSubKeys["Basket.Product.productTaxPercentage"]] || 0
+		}));
+		const total = products.reduce((sum, p) => sum + p.price * p.quantity, 0);
+		const taxTotal = products.reduce((sum, p) => sum + p.price * p.quantity * p.tax, 0);
+		const completeDateTimestamp = row[keyIndices["Basket.completeDate"]];
+		const completeDate = completeDateTimestamp ? new Date(completeDateTimestamp).toISOString() : "";
+		return {
+			id: row[keyIndices["Basket.id"]],
+			name: row[keyIndices["Basket.name"]],
+			consumerId: row[keyIndices["Basket.consumerId"]],
+			products,
+			total,
+			taxTotal,
+			status: "completed",
+			completeDate
+		};
+	});
+}
+/** Unique non-null consumer ids referenced by a set of baskets. */
+function collectConsumerIds(baskets) {
+	if (!baskets.length) return null;
+	const ids = baskets.map((b) => b.consumerId).filter((id) => id != null);
+	return ids.length > 0 ? [...new Set(ids)] : null;
+}
+/** Unique product ids referenced by a set of baskets. */
+function collectProductIds(baskets) {
+	if (!baskets.length) return null;
+	const ids = /* @__PURE__ */ new Set();
+	baskets.forEach((basket) => {
+		basket.products.forEach((product) => {
+			if (product.productId) ids.add(product.productId);
+		});
+	});
+	return ids.size > 0 ? [...ids] : null;
+}
+/** Joins baskets with consumer + product lookups, applies search, sorts. */
+function combineBasketRows({ baskets, consumerMap, productMap, search }) {
+	if (!baskets.length) return [];
+	let combinedRows = baskets.map((basket) => {
+		const consumer = basket.consumerId ? consumerMap[basket.consumerId] : null;
+		const productsWithNames = basket.products.map((p) => {
+			const product = productMap[p.productId];
+			return {
+				...p,
+				productName: product?.name || `Product #${p.productId}`
+			};
+		});
+		return {
+			id: basket.id,
+			basketId: basket.id,
+			basketName: basket.name || `Basket #${basket.id}`,
+			consumerId: basket.consumerId,
+			consumerName: consumer ? `${consumer.firstName} ${consumer.lastName}` : "Unknown",
+			consumerEmail: consumer?.email || "-",
+			products: productsWithNames,
+			basketTotal: (basket.total || 0) / 100,
+			tax: basket.taxTotal || 0,
+			dateTime: basket.completeDate,
+			status: basket.status || "pending"
+		};
+	});
+	if (search) {
+		const searchLower = search.toLowerCase();
+		combinedRows = combinedRows.filter((row) => row.basketId.toString().includes(searchLower) || row.basketName.toLowerCase().includes(searchLower) || row.consumerName.toLowerCase().includes(searchLower) || row.consumerEmail.toLowerCase().includes(searchLower));
+	}
+	combinedRows.sort((a, b) => {
+		const dateA = new Date(a.dateTime).getTime();
+		return new Date(b.dateTime).getTime() - dateA;
+	});
+	return combinedRows;
+}
+/** Aggregate totals for a set of report rows. */
+function computeBasketSummary(rows) {
+	const uniqueConsumerIds = new Set(rows.map((row) => row.consumerId));
+	return {
+		totalBaskets: rows.length,
+		totalRevenue: rows.reduce((sum, row) => sum + row.basketTotal, 0),
+		totalTax: rows.reduce((sum, row) => sum + row.tax, 0),
+		uniqueConsumers: uniqueConsumerIds.size
+	};
+}
+/** Builds a consumer id → consumer lookup. */
+function buildConsumerMap(consumers) {
+	const map = {};
+	if (consumers) consumers.forEach((consumer) => {
+		map[consumer.id] = consumer;
+	});
+	return map;
+}
+
+//#endregion
+//#region src/hooks/shared.ts
+function toMessage(e) {
+	if (e instanceof Error) return e.message;
+	return String(e);
+}
+/**
+* Internal primitive powering the auto-fetch hooks. Runs `fetcher` on mount and
+* whenever `deps` change, tracks loading/error/data, cancels in-flight requests
+* on unmount or dep change, and exposes `refetch`.
+*
+* When `enabled` is false the fetch is skipped (used for hooks that need
+* arguments before they can run, e.g. consumers-by-id).
+*/
+function useQuery(fetcher, deps, enabled = true) {
+	const [data, setData] = useState(null);
+	const [loading, setLoading] = useState(enabled);
+	const [error, setError] = useState(null);
+	const [tick, setTick] = useState(0);
+	const refetch = useCallback(() => setTick((t) => t + 1), []);
+	useEffect(() => {
+		if (!enabled) {
+			setLoading(false);
+			return;
+		}
+		const controller = new AbortController();
+		let active = true;
+		setData(null);
+		setError(null);
+		setLoading(true);
+		fetcher(controller.signal).then((result) => {
+			if (active) setData(result);
+		}).catch((e) => {
+			if (active && e?.name !== "AbortError") setError(toMessage(e));
+		}).finally(() => {
+			if (active) setLoading(false);
+		});
+		return () => {
+			active = false;
+			controller.abort();
+		};
+	}, [
+		...deps,
+		tick,
+		enabled
+	]);
+	return {
+		data,
+		loading,
+		error,
+		refetch
+	};
+}
+/**
+* Internal primitive powering the manually-triggered hooks.
+*/
+function useMutation(action, deps) {
+	const [data, setData] = useState(null);
+	const [loading, setLoading] = useState(false);
+	const [error, setError] = useState(null);
+	return {
+		mutate: useCallback(async (...args) => {
+			setLoading(true);
+			setError(null);
+			try {
+				const result = await action(...args);
+				setData(result);
+				return result;
+			} catch (e) {
+				setError(toMessage(e));
+				return null;
+			} finally {
+				setLoading(false);
+			}
+		}, deps),
+		data,
+		loading,
+		error
+	};
+}
+
+//#endregion
+//#region src/hooks/useCategory.ts
+/**
+* Auto-fetches categories on mount and whenever the params change.
+* Manual reloads are available via `refetch` (replaces the old `reloadFlag`).
+*/
+function useCategory(params = {}, options) {
+	return useQuery((signal) => fetchCategories(params, {
+		...options,
+		signal
+	}), [
+		JSON.stringify(params),
+		options?.baseUrl,
+		options?.token
+	]);
+}
+
+//#endregion
+//#region src/hooks/useConsumer.ts
+/**
+* Auto-fetches consumers by id. Disabled (no request) until at least one id is
+* supplied, mirroring the original early-return behaviour.
+*/
+function useConsumer(consumerIds, options) {
+	const enabled = !!consumerIds && consumerIds.length > 0;
+	return useQuery((signal) => fetchConsumers(consumerIds, {
+		...options,
+		signal
+	}), [
+		JSON.stringify(consumerIds),
+		options?.baseUrl,
+		options?.token
+	], enabled);
+}
+var useConsumer_default = useConsumer;
+
+//#endregion
+//#region src/hooks/useEmployee.ts
+/**
+* Auto-fetches employees on mount and whenever the params change.
+*/
+function useEmployee(params = {}, options) {
+	return useQuery((signal) => fetchEmployees(params, {
+		...options,
+		signal
+	}), [
+		JSON.stringify(params),
+		options?.baseUrl,
+		options?.token
+	]);
+}
+
+//#endregion
+//#region src/hooks/useProduct.ts
+/**
+* Auto-fetches products on mount and whenever the params change.
+*/
+function useProduct(params = {}, options) {
+	return useQuery((signal) => fetchProducts(params, {
+		...options,
+		signal
+	}), [
+		JSON.stringify(params),
+		options?.baseUrl,
+		options?.token
+	]);
+}
+
+//#endregion
+//#region src/hooks/usePromotion.ts
+/**
+* Auto-fetches promotions on mount and whenever the params change.
+* Manual reloads are available via `refetch`.
+*/
+function usePromotion(params = {}, options) {
+	return useQuery((signal) => fetchPromotions(params, {
+		...options,
+		signal
+	}), [
+		JSON.stringify(params),
+		options?.baseUrl,
+		options?.token
+	]);
+}
+
+//#endregion
+//#region src/hooks/useStore.ts
+/**
+* Auto-fetches stores on mount. Manual reloads via `refetch`
+* (replaces the old `reloadFlag` argument).
+*/
+function useStore(params = {}, options) {
+	return useQuery((signal) => fetchStores(params, {
+		...options,
+		signal
+	}), [
+		JSON.stringify(params),
+		options?.baseUrl,
+		options?.token
+	]);
+}
+
+//#endregion
+//#region src/hooks/useReport.ts
+/**
+* Auto-fetches one or more reports. Disabled (no request) until a non-null
+* query is supplied, mirroring the original early-return behaviour.
+*/
+function useReport(query, options) {
+	const enabled = !!query;
+	return useQuery((signal) => fetchReport(query, {
+		...options,
+		signal
+	}), [
+		JSON.stringify(query),
+		options?.baseUrl,
+		options?.token
+	], enabled);
+}
+var useReport_default = useReport;
+
+//#endregion
+//#region src/hooks/useDelete.ts
+/**
+* Manually-triggered delete. Returns `{ mutate, loading, error, data }`.
+*
+* Note: the original `useHandleDelete` surfaced notistack toasts. That UI
+* concern is left to the host app — handle success/error from the returned
+* state or the promise resolved by `mutate`.
+*
+* @example
+* const { mutate, loading } = useDelete();
+* await mutate("products", 42);
+*/
+function useDelete(options) {
+	return useMutation((resourcePath, entityId) => deleteEntity(resourcePath, entityId, options), [options?.baseUrl, options?.token]);
+}
+
+//#endregion
+//#region src/hooks/useSubmit.ts
+/**
+* Manually-triggered create/update. Returns `{ mutate, loading, error, data }`,
+* where `data` is the API `result` payload.
+*
+* The original `useHandleSubmit` bundled validation, payload transformation and
+* notistack toasts. Those are app concerns: resolve the endpoint/method/payload
+* in your component and pass them in, then react to the returned state.
+*
+* @example
+* const { mutate, loading } = useSubmit<Product>();
+* const saved = await mutate({
+*   endpoint: id ? `/api/products/${id}` : "/api/products",
+*   method: id ? "PUT" : "POST",
+*   payload,
+* });
+*/
+function useSubmit(options) {
+	return useMutation((args) => submitEntity(args, options), [options?.baseUrl, options?.token]);
+}
+
+//#endregion
+//#region src/hooks/useLogout.ts
+/**
+* Manually-triggered logout (ends the server session).
+*
+* This is framework-agnostic and does NOT redirect. The original `useLogout`
+* also pushed the browser to the auth-server logout URL via `next/navigation`
+* and `'use server'` actions; that part is Next-specific and stays in your app.
+*
+* @example
+* const { mutate: doLogout } = useLogout();
+* await doLogout();
+* router.push(logoutUrl); // app-specific redirect
+*/
+function useLogout(options) {
+	return useMutation(() => logout(options), [options?.baseUrl, options?.token]);
+}
+
+//#endregion
+//#region src/hooks/useBasketReport.ts
+/**
+* Composite hook that orchestrates the report → consumers → products pipeline
+* for the basket report screen. All the data-shaping logic now lives in the
+* framework-agnostic `core/basket` helpers; this hook is the thin React glue
+* (state, memoisation, effects) on top of them.
+*/
+function useBasketReport(options) {
+	const [filters, setFiltersState] = useState(DEFAULT_BASKET_FILTERS);
+	const [pagination, setPaginationState] = useState(DEFAULT_PAGINATION);
+	const [refreshFlag, setRefreshFlag] = useState(0);
+	const { data: reports, loading: basketLoading, error: basketError } = useReport_default(useMemo(() => buildBasketReportQuery(filters), [filters, refreshFlag]), options);
+	const basketData = useMemo(() => parseBasketReportData(reports), [reports]);
+	const consumerIds = useMemo(() => collectConsumerIds(basketData), [basketData]);
+	const productIds = useMemo(() => collectProductIds(basketData), [basketData]);
+	const { data: consumers, loading: consumerLoading, error: consumerError } = useConsumer_default(consumerIds, options);
+	const [productMap, setProductMap] = useState({});
+	const [productLoading, setProductLoading] = useState(false);
+	const [productError, setProductError] = useState(null);
+	useEffect(() => {
+		if (!productIds || productIds.length === 0) {
+			setProductMap({});
+			return;
+		}
+		let active = true;
+		setProductLoading(true);
+		setProductError(null);
+		fetchProductsMap(productIds, options).then((map) => {
+			if (active) setProductMap(map);
+		}).catch((e) => {
+			if (active) setProductError(e instanceof Error ? e.message : "Failed to fetch products");
+		}).finally(() => {
+			if (active) setProductLoading(false);
+		});
+		return () => {
+			active = false;
+		};
+	}, [
+		JSON.stringify(productIds),
+		options?.baseUrl,
+		options?.token
+	]);
+	const consumerMap = useMemo(() => buildConsumerMap(consumers), [consumers]);
+	const rows = useMemo(() => combineBasketRows({
+		baskets: basketData,
+		consumerMap,
+		productMap,
+		search: filters.search
+	}), [
+		basketData,
+		consumerMap,
+		productMap,
+		filters.search
+	]);
+	const summary = useMemo(() => computeBasketSummary(rows), [rows]);
+	useEffect(() => {
+		if (rows.length > 0 && rows.length === pagination.pageSize) setPaginationState((prev) => ({
+			...prev,
+			total: (pagination.page + 2) * pagination.pageSize
+		}));
+		else if (rows.length > 0) setPaginationState((prev) => ({
+			...prev,
+			total: pagination.page * pagination.pageSize + rows.length
+		}));
+	}, [
+		rows.length,
+		pagination.page,
+		pagination.pageSize
+	]);
+	const setFilters = useCallback((newFilters) => {
+		setFiltersState((prev) => ({
+			...prev,
+			...newFilters
+		}));
+		setPaginationState((prev) => ({
+			...prev,
+			page: 0
+		}));
+	}, []);
+	const setPagination = useCallback((page, pageSize) => {
+		setPaginationState((prev) => ({
+			...prev,
+			page,
+			pageSize
+		}));
+	}, []);
+	const refresh = useCallback(() => {
+		setRefreshFlag((prev) => prev + 1);
+	}, []);
+	return {
+		rows,
+		summary,
+		loading: basketLoading || consumerLoading || productLoading,
+		error: basketError || consumerError || productError,
+		filters,
+		setFilters,
+		pagination,
+		setPagination,
+		refresh
+	};
+}
+
+//#endregion
+export { useBasketReport, useCategory, useConsumer, useDelete, useEmployee, useLogout, useProduct, usePromotion, useReport, useStore, useSubmit };
+//# sourceMappingURL=index.js.map