@perdieminc/time-slots 0.0.1

package/src/utils/business-hours.ts

@@ -0,0 +1,120 @@
+import { FULFILLMENT_TYPES } from "../constants";
+import type {
+	BusinessHour,
+	BusinessHoursOverrideInput,
+	BusinessHoursOverrideOutput,
+	FulfillmentPreference,
+	LocationLike,
+} from "../types";
+
+export function toBusinessHoursOverride(
+	businessHoursOverride: BusinessHoursOverrideInput,
+): BusinessHoursOverrideOutput {
+	const {
+		month,
+		day,
+		start_time: startTime,
+		end_time: endTime,
+		is_open: isOpen,
+	} = businessHoursOverride;
+
+	return {
+		month,
+		day,
+		startTime: isOpen ? startTime : null,
+		endTime: isOpen ? endTime : null,
+	};
+}
+
+export function getLocationsBusinessHoursOverrides(
+	businessHoursOverrides: BusinessHoursOverrideInput[],
+	locations: LocationLike[],
+): Record<string, BusinessHoursOverrideOutput[]> {
+	const result: Record<string, BusinessHoursOverrideOutput[]> = {};
+
+	for (const override of businessHoursOverrides) {
+		const { all_locations: allLocations, location_ids: locationIds } =
+			override || {};
+
+		if (allLocations === true) {
+			for (const location of locations || []) {
+				const id = location.location_id;
+				result[id] ??= [];
+				result[id].push(toBusinessHoursOverride(override));
+			}
+		} else {
+			for (const id of locationIds || []) {
+				const location = locations.find((loc) => loc.location_id === id);
+				if (location) {
+					result[id] ??= [];
+					result[id].push(toBusinessHoursOverride(override));
+				}
+			}
+		}
+	}
+
+	return result;
+}
+
+export const isLocationCateringEnabled = (
+	location: LocationLike | undefined,
+): boolean => {
+	if (!location) return false;
+	return (
+		!!location?.catering?.enabled && location?.catering?.enabled !== "false"
+	);
+};
+
+export function getLocationBusinessHoursForFulfillment(
+	location: LocationLike,
+	fulfillmentPreference: FulfillmentPreference,
+	isCatering = false,
+): BusinessHour[] {
+	const fulfillmentBusinessHours: Record<
+		string,
+		Array<{ day: number; start_time: string; end_time: string }> | undefined
+	> = {
+		[FULFILLMENT_TYPES.PICKUP]: location?.pickup_hours,
+		[FULFILLMENT_TYPES.DELIVERY]: location?.delivery_hours,
+		[FULFILLMENT_TYPES.CURBSIDE]: location?.curbside_hours?.use_pickup_hours
+			? location?.pickup_hours
+			: location?.curbside_hours?.times,
+	};
+
+	const cateringBusinessTimings: Partial<
+		Record<FulfillmentPreference, { start_time: string; end_time: string }>
+	> = {
+		[FULFILLMENT_TYPES.PICKUP]: location?.catering?.pickup,
+		[FULFILLMENT_TYPES.DELIVERY]: location?.catering?.delivery,
+	};
+
+	const businessHours = fulfillmentBusinessHours[fulfillmentPreference];
+
+	const cateringBusinessTiming =
+		isCatering && isLocationCateringEnabled(location)
+			? cateringBusinessTimings[fulfillmentPreference]
+			: null;
+
+	if (isCatering && !cateringBusinessTiming) {
+		//if catering is enabled but no business hours are set, return empty arrayif
+		return [];
+	}
+
+	return (
+		businessHours?.map((businessHour) => {
+			if (isCatering && cateringBusinessTiming) {
+				//if catering is enabled and catering business hours are set, return catering business hours
+				return {
+					day: businessHour.day,
+					startTime: cateringBusinessTiming.start_time,
+					endTime: cateringBusinessTiming.end_time,
+				};
+			}
+			return {
+				day: businessHour.day,
+				startTime: businessHour.start_time,
+				endTime: businessHour.end_time,
+			};
+		}) ?? []
+	);
+}

package/src/utils/catering.ts

