@perdieminc/time-slots 0.0.1 → 0.0.3

package/src/schedule/generate.ts

@@ -1,276 +0,0 @@
-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);
-}

package/src/schedule/get-schedules.ts

@@ -1,264 +0,0 @@
-import { differenceInDays } from "date-fns";
-import {
-	DEFAULT_TIMEZONE,
-	FULFILLMENT_TYPES,
-	PLATFORM,
-	PREP_TIME_CADENCE,
-} from "../constants";
-import type {
-	CartItem,
-	FulfillmentSchedule,
-	GetSchedulesParams,
-	GetSchedulesResult,
-	PrepTimeSettings,
-	PreSaleConfig,
-} from "../types";
-import { getLocationsBusinessHoursOverrides } from "../utils/business-hours";
-import { getCateringPrepTimeConfig } from "../utils/catering";
-import { getPreSalePickupDates, overrideTimeZoneOnUTC } from "../utils/date";
-import { filterBusyTimesFromSchedule } from "../utils/schedule-filter";
-import { generateLocationFulfillmentSchedule } from "./location";
-
-// ── Helpers ─────────────────────────────────────────────────────────────────
-
-function deriveCartInfo(cartItems: CartItem[]) {
-	return {
-		hasPreSaleItem: cartItems.some((item) => item.preSale),
-		hasWeeklyPreSaleItem: cartItems.some((item) => item.weeklyPreSale),
-		categoryIds: Array.from(
-			new Set(
-				cartItems
-					.map((item) => item.internalCategoryId)
-					.filter((id): id is string => Boolean(id)),
-			),
-		),
-	};
-}
-
-function resolvePreSaleDates(
-	preSaleConfig: PreSaleConfig | undefined,
-	timezone: string,
-) {
-	return {
-		startDate: preSaleConfig?.due_start_date
-			? overrideTimeZoneOnUTC(preSaleConfig.due_start_date, timezone)
-			: new Date(),
-		endDate: preSaleConfig?.due_end_date
-			? overrideTimeZoneOnUTC(preSaleConfig.due_end_date, timezone)
-			: new Date(),
-	};
-}
-
-function getPreSaleHoursOverride(
-	preSaleConfig: PreSaleConfig | undefined,
-	hasPreSaleItem: boolean,
-) {
-	if (
-		preSaleConfig &&
-		!preSaleConfig.use_store_hours_due &&
-		hasPreSaleItem &&
-		preSaleConfig.due_start_time &&
-		preSaleConfig.due_end_time
-	) {
-		return [
-			{
-				startTime: preSaleConfig.due_start_time,
-				endTime: preSaleConfig.due_end_time,
-			},
-		];
-	}
-	return null;
-}
-
-function resolveStartDate(
-	zonedDueStartDate: Date,
-	hasPreSaleItem: boolean,
-): Date {
-	if (hasPreSaleItem) {
-		return new Date(Math.max(zonedDueStartDate.getTime(), Date.now()));
-	}
-	return new Date();
-}
-const WEEKDAY_KEYS = [0, 1, 2, 3, 4, 5, 6] as const;
-
-function addEstimatedDeliveryToWeekDays(
-	weekDayPrepTimes: Record<number, number>,
-	estimatedDeliveryMinutes: number,
-): Record<number, number> {
-	const result: Record<number, number> = {};
-	for (const day of WEEKDAY_KEYS) {
-		result[day] = (weekDayPrepTimes[day] ?? 0) + estimatedDeliveryMinutes;
-	}
-	return result;
-}
-
-/**
- * Resolves prep time config: for catering flow uses cart-derived cadence/frequency;
- * when fulfillment is DELIVERY, adds estimatedDeliveryMinutes to all weekday prep times.
- */
-function resolvePrepTimeConfig(
-	prepTimeSettings: PrepTimeSettings,
-	cartItems: CartItem[],
-	isCateringFlow: boolean,
-	fulfillmentPreference: "PICKUP" | "DELIVERY" | "CURBSIDE",
-	timezone: string = DEFAULT_TIMEZONE,
-): PrepTimeSettings {
-	let resolved: PrepTimeSettings;
-
-	if (!isCateringFlow) {
-		const isDayCadence =
-			prepTimeSettings.prepTimeCadence === PREP_TIME_CADENCE.DAY;
-		resolved = {
-			...prepTimeSettings,
-			...(isDayCadence && { weekDayPrepTimes: {} }),
-		};
-	} else {
-		const cateringPrepTimeConfig = getCateringPrepTimeConfig({
-			items: cartItems,
-			prepTimeCadence: prepTimeSettings.prepTimeCadence,
-			prepTimeFrequency: prepTimeSettings.prepTimeFrequency,
-			timezone,
-		});
-		resolved = {
-			...prepTimeSettings,
-			...cateringPrepTimeConfig,
-		};
-	}
-	const { estimatedDeliveryMinutes = 0 } = prepTimeSettings;
-	if (
-		fulfillmentPreference === FULFILLMENT_TYPES.DELIVERY &&
-		estimatedDeliveryMinutes > 0
-	) {
-		const baseWeekDays = resolved.weekDayPrepTimes ?? {};
-		resolved = {
-			...resolved,
-			weekDayPrepTimes: addEstimatedDeliveryToWeekDays(
-				baseWeekDays,
-				prepTimeSettings.estimatedDeliveryMinutes ?? 0,
-			),
-		};
-	}
-
-	return resolved;
-}
-
-// ── Main ────────────────────────────────────────────────────────────────────
-
-export function getSchedules({
-	store,
-	locations,
-	cartItems,
-	fulfillmentPreference,
-	prepTimeSettings,
-	currentLocation,
-	isCateringFlow = false,
-	platform = PLATFORM.WEB,
-}: GetSchedulesParams): GetSchedulesResult {
-	const {
-		isAsapOrders,
-		isSameDayOrders,
-		max_future_order_days: daysCount = 7,
-		weeklyPreSaleConfig,
-		preSaleConfig,
-	} = store;
-
-	const cart = deriveCartInfo(cartItems);
-	const resolvedPrepTime = resolvePrepTimeConfig(
-		prepTimeSettings,
-		cartItems,
-		isCateringFlow,
-		fulfillmentPreference,
-		currentLocation?.timezone,
-	);
-	const {
-		gapInMinutes,
-		busyTimes: busyTimesByLocationId,
-		prepTimeFrequency,
-		prepTimeCadence,
-		weekDayPrepTimes,
-	} = resolvedPrepTime;
-
-	const busyTimes = busyTimesByLocationId?.[currentLocation.location_id] ?? [];
-
-	const businessHoursOverrides =
-		getLocationsBusinessHoursOverrides(store.businessHoursOverrides, locations)[
-			currentLocation.location_id
-		] ?? [];
-
-	const filterSchedule = (schedule: FulfillmentSchedule) =>
-		filterBusyTimesFromSchedule({
-			schedule,
-			busyTimes,
-			cartCategoryIds: cart.categoryIds,
-		});
-
-	// ── Weekly pre-sale path (early return) ─────────────────────────────────
-	if (
-		cart.hasWeeklyPreSaleItem &&
-		weeklyPreSaleConfig?.active &&
-		!isCateringFlow
-	) {
-		const weeklyPickupDates = getPreSalePickupDates(
-			weeklyPreSaleConfig?.pickup_days,
-			weeklyPreSaleConfig?.ordering_days,
-		);
-
-		if (weeklyPickupDates.length > 0) {
-			const schedule = generateLocationFulfillmentSchedule({
-				startDate: weeklyPickupDates[0],
-				location: currentLocation,
-				fulfillmentPreference,
-				businessHoursOverrides,
-				gapInMinutes,
-				daysCount: 7,
-				preSaleDates: weeklyPickupDates.map((d) => d.getDate()),
-				presalePickupWeekDays: weeklyPreSaleConfig.pickup_days,
-				platform,
-			});
-
-			return {
-				schedule: filterSchedule(schedule),
-				isWeeklyPreSaleAvailable: true,
-			};
-		}
-	}
-
-	// ── Main schedule path ──────────────────────────────────────────────────
-	const isPreSaleEnabled =
-		(preSaleConfig?.active ?? false) && cart.hasPreSaleItem && !isCateringFlow;
-	const preSaleDates = resolvePreSaleDates(
-		preSaleConfig,
-		currentLocation.timezone,
-	);
-	const preSaleHoursOverride = getPreSaleHoursOverride(
-		preSaleConfig,
-		cart.hasPreSaleItem,
-	);
-
-	const schedule = generateLocationFulfillmentSchedule({
-		startDate: resolveStartDate(preSaleDates.startDate, cart.hasPreSaleItem),
-		prepTimeFrequency,
-		prepTimeCadence,
-		location: currentLocation,
-		fulfillmentPreference,
-		businessHoursOverrides,
-		gapInMinutes,
-		daysCount: isPreSaleEnabled
-			? differenceInDays(preSaleDates.endDate, preSaleDates.startDate) + 1
-			: !isAsapOrders && !isSameDayOrders
-				? daysCount
-				: 1,
-		platform,
-
-		...(!isPreSaleEnabled && {
-			weekDayPrepTimes,
-		}),
-		...(preSaleHoursOverride && { preSaleHoursOverride }),
-		...(isPreSaleEnabled && { endDate: preSaleDates.endDate }),
-	});
-
-	return {
-		schedule: filterSchedule(schedule),
-		isWeeklyPreSaleAvailable: false,
-	};
-}

