@perdieminc/time-slots 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Per Diem Subscriptions Inc.
+
+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,100 @@
+# @perdieminc/time-slots
+
+Generate time slots for scheduling—pickup, delivery, and curbside—with timezone-aware business hours, prep time, and optional pre-sale / catering rules.
+
+## Requirements
+
+- **Node.js** ≥ 20
+- **TypeScript** (consumers can use the package from source or your built output)
+
+## Install
+
+```bash
+npm install @perdieminc/time-slots
+```
+
+## Overview
+
+This library helps you:
+
+- Build **fulfillment schedules** (days and time slots) for a given location and fulfillment type (pickup, delivery, curbside).
+- Respect **business hours** and overrides (e.g. holidays, special hours).
+- Apply **prep time** (per shift or per day) and **slot gaps** to compute the first available slot and generate slots.
+- Support **pre-sale** windows (date range and optional custom hours) and **weekly pre-sale** (fixed pickup/ordering days).
+- Support **catering** flows with cart-derived prep time (by minute, hour, or day).
+- Filter slots by **busy times** and optional **menu/category** rules.
+
+All date/time logic is timezone-aware (e.g. `America/New_York`). The package supports multiple platforms for timezone handling: **web** (default, uses `@date-fns/tz`) and **ios/android** (uses `timezone-support`).
+
+## Main API
+
+### `getSchedules(params): GetSchedulesResult`
+
+Builds the schedule for the current location and fulfillment preference.
+
+**Parameters (`GetSchedulesParams`):**
+
+| Field | Description |
+|-------|-------------|
+| `store` | Store config: ASAP/same-day flags, max future days, business hour overrides, pre-sale and weekly pre-sale config. |
+| `locations` | List of locations (with `location_id`, `timezone`, and business hours). |
+| `cartItems` | Cart items (used for pre-sale, weekly pre-sale, catering prep time, and category-based filtering). |
+| `fulfillmentPreference` | `"PICKUP"` \| `"DELIVERY"` \| `"CURBSIDE"`. |
+| `prepTimeSettings` | Prep time in minutes, per-weekday overrides, gap, busy times, cadence (minute/hour/day), frequency, and optional delivery buffer. |
+| `currentLocation` | The location to generate the schedule for. |
+| `isCateringFlow` | If `true`, prep time is derived from cart catering config. |
+| `platform` | `"web"` \| `"ios"` \| `"android"` for timezone handling (default `"web"`). |
+
+**Returns:** `{ schedule: FulfillmentSchedule, isWeeklyPreSaleAvailable: boolean }`.
+
+- **`schedule`** is an array of **day schedules**, each with `date`, `openingTime`, `closingTime`, `firstAvailableSlot`, and `slots` (array of `Date`).
+
+### Types and constants
+
+- **Fulfillment:** `FULFILLMENT_TYPES`, `FulfillmentType`, `FulfillmentSchedule`, `DaySchedule`.
+- **Prep time:** `PrepTimeBehaviour` (first shift / every shift / roll), `DEFAULT_PREP_TIME_IN_MINUTES`, `DEFAULT_GAP_IN_MINUTES`, `PrepTimeSettings`, `PrepTimeCadence` (minute / hour / day).
+- **Store / cart:** `StoreConfig`, `PreSaleConfig`, `WeeklyPreSaleConfig`, `CartItem`, `PrepTimeSettings`, `CateringPrepTimeResult`.
+- **Location / hours:** `LocationLike`, `BusinessHour`, `BusinessHoursOverrideInput` / `Output`, `getLocationsBusinessHoursOverrides`, `getOpeningClosingTime`.
+- **Platform:** `PLATFORM` (web, ios, android).
+
+## Utilities (exported)
+
+- **`getCateringPrepTimeConfig(params)`** – Derives prep time cadence and frequency from cart items for catering.
+- **`getPreSalePickupDates(pickupDays, orderingDays)`** – Dates when weekly pre-sale pickup is allowed.
+- **`isTodayInTimeZone(date, timezone)`** / **`isTomorrowInTimeZone(date, timezone)`** – Date checks in a given timezone.
+- **`overrideTimeZoneOnUTC(utcDate, timezone)`** – Interpret a UTC date in a store timezone.
+- **`filterBusyTimesFromSchedule({ schedule, busyTimes, cartCategoryIds })`** – Remove busy blocks from a schedule.
+- **`filterMenusFromSchedule`** – Filter schedule by menu type.
+- **`getOpeningClosingTime(params)`** – Opening/closing time for a given date and business hours.
+
+Internal schedule generation uses **`getNextAvailableDates`**-style logic (timezone-aware “next N open days”) and slot generation with configurable prep time behaviour and gap.
+
+## Prep time (high level)
+
+Prep time can be applied in different ways (see `PrepTimeBehaviour` and `PrepTimeSettings`):
+
+- **Cadence:** by **minute**, **hour**, or **day** (e.g. “first slot after 2 days”).
+- **Per weekday:** different prep minutes per day via `weekDayPrepTimes`.
+- **Catering:** when `isCateringFlow` is true, cadence and frequency are derived from cart items via `getCateringPrepTimeConfig`.
+- **Delivery:** optional `estimatedDeliveryMinutes` added to weekday prep times for delivery.
+
+Detailed behaviour and edge cases are covered by the test suite. QA-friendly test cases (Given / When / Expected) are in [docs/TEST-CASES.md](docs/TEST-CASES.md).
+
+## Scripts
+
+```bash
+npm run build        # Compile TypeScript
+npm run test         # Run tests
+npm run test:coverage
+npm run lint         # Lint with Biome
+npm run format       # Format with Biome
+```
+
+## License
+
+MIT © Per Diem Subscriptions Inc.
+
+## Repository
+
+- **Homepage:** [perdiem-pkgs](https://github.com/PerDiemInc/perdiem-pkgs#readme)
+- **Issues:** [perdiem-pkgs/issues](https://github.com/PerDiemInc/perdiem-pkgs/issues)

package/package.json

@@ -0,0 +1,63 @@
+{
+	"name": "@perdieminc/time-slots",
+	"version": "0.0.1",
+	"description": "Generate time slots for scheduling",
+	"keywords": [
+		"time-slots",
+		"schedule",
+		"slots"
+	],
+	"license": "MIT",
+	"author": "Per Diem Subscriptions Inc.",
+	"homepage": "https://github.com/PerDiemInc/perdiem-pkgs#readme",
+	"bugs": {
+		"url": "https://github.com/PerDiemInc/perdiem-pkgs/issues"
+	},
+	"main": "src/index.ts",
+	"types": "src/index.ts",
+	"engines": {
+		"node": ">=20"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/PerDiemInc/perdiem-pkgs.git"
+	},
+	"scripts": {
+		"lint": "biome lint .",
+		"lint:fix": "biome lint --write .",
+		"format": "biome check --write .",
+		"clean": "rm -rf lib types coverage",
+		"build": "tsc -b .",
+		"build:watch": "tsc --watch",
+		"test": "vitest run",
+		"test:coverage": "vitest run --coverage",
+		"coveralls": "vitest run --coverage",
+		"test:watch": "vitest"
+	},
+	"dependencies": {
+		"@date-fns/tz": "^1.4.1",
+		"date-fns": "^4.1.0",
+		"date-fns-tz": "^3.2.0",
+		"timezone-support": "^2.2.0"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "2.3.11",
+		"@types/node": "^20.19.27",
+		"@vitest/coverage-v8": "^3.2.4",
+		"husky": "^9.1.7",
+		"lint-staged": "^16.2.7",
+		"tsx": "^4.21.0",
+		"typescript": "^5.9.3",
+		"vitest": "^3.2.4"
+	},
+	"files": [
+		"src"
+	],
+	"directories": {
+		"lib": "lib",
+		"test": "test"
+	},
+	"publishConfig": {
+		"access": "public"
+	}
+}

package/src/constants.ts

@@ -0,0 +1,45 @@
+/**
+ * Fulfillment types for pickup, delivery, curbside.
+ */
+export const FULFILLMENT_TYPES = {
+	PICKUP: "PICKUP",
+	DELIVERY: "DELIVERY",
+	CURBSIDE: "CURBSIDE",
+} as const;
+
+export const DEFAULT_TIMEZONE = "America/New_York";
+export type FulfillmentType =
+	(typeof FULFILLMENT_TYPES)[keyof typeof FULFILLMENT_TYPES];
+
+export const DEFAULT_GAP_IN_MINUTES = 15;
+export const DEFAULT_PREP_TIME_IN_MINUTES = 5;
+
+/**
+ * Prep time behaviour when computing first available slot.
+ */
+export const PrepTimeBehaviour = Object.freeze({
+	FIRST_SHIFT: 0,
+	EVERY_SHIFT: 1,
+	ROLL_FROM_FIRST_SHIFT: 2,
+});
+
+export type PrepTimeBehaviourType =
+	(typeof PrepTimeBehaviour)[keyof typeof PrepTimeBehaviour];
+
+export const PREP_TIME_CADENCE = {
+	MINUTE: "minute",
+	DAY: "day",
+	HOUR: "hour",
+} as const;
+
+export type PrepTimeCadence =
+	(typeof PREP_TIME_CADENCE)[keyof typeof PREP_TIME_CADENCE];
+
+/**
+ * Platform for timezone handling (web uses @date-fns/tz; ios/android use timezone-support).
+ */
+export const PLATFORM = {
+	WEB: "web",
+	IOS: "ios",
+	ANDROID: "android",
+} as const;

package/src/index.ts

@@ -0,0 +1,23 @@
+export type { FulfillmentType, PrepTimeBehaviourType } from "./constants";
+export {
+	DEFAULT_GAP_IN_MINUTES,
+	DEFAULT_PREP_TIME_IN_MINUTES,
+	FULFILLMENT_TYPES,
+	PLATFORM,
+	PrepTimeBehaviour,
+} from "./constants";
+export { getSchedules } from "./schedule/get-schedules";
+export * from "./types";
+export { getLocationsBusinessHoursOverrides } from "./utils/business-hours";
+export { getCateringPrepTimeConfig } from "./utils/catering";
+export {
+	getPreSalePickupDates,
+	isTodayInTimeZone,
+	isTomorrowInTimeZone,
+	overrideTimeZoneOnUTC,
+} from "./utils/date";
+export {
+	filterBusyTimesFromSchedule,
+	filterMenusFromSchedule,
+} from "./utils/schedule-filter";
+export { getOpeningClosingTime } from "./utils/store-hours";

package/src/schedule/available-dates.ts

@@ -0,0 +1,129 @@
+import { tz } from "@date-fns/tz";
+import { isAfter, isSameDay, startOfDay } from "date-fns";
+import { findTimeZone, getUnixTime, getZonedTime } from "timezone-support";
+
+import { PLATFORM } from "../constants";
+import type { GetNextAvailableDatesParams, Platform } from "../types";
+import { addDaysInTimeZone, setHmOnDate } from "../utils/date";
+
+function getStartOfDayInZone(
+	startDate: Date,
+	timeZone: string,
+	platform: Platform,
+): Date {
+	if (platform !== PLATFORM.ANDROID) {
+		return startOfDay(startDate, { in: tz(timeZone) });
+	}
+	const zoned = getZonedTime(startDate, findTimeZone(timeZone));
+	return new Date(
+		getUnixTime({
+			...zoned,
+			hours: 0,
+			minutes: 0,
+			seconds: 0,
+			milliseconds: 0,
+		}),
+	);
+}
+
+export function getNextAvailableDates({
+	startDate,
+	timeZone,
+	businessHours,
+	businessHoursOverrides = [],
+	datesCount = 1,
+	preSaleDates = [],
+	presalePickupWeekDays = [],
+	endDate = null,
+	isDaysCadence = false,
+	platform = PLATFORM.WEB,
+}: GetNextAvailableDatesParams): Date[] {
+	const startOfDayInZone = getStartOfDayInZone(startDate, timeZone, platform);
+	const zonedStartTime = getZonedTime(startOfDayInZone, findTimeZone(timeZone));
+
+	const dates: Date[] = [];
+
+	for (
+		let date = new Date(
+				getUnixTime({
+					...zonedStartTime,
+					hours: 0,
+					minutes: 0,
+					seconds: 0,
+					milliseconds: 0,
+				}),
+			),
+			maxRuns = 0;
+		dates.length < datesCount && maxRuns <= 30;
+		date = addDaysInTimeZone(date, 1, timeZone), maxRuns += 1
+	) {
+		const lastDate = dates?.at(-1);
+		if (lastDate && isSameDay(lastDate, date)) {
+			continue;
+		}
+
+		if (endDate && isAfter(date, endDate)) {
+			break;
+		}
+
+		if (date.getTime() < getUnixTime(zonedStartTime)) {
+			continue;
+		}
+
+		const zonedDate = getZonedTime(date, findTimeZone(timeZone));
+		const dayOfWeek = zonedDate.dayOfWeek ?? 0;
+
+		const todayBusinessHoursOverride = businessHoursOverrides.filter(
+			(override) =>
+				zonedDate.month === override.month && zonedDate.day === override.day,
+		);
+
+		const closedBusinessHoursOverride = todayBusinessHoursOverride.filter(
+			(override) => !override.startTime && !override.endTime,
+		);
+
+		if (closedBusinessHoursOverride.length) {
+			continue;
+		}
+
+		const todayBusinessHours = businessHours.filter(
+			(bh) => bh.day === dayOfWeek,
+		);
+		// If days cadence, we dont need to skip date even if it is after the last shift end time
+		if (isDaysCadence) {
+			const lastShiftEndTime = todayBusinessHours.at(-1)?.endTime;
+			const shiftEndDate = lastShiftEndTime
+				? setHmOnDate(date, lastShiftEndTime, timeZone)
+				: null;
+			/**
+			 * Skip current date if current time is after the last shift end time
+			 */
+			if (shiftEndDate && isAfter(startDate, shiftEndDate)) {
+				continue;
+			}
+		}
+		/**
+		 * Skip if today is closed by location hours or by override hours
+		 */
+		if (
+			!todayBusinessHours?.length &&
+			!todayBusinessHoursOverride.length &&
+			!endDate
+		) {
+			continue;
+		}
+
+		if (preSaleDates.length && presalePickupWeekDays.length) {
+			if (
+				preSaleDates.includes(zonedDate.day) &&
+				presalePickupWeekDays.includes(dayOfWeek)
+			) {
+				dates.push(date);
+			}
+		} else {
+			dates.push(date);
+		}
+	}
+
+	return dates;
+}

package/src/schedule/generate.ts

@@ -0,0 +1,276 @@
+import {
+	addMinutes,
+	compareAsc,
+	eachMinuteOfInterval,
+	isAfter,
+	isBefore,
+	max,
+} from "date-fns";
+import { findTimeZone, getZonedTime } from "timezone-support";
+import type { PrepTimeBehaviourType } from "../constants";
+import {
+	DEFAULT_PREP_TIME_IN_MINUTES,
+	PREP_TIME_CADENCE,
+	PrepTimeBehaviour,
+} from "../constants";
+import type {
+	BusinessHour,
+	BusinessHoursOverrideOutput,
+	DaySchedule,
+	GenerateScheduleParams,
+} from "../types";
+import {
+	isTodayInTimeZone,
+	isZeroPrepTimeForMidnightShift,
+	setHmOnDate,
+} from "../utils/date";
+
+// ── Private helpers ─────────────────────────────────────────────────────────
+
+interface GetSelectedBusinessHoursParams {
+	businessHours?: BusinessHour[];
+	businessHoursOverrides?: BusinessHoursOverrideOutput[];
+	date?: Date;
+	timeZone?: string;
+	preSaleHoursOverride?: Array<{
+		startTime: string;
+		endTime: string;
+		month?: number;
+		day?: number;
+	}> | null;
+}
+
+function getSelectedBusinessHours({
+	businessHours = [],
+	businessHoursOverrides = [],
+	date,
+	timeZone,
+	preSaleHoursOverride,
+}: GetSelectedBusinessHoursParams): [
+	BusinessHour[],
+	ReturnType<typeof getZonedTime>,
+] {
+	if (!date || !timeZone) {
+		return [[], getZonedTime(new Date(), findTimeZone(timeZone ?? "UTC"))];
+	}
+
+	const zonedDate = getZonedTime(date, findTimeZone(timeZone));
+	const dayOfWeek = zonedDate.dayOfWeek ?? 0;
+
+	const dayBusinessHours = businessHours?.filter((bh) => bh.day === dayOfWeek);
+
+	const businessHoursOverride = businessHoursOverrides?.filter(
+		(override) =>
+			zonedDate.month === override.month && zonedDate.day === override.day,
+	);
+
+	const selectedBusinessHours: BusinessHour[] = preSaleHoursOverride
+		? preSaleHoursOverride.map((o) => ({
+				day: dayOfWeek,
+				startTime: o.startTime,
+				endTime: o.endTime,
+			}))
+		: businessHoursOverride.length
+			? businessHoursOverride.map((o) => ({
+					day: dayOfWeek,
+					startTime: o.startTime ?? "00:00",
+					endTime: o.endTime ?? "23:59",
+				}))
+			: (dayBusinessHours ?? []);
+
+	return [selectedBusinessHours, zonedDate];
+}
+
+// ── Public API ──────────────────────────────────────────────────────────────
+
+export function generateSchedule({
+	currentDate = new Date(),
+	prepTimeBehaviour = PrepTimeBehaviour.ROLL_FROM_FIRST_SHIFT,
+	weekDayPrepTimes = {},
+	timeZone,
+	dates = [],
+	businessHours = [],
+	businessHoursOverrides = [],
+	preSaleHoursOverride,
+	gapInMinutes = 15,
+	prepTimeCadence = null,
+}: GenerateScheduleParams): DaySchedule[] {
+	const isMinutesCadence = prepTimeCadence === PREP_TIME_CADENCE.MINUTE;
+	let shiftStartDateWithPrepTime: Date | null = null;
+	return dates
+		.map((date, index) => {
+			const lastDate = dates?.[index - 1];
+
+			const [selectedBusinessHours, zonedDate] = getSelectedBusinessHours({
+				businessHours,
+				businessHoursOverrides,
+				date,
+				timeZone,
+				preSaleHoursOverride,
+			});
+
+			const [prevSelectedBusinessHours] = getSelectedBusinessHours({
+				businessHours,
+				businessHoursOverrides,
+				date: lastDate,
+				timeZone,
+				preSaleHoursOverride,
+			});
+
+			const weekDayPrepTime =
+				weekDayPrepTimes[zonedDate.dayOfWeek] ?? DEFAULT_PREP_TIME_IN_MINUTES;
+
+			const storeTimes = {
+				openingTime: null as Date | null,
+				closingTime: null as Date | null,
+				remainingShifts: 0,
+				totalShifts: 0,
+			};
+
+			let isPrevDayMidnightTransition = false;
+
+			const slots = selectedBusinessHours
+				.flatMap((businessHour, i) => {
+					const startDate = setHmOnDate(date, businessHour.startTime, timeZone);
+					const shiftStartDate =
+						isMinutesCadence && shiftStartDateWithPrepTime
+							? max([shiftStartDateWithPrepTime, startDate])
+							: startDate;
+					const shiftEndDate = setHmOnDate(
+						date,
+						businessHour.endTime,
+						timeZone,
+					);
+
+					if (i === 0) {
+						storeTimes.openingTime = shiftStartDate;
+					}
+
+					if (i === selectedBusinessHours.length - 1) {
+						storeTimes.closingTime = shiftEndDate;
+					}
+
+					if (!isBefore(shiftStartDate, shiftEndDate)) {
+						if (isMinutesCadence) {
+							shiftStartDateWithPrepTime = null;
+						}
+						return [];
+					}
+
+					storeTimes.totalShifts += 1;
+
+					const fixedSlots = eachMinuteOfInterval(
+						{ start: shiftStartDate, end: shiftEndDate },
+						{ step: gapInMinutes },
+					);
+
+					if (isTodayInTimeZone(date, timeZone)) {
+						const openingTime = storeTimes.openingTime ?? new Date(0);
+						const baseDate =
+							currentDate instanceof Date ? currentDate : new Date(currentDate);
+						const currentDateWithPrepTime = addMinutes(
+							new Date(Math.max(baseDate.getTime(), openingTime.getTime())),
+							Math.max(DEFAULT_PREP_TIME_IN_MINUTES, weekDayPrepTime),
+						);
+
+						if (isAfter(currentDateWithPrepTime, shiftEndDate)) {
+							// If the prep time cadence is minutes, we need to set the shift start date with the prep time
+							if (isMinutesCadence) {
+								shiftStartDateWithPrepTime = currentDateWithPrepTime;
+							}
+							return [];
+						}
+
+						if (isBefore(currentDateWithPrepTime, shiftStartDate)) {
+							storeTimes.remainingShifts += 1;
+
+							if (
+								(prepTimeBehaviour as PrepTimeBehaviourType) ===
+								PrepTimeBehaviour.EVERY_SHIFT
+							) {
+								const shiftStartDateWithPrepTime = addMinutes(
+									shiftStartDate,
+									weekDayPrepTime,
+								);
+
+								const slotDates = fixedSlots.filter((d) =>
+									isAfter(d, shiftStartDateWithPrepTime),
+								);
+
+								slotDates.unshift(shiftStartDateWithPrepTime);
+								return slotDates;
+							}
+
+							return fixedSlots;
+						}
+
+						const slotDates = fixedSlots.filter((d) =>
+							isAfter(d, currentDateWithPrepTime),
+						);
+
+						slotDates.unshift(currentDateWithPrepTime);
+						storeTimes.remainingShifts += 1;
+						return slotDates;
+					}
+
+					if (prepTimeBehaviour === PrepTimeBehaviour.FIRST_SHIFT && i !== 0) {
+						storeTimes.remainingShifts += 1;
+						return fixedSlots;
+					}
+
+					const allowZeroPrepTimeForMidnightShift =
+						isZeroPrepTimeForMidnightShift({
+							prevDayBusinessHours: prevSelectedBusinessHours,
+							businessHour,
+						});
+
+					const prepTimeSlot = addMinutes(
+						prepTimeBehaviour === PrepTimeBehaviour.ROLL_FROM_FIRST_SHIFT &&
+							!isPrevDayMidnightTransition &&
+							storeTimes.openingTime
+							? storeTimes.openingTime
+							: shiftStartDate,
+						allowZeroPrepTimeForMidnightShift ? 0 : weekDayPrepTime,
+					);
+
+					isPrevDayMidnightTransition = allowZeroPrepTimeForMidnightShift;
+
+					if (prepTimeSlot > shiftEndDate) {
+						if (isMinutesCadence) {
+							shiftStartDateWithPrepTime = prepTimeSlot;
+						}
+						shiftStartDateWithPrepTime = prepTimeSlot;
+						return [];
+					}
+
+					if (prepTimeSlot < shiftStartDate) {
+						storeTimes.remainingShifts += 1;
+						return fixedSlots;
+					}
+
+					const slotDates = fixedSlots.filter((d) => isAfter(d, prepTimeSlot));
+
+					slotDates.unshift(prepTimeSlot);
+					storeTimes.remainingShifts += 1;
+					shiftStartDateWithPrepTime = null; //reset the shift start date with prep time
+					return slotDates;
+				})
+				.sort(compareAsc);
+
+			const currentDateMs =
+				currentDate instanceof Date ? currentDate.getTime() : currentDate;
+			const availableSlots = slots.filter((d) => d.getTime() >= currentDateMs);
+
+			return {
+				date,
+				originalStoreOpeningTime: storeTimes.openingTime,
+				originalStoreClosingTime: storeTimes.closingTime,
+				remainingShifts: storeTimes.remainingShifts,
+				openingTime: slots[0],
+				closingTime: slots[slots.length - 1],
+				firstAvailableSlot: availableSlots[0],
+				slots: availableSlots,
+			};
+		})
+		.filter((a) => a.slots.length);
+}