@@ -0,0 +1,85 @@
+import { findTimeZone, getZonedTime } from "timezone-support";
+import { DEFAULT_TIMEZONE, PREP_TIME_CADENCE } from "../constants";
+import type {
+	CateringPrepTimeResult,
+	GetCateringPrepTimeParams,
+} from "../types";
+
+function buildCateringPrepTimeResult(
+	prepTimeCadence: CateringPrepTimeResult["prepTimeCadence"],
+	prepTimeFrequency: number,
+	timezone: string = DEFAULT_TIMEZONE,
+): CateringPrepTimeResult {
+	const result: CateringPrepTimeResult = {
+		prepTimeCadence,
+		prepTimeFrequency,
+	};
+	if (prepTimeCadence === PREP_TIME_CADENCE.DAY) {
+		result.weekDayPrepTimes = {};
+	} else {
+		result.weekDayPrepTimes = {
+			[getZonedTime(new Date(), findTimeZone(timezone)).dayOfWeek]:
+				prepTimeCadence === PREP_TIME_CADENCE.HOUR
+					? prepTimeFrequency * 60
+					: prepTimeFrequency,
+		};
+	}
+	return result;
+}
+
+/**
+ * Derives prep time config (cadence, frequency, weekDayPrepTimes) from cart items for catering flow.
+ * DAY cadence has priority; if any item uses days, returns max day frequency.
+ * Otherwise returns HOUR cadence with max hour frequency across items.
+ * When items are empty or have no catering prep time, falls back to params (e.g. from prepTimeSettings).
+ */
+export function getCateringPrepTimeConfig(
+	params: GetCateringPrepTimeParams,
+): CateringPrepTimeResult {
+	const { items, timezone = DEFAULT_TIMEZONE } = params;
+
+	if (items.length === 0) {
+		return buildCateringPrepTimeResult(
+			params.prepTimeCadence ?? PREP_TIME_CADENCE.HOUR,
+			params.prepTimeFrequency ?? 1,
+			timezone,
+		);
+	}
+
+	const dayFrequencies: number[] = [];
+	const hourFrequencies: number[] = [];
+
+	for (const item of items) {
+		const cadence = item.cateringService?.prep_time?.cadence;
+		const frequency = item.cateringService?.prep_time?.frequency;
+		if (cadence == null || frequency == null) continue;
+
+		if (cadence === PREP_TIME_CADENCE.DAY) {
+			dayFrequencies.push(frequency);
+		} else if (cadence === PREP_TIME_CADENCE.HOUR) {
+			hourFrequencies.push(frequency);
+		}
+	}
+
+	if (dayFrequencies.length > 0) {
+		return buildCateringPrepTimeResult(
+			PREP_TIME_CADENCE.DAY,
+			Math.max(...dayFrequencies),
+			timezone,
+		);
+	}
+
+	if (hourFrequencies.length > 0) {
+		return buildCateringPrepTimeResult(
+			PREP_TIME_CADENCE.HOUR,
+			Math.max(...hourFrequencies),
+			timezone,
+		);
+	}
+
+	return buildCateringPrepTimeResult(
+		params.prepTimeCadence ?? PREP_TIME_CADENCE.HOUR,
+		params.prepTimeFrequency ?? 1,
+		timezone,
+	);
+}

package/src/utils/date.ts

