react-shopwave-connect 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ShopwaveLTD
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,258 @@
+# react-shopwave-connect
+
+Shopwave API client split into two clearly separated layers:
+
+- **`core`** — framework-agnostic async API functions + all TypeScript types. No React anywhere. Works in any TS/JS project (Node script, Vue, Angular, CLI, …).
+- **`hooks`** — thin React wrappers around `core`, with a consistent `{ data, loading, error, refetch }` shape. React is a **peer dependency** and is never bundled.
+
+```
+src/
+  core/    index.ts + one file per domain (category, consumer, employee,
+           product, store, report, session, entity, basket) — plus the shared
+           request helper (request.ts) and API envelope types (types.ts)
+  hooks/   index.ts + one wrapper per domain, all importing logic from core
+```
+
+## Install
+
+```bash
+npm install react-shopwave-connect
+# React is only needed if you use the hooks layer:
+npm install react react-dom
+```
+
+## Import paths
+
+| Import                               | What you get                                  |
+| ------------------------------------ | --------------------------------------------- |
+| `react-shopwave-connect/core`         | Framework-agnostic functions + types only     |
+| `react-shopwave-connect/hooks`        | React hooks only                              |
+| `react-shopwave-connect`              | Both (re-exports `core` + `hooks`)            |
+
+Prefer the subpath imports when you want a hard boundary — e.g. a Node service should import from `/core` so React never enters the dependency graph.
+
+## Configuration (`RequestOptions`)
+
+Every `core` function (and every hook) accepts an optional `options` argument:
+
+```ts
+interface RequestOptions {
+  baseUrl?: string;        // prefix for every path; omit in the browser to use
+                           // relative URLs like "/api/products"
+  token?: string;          // forwarded as the `token` request header
+  fetch?: typeof fetch;    // custom fetch (Node < 18, tests, interceptors)
+  signal?: AbortSignal;    // cancellation (hooks pass this automatically)
+}
+```
+
+In the browser / Next.js you can usually omit `options` entirely (relative URLs resolve against the current origin). Outside the browser, pass an absolute `baseUrl` and a `token`.
+
+---
+
+## 1. Using `core` standalone (no React)
+
+Plain async functions — usable in a Node script, CLI, Vue, Angular, a server route, etc.
+
+```ts
+import {
+  fetchProducts,
+  fetchStores,
+  fetchReport,
+  type Product,
+} from "react-shopwave-connect/core";
+
+const options = {
+  baseUrl: "https://api.shopwave.example",
+  token: process.env.SHOPWAVE_TOKEN,
+};
+
+async function main() {
+  const stores = await fetchStores({}, options);
+  console.log(`${stores.length} stores`);
+
+  const products: Product[] = await fetchProducts(
+    { storeId: stores[0].id },
+    options
+  );
+  console.log(products.map((p) => p.name));
+
+  const reports = await fetchReport(
+    { sales: { FROM: "Basket", WHERE: { AND: ["Basket.status = 'completed'"] } } },
+    options
+  );
+  console.log(reports.sales?.data.length, "rows");
+}
+
+main().catch(console.error);
+```
+
+On Node < 18 (no global `fetch`), inject one:
+
+```ts
+import { fetchStores } from "react-shopwave-connect/core";
+import fetch from "node-fetch";
+
+await fetchStores({}, { baseUrl: "https://api.merchantstack.com", fetch });
+```
+
+Functions **throw** on network failure or API errors (the error message contains the serialized API errors), so wrap calls in `try/catch`.
+
+### Available `core` functions
+
+| Domain    | Function(s)                                              |
+| --------- | ------------------------------------------------------- |
+| category  | `fetchCategories`                                       |
+| consumer  | `fetchConsumers`                                        |
+| employee  | `fetchEmployees`                                        |
+| product   | `fetchProducts`, `fetchProductsMap` (batched, keyed)    |
+| store     | `fetchStores`                                           |
+| report    | `fetchReport`                                           |
+| session   | `logout`                                                |
+| entity    | `deleteEntity`, `submitEntity`                          |
+| basket    | `buildBasketReportQuery`, `parseBasketReportData`, `combineBasketRows`, `computeBasketSummary`, … (pure transforms) |
+
+All types/interfaces (`Product`, `Store`, `Category`, `Consumer`, `Employee`, `ReportQueryMap`, `Basket*`, `apiResponse`, …) are exported from `core` too.
+
+---
+
+## 2. Using `hooks` in React / Next.js
+
+Every auto-fetching hook returns the same shape:
+
+```ts
+{ data, loading, error, refetch }
+```
+
+```tsx
+"use client";
+import { useProduct, useStore } from "react-shopwave-connect/hooks";
+
+export function ProductList({ storeId }: { storeId: number }) {
+  const { data: products, loading, error, refetch } = useProduct({ storeId });
+
+  if (loading) return <p>Loading…</p>;
+  if (error) return <p>Error: {error}</p>;
+
+  return (
+    <>
+      <button onClick={refetch}>Reload</button>
+      <ul>{products?.map((p) => <li key={p.id}>{p.name}</li>)}</ul>
+    </>
+  );
+}
+```
+
+In the browser you don't need `baseUrl` — relative `/api/...` URLs work. To target another host or pass a token, give every hook the same optional second argument:
+
+```tsx
+const { data } = useProduct({ storeId }, { baseUrl: "https://api.merchantstack.com", token });
+```
+
+### Auto-fetch hooks (`useEffect`-based)
+
+`useCategory`, `useConsumer`, `useEmployee`, `useProduct`, `useStore`, `useReport`.
+They fetch on mount and re-run when their arguments change. `useConsumer` and `useReport` stay idle until you pass ids / a query (they return `loading: false`, `data: null` until then). `refetch()` replaces the old `reloadFlag` argument.
+
+### Manually-triggered hooks (`useCallback`-based)
+
+`useDelete`, `useSubmit`, `useLogout` return `{ mutate, data, loading, error }` — nothing fires until you call `mutate`:
+
+```tsx
+import { useDelete, useSubmit } from "react-shopwave-connect/hooks";
+
+const { mutate: remove, loading } = useDelete();
+await remove("products", productId);
+
+const { mutate: save } = useSubmit<Product>();
+const saved = await save({
+  endpoint: id ? `/api/products/${id}` : "/api/products",
+  method: id ? "PUT" : "POST",
+  payload,
+});
+```
+
+> The original `useHandleDelete` / `useHandleSubmit` also showed notistack toasts and did validation/payload transforms. Those are app concerns and are intentionally left out of the package — drive them from the returned state or the value `mutate` resolves to.
+
+### Composite hook
+
+`useBasketReport(options?)` orchestrates the report → consumers → products pipeline and returns rows, summary, filters, pagination and a `refresh()`. All of its data-shaping logic lives in `core/basket` (pure, testable functions); the hook is just the React glue.
+
+---
+
+## Auth & Next.js note
+
+The original `useLogin` / `useLogout` were tightly coupled to Next.js (`next/navigation` router + `'use server'` actions) and **cannot** be framework-agnostic, so they are **not** shipped here. Instead:
+
+- `core.logout()` / `useLogout()` end the server session (`DELETE /api/session?action=logout`) — no redirect.
+- The redirect to the auth server's login/logout URL stays in your app, since it depends on your server actions and router:
+
+```tsx
+"use client";
+import { useRouter } from "next/navigation";
+import { useLogout } from "react-shopwave-connect/hooks";
+import { getLogoutUrl } from "@/app/actions";
+
+export function LogoutButton() {
+  const router = useRouter();
+  const { mutate: endSession } = useLogout();
+
+  const onClick = async () => {
+    await endSession();
+    router.push(await getLogoutUrl(window.location.origin + "/auth"));
+  };
+
+  return <button onClick={onClick}>Log out</button>;
+}
+```
+
+---
+
+## Build
+
+Built with [`tsdown`](https://tsdown.dev) into dual ESM + CJS with `.d.ts` types, via two separate entries (`core` with no externals, `hooks` with `react`/`react-dom` marked external so they're never bundled).
+
+```bash
+npm run build       # emit dist/
+npm run typecheck   # tsc --noEmit
+```
+
+---
+
+## Testing
+
+Integration tests run against a live API using [Vitest](https://vitest.dev). Tests are located in `tests/integration/` and cover full CRUD lifecycles for Products, Categories, Consumers, and Employees.
+
+### Environment Variables
+
+| Variable    | Description                          | Example                                   |
+|-------------|--------------------------------------|-------------------------------------------|
+| `API_URL`   | Base URL for the API                 | `https://api.staging.merchantstack.com`   |
+| `API_TOKEN` | Authentication token                 | `your-staging-token`                      |
+
+### Running Tests
+
+```bash
+# Set environment variables
+export API_URL=https://api.staging.merchantstack.com
+export API_TOKEN=your-staging-token
+
+# Run all integration tests
+npm run test:integration
+
+# Run tests in watch mode
+npm test
+```
+
+### Test Structure
+
+```
+tests/
+  integration/
+    setup.ts                       # Shared config and helpers
+    products.integration.test.ts   # Products CRUD lifecycle
+    categories.integration.test.ts # Categories CRUD lifecycle
+    consumers.integration.test.ts  # Consumers CRUD lifecycle
+    employees.integration.test.ts  # Employees CRUD lifecycle
+```
+
+Each test file uses `describe.sequential` to guarantee execution order (create → read → update → delete) with shared state across tests. An `afterAll` cleanup ensures created resources are deleted even if a test fails midway.

package/dist/core/index.cjs

@@ -0,0 +1,426 @@
+
+//#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
+const rolesById = {
+	"1": "Owner",
+	"2": "Manager",
+	"3": "Assistant",
+	"4": "Guest",
+	"5": "Assistant Manager"
+};
+/**
+* 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
+/** Promotion rule identifiers as stored by the Shopwave API. */
+let PromotionRuleSet = /* @__PURE__ */ function(PromotionRuleSet$1) {
+	PromotionRuleSet$1["Percentage"] = "|%^/";
+	PromotionRuleSet$1["Combo"] = "&%</";
+	PromotionRuleSet$1["MealDeal"] = "&=^/";
+	return PromotionRuleSet$1;
+}({});
+/**
+* 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
+exports.DEFAULT_BASKET_FILTERS = DEFAULT_BASKET_FILTERS;
+exports.DEFAULT_PAGINATION = DEFAULT_PAGINATION;
+exports.PromotionRuleSet = PromotionRuleSet;
+exports.apiDelete = apiDelete;
+exports.apiGet = apiGet;
+exports.apiSend = apiSend;
+exports.buildBasketReportQuery = buildBasketReportQuery;
+exports.buildConsumerMap = buildConsumerMap;
+exports.collectConsumerIds = collectConsumerIds;
+exports.collectProductIds = collectProductIds;
+exports.combineBasketRows = combineBasketRows;
+exports.computeBasketSummary = computeBasketSummary;
+exports.deleteEntity = deleteEntity;
+exports.fetchCategories = fetchCategories;
+exports.fetchConsumers = fetchConsumers;
+exports.fetchEmployees = fetchEmployees;
+exports.fetchProducts = fetchProducts;
+exports.fetchProductsMap = fetchProductsMap;
+exports.fetchPromotions = fetchPromotions;
+exports.fetchReport = fetchReport;
+exports.fetchStores = fetchStores;
+exports.formatDateForQuery = formatDateForQuery;
+exports.getApiErrors = getApiErrors;
+exports.logout = logout;
+exports.parseBasketReportData = parseBasketReportData;
+exports.rolesById = rolesById;
+exports.submitEntity = submitEntity;
+//# sourceMappingURL=index.cjs.map