package/src/schedule/location.ts

@@ -1,58 +0,0 @@
-import { roundToNearestMinutes } from "date-fns";
-import { PLATFORM, PREP_TIME_CADENCE } from "../constants";
-import type {
-	FulfillmentSchedule,
-	GenerateLocationFulfillmentScheduleParams,
-} from "../types";
-import { getLocationBusinessHoursForFulfillment } from "../utils/business-hours";
-import { getNextAvailableDates } from "./available-dates";
-import { generateSchedule } from "./generate";
-
-export function generateLocationFulfillmentSchedule({
-	startDate,
-	prepTimeFrequency = 0,
-	prepTimeCadence = PREP_TIME_CADENCE.MINUTE,
-	weekDayPrepTimes,
-	location,
-	fulfillmentPreference,
-	businessHoursOverrides = [],
-	preSaleHoursOverride,
-	gapInMinutes,
-	daysCount = 1,
-	preSaleDates = [],
-	presalePickupWeekDays = [],
-	endDate = null,
-	platform = PLATFORM.WEB,
-}: GenerateLocationFulfillmentScheduleParams): FulfillmentSchedule {
-	const isDaysCadence = prepTimeCadence === PREP_TIME_CADENCE.DAY;
-	const businessHours = getLocationBusinessHoursForFulfillment(
-		location,
-		fulfillmentPreference,
-	);
-
-	const dates = getNextAvailableDates({
-		startDate,
-		businessHours,
-		businessHoursOverrides,
-		timeZone: location.timezone,
-		datesCount: daysCount,
-		preSaleDates,
-		endDate,
-		presalePickupWeekDays,
-		isDaysCadence,
-		platform,
-	});
-	// If prepTimeCadence is days, we need to skip opening days by prepTimeFrequency
-	const availableDates = isDaysCadence ? dates.slice(prepTimeFrequency) : dates;
-	return generateSchedule({
-		currentDate: roundToNearestMinutes(startDate),
-		weekDayPrepTimes,
-		timeZone: location.timezone,
-		dates: availableDates,
-		businessHours,
-		businessHoursOverrides,
-		preSaleHoursOverride,
-		gapInMinutes,
-		prepTimeCadence,
-	});
-}

package/src/types/business-hours.d.ts

@@ -1,32 +0,0 @@
-/** Raw business-hour record from the API (snake_case keys). */
-export interface BusinessHourInput {
-	day: number;
-	start_time: string;
-	end_time: string;
-}
-
-/** Normalised business-hour used internally (camelCase keys). */
-export interface BusinessHour {
-	day: number;
-	startTime: string;
-	endTime: string;
-}
-
-/** Raw business-hours override coming from the API. */
-export interface BusinessHoursOverrideInput {
-	all_locations?: boolean;
-	location_ids?: string[];
-	month: number;
-	day: number;
-	start_time: string | null;
-	end_time: string | null;
-	is_open?: boolean;
-}
-
-/** Normalised business-hours override. */
-export interface BusinessHoursOverrideOutput {
-	month: number;
-	day: number;
-	startTime: string | null;
-	endTime: string | null;
-}

package/src/types/common.d.ts

@@ -1,5 +0,0 @@
-export interface BusyTimeItem {
-	startTime: string;
-	endTime: string;
-	threshold?: { categoryIds?: string[] };
-}