@@ -0,0 +1,163 @@
+import { addDays, compareAsc } from "date-fns";
+import { findTimeZone, getUnixTime, getZonedTime } from "timezone-support";
+
+import type { BusinessHour } from "../types";
+
+export function setHmOnDate(date: Date, hm: string, timeZone: string): Date {
+	const [hours, minutes] = String(hm).split(":");
+
+	const zonedTime = getZonedTime(new Date(date), findTimeZone(timeZone));
+
+	return new Date(
+		getUnixTime({
+			zone: zonedTime.zone,
+			year: zonedTime.year,
+			month: zonedTime.month,
+			day: zonedTime.day,
+			hours: hours === "24" ? 23 : Number(hours),
+			minutes: hours === "24" ? 59 : Number(minutes),
+			seconds: 0,
+			milliseconds: 0,
+		}),
+	);
+}
+
+export function getNextDateForDayOfWeek(
+	targetDayIndex: number,
+	referenceDate: Date = new Date(),
+): Date {
+	const currentDayIndex = referenceDate.getDay();
+	const daysUntilTarget = (targetDayIndex - currentDayIndex + 7) % 7;
+	return addDays(referenceDate, daysUntilTarget);
+}
+
+export function getPreSalePickupDates(
+	preSalePickupDays: number[] = [],
+	preSaleOrderingDays: number[] = [],
+): Date[] {
+	const today = new Date();
+	const currentDayIndex = today.getDay();
+
+	if (preSalePickupDays.includes(currentDayIndex)) {
+		return [];
+	}
+
+	if (!preSaleOrderingDays.includes(currentDayIndex)) {
+		return [];
+	}
+
+	return preSalePickupDays
+		.map((day) => getNextDateForDayOfWeek(day))
+		.sort(compareAsc);
+}
+
+export function overrideTimeZoneOnUTC(
+	date: Date | string,
+	timeZoneB: string,
+): Date {
+	const timeZoneATime = getZonedTime(new Date(date), findTimeZone("UTC"));
+	const timeZoneBTime = getZonedTime(new Date(date), findTimeZone(timeZoneB));
+
+	return new Date(
+		getUnixTime({
+			...timeZoneATime,
+			zone: timeZoneBTime.zone,
+		}),
+	);
+}
+
+export function isTodayInTimeZone(date: Date, timeZone: string): boolean {
+	if (!date) {
+		return false;
+	}
+	const zonedNow = getZonedTime(Date.now(), findTimeZone(timeZone));
+	const zonedTime = getZonedTime(date, findTimeZone(timeZone));
+
+	return zonedNow.day === zonedTime.day && zonedNow.month === zonedTime.month;
+}
+
+export function isTomorrowInTimeZone(date: Date, timeZone: string): boolean {
+	const zonedNow = getZonedTime(addDays(Date.now(), 1), findTimeZone(timeZone));
+	const zonedTime = getZonedTime(date, findTimeZone(timeZone));
+
+	return zonedNow.day === zonedTime.day && zonedNow.month === zonedTime.month;
+}
+
+export function isSameDateInTimeZone(
+	dateLeft: Date,
+	dateRight: Date,
+	timeZone: string,
+): boolean {
+	const zonedDateLeft = getZonedTime(dateLeft, findTimeZone(timeZone));
+	const zonedDateRight = getZonedTime(dateRight, findTimeZone(timeZone));
+
+	return (
+		zonedDateLeft.year === zonedDateRight.year &&
+		zonedDateLeft.month === zonedDateRight.month &&
+		zonedDateLeft.day === zonedDateRight.day
+	);
+}
+
+export function isMidnightTransition(
+	endDate: Date,
+	startDateNextDay: Date,
+	timeZone: string,
+): boolean {
+	if (!endDate || !startDateNextDay) {
+		return false;
+	}
+	const zonedEndDate = getZonedTime(endDate, findTimeZone(timeZone));
+	const zonedStartDate = getZonedTime(startDateNextDay, findTimeZone(timeZone));
+
+	return (
+		zonedEndDate.hours === 23 &&
+		zonedEndDate.minutes === 59 &&
+		zonedStartDate.hours === 0 &&
+		zonedStartDate.minutes === 0
+	);
+}
+
+export function addDaysInTimeZone(
+	date: Date,
+	days: number,
+	timeZone: string,
+): Date {
+	const zonedTime = getZonedTime(addDays(date, days), findTimeZone(timeZone));
+	return new Date(
+		getUnixTime({
+			...zonedTime,
+			hours: 0,
+			minutes: 0,
+			seconds: 0,
+			milliseconds: 0,
+		}),
+	);
+}
+
+export function isZeroPrepTimeForMidnightShift({
+	prevDayBusinessHours,
+	businessHour,
+}: {
+	prevDayBusinessHours: BusinessHour[];
+	businessHour: BusinessHour;
+}): boolean {
+	if (
+		!Array.isArray(prevDayBusinessHours) ||
+		prevDayBusinessHours.length === 0
+	) {
+		return false;
+	}
+
+	if (!businessHour || businessHour.startTime !== "00:00") {
+		return false;
+	}
+
+	const currentDay = businessHour.day;
+	const prevDay = (currentDay + 6) % 7;
+
+	const prevDayHas24End = prevDayBusinessHours.some(
+		(bh) =>
+			bh.day === prevDay && (bh.endTime === "24:00" || bh.endTime === "23:59"),
+	);
+	return prevDayHas24End;
+}

package/src/utils/schedule-filter.ts

@@ -0,0 +1,140 @@
+import { findTimeZone, getZonedTime } from "timezone-support";
+
+import type {
+	BusyTimeItem,
+	FilterBusyTimesFromScheduleParams,
+	FulfillmentSchedule,
+	MenuType,
+} from "../types";
+import { isTimeInRange } from "./time";
+
+// ── Private helpers ─────────────────────────────────────────────────────────
+
+function isSlotBusy(
+	applicableBusyTimes: BusyTimeItem[],
+	slotTimeValue: Date | number,
+): boolean {
+	const slotTime = new Date(slotTimeValue);
+
+	if (Number.isNaN(slotTime.getTime())) {
+		return false;
+	}
+
+	return applicableBusyTimes.some((busyTime) => {
+		const busyStart = new Date(busyTime?.startTime);
+		const busyEnd = new Date(busyTime?.endTime);
+
+		if (Number.isNaN(busyStart.getTime()) || Number.isNaN(busyEnd.getTime())) {
+			return false;
+		}
+
+		return slotTime > busyStart && slotTime <= busyEnd;
+	});
+}
+
+// ── Public API ──────────────────────────────────────────────────────────────
+
+export function filterBusyTimesFromSchedule({
+	schedule = [],
+	busyTimes = [],
+	cartCategoryIds = [],
+}: FilterBusyTimesFromScheduleParams): FulfillmentSchedule {
+	if (!Array.isArray(schedule) || schedule.length === 0) {
+		return [];
+	}
+
+	if (!Array.isArray(busyTimes) || busyTimes.length === 0) {
+		return schedule;
+	}
+
+	const uniqueCartCategoryIds = Array.isArray(cartCategoryIds)
+		? Array.from(new Set(cartCategoryIds.filter(Boolean)))
+		: [];
+
+	const applicableBusyTimes = busyTimes.filter((busyTime) => {
+		const thresholdCategoryIds = busyTime?.threshold?.categoryIds || [];
+
+		if (!thresholdCategoryIds.length) {
+			return true;
+		}
+
+		if (!uniqueCartCategoryIds.length) {
+			return false;
+		}
+
+		return uniqueCartCategoryIds.some((cartCategoryId) =>
+			thresholdCategoryIds.includes(cartCategoryId),
+		);
+	});
+
+	if (!applicableBusyTimes.length) {
+		return schedule;
+	}
+
+	return schedule
+		.map((daySchedule) => {
+			const slots = Array.isArray(daySchedule?.slots) ? daySchedule.slots : [];
+			const filteredSlots = slots.filter(
+				(slot) => !isSlotBusy(applicableBusyTimes, slot),
+			);
+
+			return {
+				...daySchedule,
+				slots: filteredSlots,
+				openingTime: filteredSlots[0],
+				closingTime: filteredSlots[filteredSlots.length - 1],
+				firstAvailableSlot: filteredSlots[0],
+			};
+		})
+		.filter((daySchedule) => (daySchedule?.slots || []).length > 0);
+}
+
+export function filterMenusFromSchedule({
+	schedule = [],
+	menus = [],
+	timeZone,
+}: {
+	schedule?: FulfillmentSchedule;
+	menus?: MenuType[];
+	timeZone: string;
+}): FulfillmentSchedule {
+	return schedule
+		.map((daySchedule) => ({
+			...daySchedule,
+			slots: daySchedule.slots.filter((slot) => {
+				const zonedSlot = getZonedTime(slot, findTimeZone(timeZone));
+				const dayOfWeek = zonedSlot.dayOfWeek;
+
+				if (!menus.length) {
+					return true;
+				}
+
+				return menus.some((menu) => {
+					const dayScheduleConfig = menu.times[String(dayOfWeek)];
+					if (!dayScheduleConfig) {
+						return false;
+					}
+
+					if (dayScheduleConfig.all_day) {
+						return true;
+					}
+					// Only show slot if it falls within the configured time range
+					// Check for null start_time or end_time
+					if (!dayScheduleConfig.start_time || !dayScheduleConfig.end_time) {
+						return false;
+					}
+					return isTimeInRange(
+						{
+							start_time: dayScheduleConfig.start_time,
+							end_time: dayScheduleConfig.end_time,
+						},
+						{
+							hours: Number(zonedSlot.hours),
+							minutes: Number(zonedSlot.minutes),
+						},
+					);
+				});
+			}),
+		}))
+		.filter((daySchedule) => daySchedule.slots.length > 0);
+}