@wasto/sdk 1.0.3

package/src/enums.ts

@@ -0,0 +1,298 @@
+/**
+ * Enums aligned with Prisma schema (no @prisma/client dependency).
+ * Use these in DTOs and types so the SDK can be used from browser/frontend.
+ */
+
+export enum UserRole {
+  ADMIN = 'ADMIN',
+  GESTIONNAIRE_COLLECTIVITE = 'GESTIONNAIRE_COLLECTIVITE',
+  USER = 'USER',
+}
+
+export enum CityGroupType {
+  AGGLOMERATION = 'AGGLOMERATION',
+  COMMUNAUTE = 'COMMUNAUTE',
+  METROPOLE = 'METROPOLE',
+  SYNDICAT = 'SYNDICAT',
+  AUTRE = 'AUTRE',
+}
+
+export enum CityStatus {
+  NON_ACTIF = 'NON_ACTIF',
+  INCOMPLET = 'INCOMPLET',
+  ACTIF = 'ACTIF',
+  MAINTENANCE = 'MAINTENANCE',
+}
+
+export enum RecipientGroupType {
+  CITY = 'CITY',
+  CITY_GROUP = 'CITY_GROUP',
+  ZONE = 'ZONE',
+}
+
+export enum NotificationStatus {
+  DRAFT = 'DRAFT',
+  SCHEDULED = 'SCHEDULED',
+  SENT = 'SENT',
+  ARCHIVED = 'ARCHIVED',
+}
+
+export enum NotificationDeliveryStatus {
+  PENDING = 'PENDING',
+  SENT = 'SENT',
+  FAILED = 'FAILED',
+}
+
+export enum CmsSiteType {
+  SITE = 'SITE',
+  APP = 'APP',
+}
+
+export enum CmsMenuLinkType {
+  PAGE = 'PAGE',
+  EXTERNAL = 'EXTERNAL',
+  COMPONENT = 'COMPONENT',
+}
+
+export enum ChatMessageRole {
+  USER = 'USER',
+  ASSISTANT = 'ASSISTANT',
+  AGENT = 'AGENT',
+}
+
+export enum ChatStatus {
+  OPEN = 'OPEN',
+  WAITING_AGENT = 'WAITING_AGENT',
+  RESOLVED = 'RESOLVED',
+  CLOSED = 'CLOSED',
+}
+
+export enum PermissionAction {
+  READ = 'READ',
+  WRITE = 'WRITE',
+}
+
+export enum PermissionResource {
+  USERS = 'USERS',
+  CITIES = 'CITIES',
+  CITY_GROUPS = 'CITY_GROUPS',
+  BLOG_POSTS = 'BLOG_POSTS',
+  CHALLENGES = 'CHALLENGES',
+  SERIES = 'SERIES',
+  BADGES = 'BADGES',
+  NOTIFICATIONS = 'NOTIFICATIONS',
+  RECIPIENT_GROUPS = 'RECIPIENT_GROUPS',
+  WASTE_TYPES = 'WASTE_TYPES',
+  WASTE_COLLECTION_PLACES = 'WASTE_COLLECTION_PLACES',
+  RECYCLING_POINTS = 'RECYCLING_POINTS',
+  QUIZ_QUESTIONS = 'QUIZ_QUESTIONS',
+  CHAT_CONVERSATIONS = 'CHAT_CONVERSATIONS',
+  ANALYTICS = 'ANALYTICS',
+  ASSETS = 'ASSETS',
+  IOT_DEVICES = 'IOT_DEVICES',
+  SURVEYS = 'SURVEYS',
+  TICKETS = 'TICKETS',
+  TICKET_FORMS = 'TICKET_FORMS',
+  PROVIDERS = 'PROVIDERS',
+  CMS_SITES = 'CMS_SITES',
+  CMS_PAGES = 'CMS_PAGES',
+  CMS_MEDIA = 'CMS_MEDIA',
+  CALENDO_EVENTS = 'CALENDO_EVENTS',
+  MAPSO_EVENTS = 'MAPSO_EVENTS',
+  FIELD_REPORTS = 'FIELD_REPORTS',
+}
+
+export enum TerritoryActionType {
+  AWARENESS = 'AWARENESS',
+  CONTROLS = 'CONTROLS',
+  EQUIPMENT = 'EQUIPMENT',
+  WASTO_APP = 'WASTO_APP',
+  TRAINING = 'TRAINING',
+  OTHER = 'OTHER',
+}
+
+export enum TerritoryActionStatus {
+  PLANNED = 'PLANNED',
+  IN_PROGRESS = 'IN_PROGRESS',
+  COMPLETED = 'COMPLETED',
+  CANCELLED = 'CANCELLED',
+}
+
+export enum AssetType {
+  BENNE = 'BENNE',
+  BORNE_VERRE = 'BORNE_VERRE',
+  BORNE_TEMPORAIRE = 'BORNE_TEMPORAIRE',
+  EPHEMERE = 'EPHEMERE',
+  LOCATION = 'LOCATION',
+  VEHICULE = 'VEHICULE',
+  CAMION = 'CAMION',
+}
+
+export enum AssetStatus {
+  DISPONIBLE = 'DISPONIBLE',
+  EN_LOCATION = 'EN_LOCATION',
+  EN_MAINTENANCE = 'EN_MAINTENANCE',
+  HORS_SERVICE = 'HORS_SERVICE',
+}
+
+export enum BookingStatus {
+  PENDING = 'PENDING',
+  CONFIRMED = 'CONFIRMED',
+  CANCELLED = 'CANCELLED',
+}
+
+export enum SurveyStatus {
+  DRAFT = 'DRAFT',
+  ACTIVE = 'ACTIVE',
+  ARCHIVED = 'ARCHIVED',
+}
+
+export enum SurveyMode {
+  FIELD = 'FIELD',
+  ONLINE = 'ONLINE',
+  PHONE = 'PHONE',
+}
+
+export enum QuestionType {
+  TEXT = 'TEXT',
+  NUMBER = 'NUMBER',
+  CHOICE = 'CHOICE',
+  MULTIPLE_CHOICE = 'MULTIPLE_CHOICE',
+  RATING = 'RATING',
+  DATE = 'DATE',
+  LOCATION = 'LOCATION',
+  PHOTO = 'PHOTO',
+  YES_NO = 'YES_NO',
+}
+
+export enum ResponseStatus {
+  DRAFT = 'DRAFT',
+  SUBMITTED = 'SUBMITTED',
+  SYNCED = 'SYNCED',
+}
+
+export enum TicketFormStatus {
+  DRAFT = 'DRAFT',
+  ACTIVE = 'ACTIVE',
+  ARCHIVED = 'ARCHIVED',
+}
+
+export enum TicketStatus {
+  OUVERT = 'OUVERT',
+  EN_COURS = 'EN_COURS',
+  RESOLU = 'RESOLU',
+  FERME = 'FERME',
+}
+
+export enum FieldReportFormStatus {
+  DRAFT = 'DRAFT',
+  ACTIVE = 'ACTIVE',
+  ARCHIVED = 'ARCHIVED',
+}
+
+export enum FieldReportStatus {
+  OUVERT = 'OUVERT',
+  EN_COURS = 'EN_COURS',
+  RESOLU = 'RESOLU',
+  FERME = 'FERME',
+}
+
+export enum ProviderType {
+  LOCATION_ASSETS = 'LOCATION_ASSETS',
+  ANIMATION_CHALLENGE = 'ANIMATION_CHALLENGE',
+  MAINTENANCE = 'MAINTENANCE',
+  AUTRE = 'AUTRE',
+}
+
+export enum InterventionType {
+  MAINTENANCE = 'MAINTENANCE',
+  INDISPO = 'INDISPO',
+  CONTROLE = 'CONTROLE',
+  OTHER = 'OTHER',
+}
+
+export enum InterventionStatus {
+  PLANNED = 'PLANNED',
+  IN_PROGRESS = 'IN_PROGRESS',
+  DONE = 'DONE',
+  CANCELLED = 'CANCELLED',
+}
+
+export enum AssetEventType {
+  LOCATION_CHANGE = 'LOCATION_CHANGE',
+  STATUS_CHANGE = 'STATUS_CHANGE',
+  MAINTENANCE = 'MAINTENANCE',
+  INSPECTION = 'INSPECTION',
+  OTHER = 'OTHER',
+}
+
+export enum CalendoEventType {
+  CONCERT = 'CONCERT',
+  ANIMATION = 'ANIMATION',
+  EXPOSITION = 'EXPOSITION',
+  OTHER = 'OTHER',
+}
+
+export enum CalendoEventStatus {
+  DRAFT = 'DRAFT',
+  PUBLISHED = 'PUBLISHED',
+  CANCELLED = 'CANCELLED',
+  SOLD_OUT = 'SOLD_OUT',
+}
+
+export enum CalendoTicketSaleStatus {
+  CONFIRMED = 'CONFIRMED',
+  CANCELLED = 'CANCELLED',
+  REFUNDED = 'REFUNDED',
+}
+
+export enum MapEventType {
+  FAIR = 'FAIR',
+  MARKET = 'MARKET',
+  FESTIVAL = 'FESTIVAL',
+  PERMANENT = 'PERMANENT',
+  OTHER = 'OTHER',
+}
+
+export enum MapEventStatus {
+  DRAFT = 'DRAFT',
+  PUBLISHED = 'PUBLISHED',
+  ARCHIVED = 'ARCHIVED',
+}
+
+export enum MapPoiCategory {
+  ATTRACTION_STAND = 'ATTRACTION_STAND',
+  TOILET = 'TOILET',
+  SECURITY = 'SECURITY',
+  FOOD = 'FOOD',
+  WATER_FOUNTAIN = 'WATER_FOUNTAIN',
+  WASTO_RECYCLING = 'WASTO_RECYCLING',
+  WASTO_BIOWASTE = 'WASTO_BIOWASTE',
+  WASTO_RETURN = 'WASTO_RETURN',
+  TRAVAUX = 'TRAVAUX',
+}
+
+export enum MapZoneType {
+  PARKING_PROVISOIRE = 'PARKING_PROVISOIRE',
+  ZONE_INTERDITE = 'ZONE_INTERDITE',
+  AUTRE = 'AUTRE',
+}
+
+export enum MapPoiStatus {
+  ACTIVE = 'ACTIVE',
+  MAINTENANCE = 'MAINTENANCE',
+  CLOSED = 'CLOSED',
+}
+
+export enum OperationalZoneType {
+  TRAVAUX = 'TRAVAUX',
+  PARKING_PROVISOIRE = 'PARKING_PROVISOIRE',
+  ZONE_INTERDITE = 'ZONE_INTERDITE',
+  AUTRE = 'AUTRE',
+}
+
+export enum OperationalZoneStatus {
+  DRAFT = 'DRAFT',
+  ACTIVE = 'ACTIVE',
+  ARCHIVED = 'ARCHIVED',
+}

package/src/free-tier.ts

@@ -0,0 +1,56 @@
+import type { FreeTierFeature, FreeTierResource } from './types/free-tier.types';
+
+/** Quotas numériques offre gratuite — valeurs ajustables sans changer la logique. */
+export const FREE_TIER_LIMITS = {
+  cmsApps: 1,
+  cmsPages: 5,
+  blogPosts: 10,
+  cmsMedia: 50,
+  cmsMediaBytesMb: 50,
+  wasteTypes: 15,
+  collectionPlaces: 10,
+  printCalendarTemplates: 3,
+} as const;
+
+/** Feature gates offre gratuite — `false` = bloqué. */
+export const FREE_TIER_FEATURES: Record<FreeTierFeature, boolean> = {
+  challenges: false,
+  roi: false,
+  notifications: false,
+  recyclingPoints: false,
+  assets: false,
+  nativeStorePublication: false,
+  inviteMembers: false,
+};
+
+export const FREE_TIER_RESOURCES: readonly FreeTierResource[] = [
+  'cmsApps',
+  'cmsPages',
+  'blogPosts',
+  'cmsMedia',
+  'wasteTypes',
+  'collectionPlaces',
+  'printCalendarTemplates',
+] as const;
+
+export const FREE_TIER_FEATURE_KEYS: readonly FreeTierFeature[] = [
+  'challenges',
+  'roi',
+  'notifications',
+  'recyclingPoints',
+  'assets',
+  'nativeStorePublication',
+  'inviteMembers',
+] as const;
+
+export function getFreeTierLimit(resource: FreeTierResource): number {
+  return FREE_TIER_LIMITS[resource];
+}
+
+export function getFreeTierMediaBytesLimit(): number {
+  return FREE_TIER_LIMITS.cmsMediaBytesMb * 1024 * 1024;
+}
+
+export function isFreeTierFeatureEnabled(feature: FreeTierFeature): boolean {
+  return FREE_TIER_FEATURES[feature] === true;
+}

package/src/index.ts

@@ -0,0 +1,35 @@
+// Enums
+export * from './enums';
+export * from './dashboard-apps';
+export * from './free-tier';
+
+// Types (interfaces Request/Response, pagination, etc.) — no decorators; DTOs with validation live in API
+export * from './types';
+
+// ROI déchets — formules GEC / CEN / ROI (runtime)
+export * from './roi';
+
+// Horaires d'ouverture structurés (UTC)
+export * from './opening-hours';
+
+// CMS app settings (interfaces only)
+export type {
+  AppSplashSettings,
+  AppAdaptiveIconSettings,
+  AppIconSettings,
+  AppThemeGradient,
+  AppThemeSettings,
+  AppLayoutsConfig,
+  AppTabConfig,
+  AppStackScreenConfig,
+  AppSettings,
+} from './dto/cms-app-settings';
+
+// HTTP client
+export {
+  createWastoClient,
+  WastoApiError,
+  type WastoClientConfig,
+  type WastoClient,
+  type WastoRequestErrorContext,
+} from './client';

package/src/opening-hours/constants.ts

@@ -0,0 +1,48 @@
+import type { Weekday } from './types';
+
+/** Dates de référence (semaine du 2024-01-01, lundi) pour conversions TZ */
+export const WEEKDAY_REF_DATES: Record<Weekday, string> = {
+  monday: '2024-01-01',
+  tuesday: '2024-01-02',
+  wednesday: '2024-01-03',
+  thursday: '2024-01-04',
+  friday: '2024-01-05',
+  saturday: '2024-01-06',
+  sunday: '2024-01-07',
+};
+
+export const WEEKDAY_LABELS_FR: Record<Weekday, string> = {
+  monday: 'Lundi',
+  tuesday: 'Mardi',
+  wednesday: 'Mercredi',
+  thursday: 'Jeudi',
+  friday: 'Vendredi',
+  saturday: 'Samedi',
+  sunday: 'Dimanche',
+};
+
+export const WEEKDAY_LABELS_FR_SHORT: Record<Weekday, string> = {
+  monday: 'Lun',
+  tuesday: 'Mar',
+  wednesday: 'Mer',
+  thursday: 'Jeu',
+  friday: 'Ven',
+  saturday: 'Sam',
+  sunday: 'Dim',
+};
+
+export const WEEKDAY_INDEX: Record<Weekday, number> = {
+  monday: 0,
+  tuesday: 1,
+  wednesday: 2,
+  thursday: 3,
+  friday: 4,
+  saturday: 5,
+  sunday: 6,
+};
+
+export const PRESET_SLOTS = {
+  morning: { open: '08:00', close: '12:00' },
+  afternoon: { open: '14:00', close: '18:00' },
+  fullDay: { open: '08:00', close: '18:00' },
+} as const;

package/src/opening-hours/convert.ts

@@ -0,0 +1,276 @@
+import type {
+  OpeningHours,
+  OpeningHoursException,
+  OpeningHoursRule,
+  TimeSlot,
+  Weekday,
+} from './types';
+import { WEEKDAYS } from './types';
+import {
+  addDaysToIsoDate,
+  nextWeekday,
+  parseTimeMinutes,
+  refDateForWeekday,
+  sortSlots,
+  utcHhmmFromDate,
+  weekdayFromUtcDate,
+} from './time';
+import { localDateTimeToUtc, utcDateIso } from './timezone';
+
+type LocalOpeningHoursInput = {
+  rules: OpeningHoursRule[];
+  exceptions?: OpeningHoursException[];
+};
+
+function addSlotToMap(
+  map: Map<Weekday, TimeSlot[]>,
+  day: Weekday,
+  slot: TimeSlot,
+): void {
+  const existing = map.get(day) ?? [];
+  existing.push(slot);
+  map.set(day, existing);
+}
+
+function mergeSlots(slots: TimeSlot[]): TimeSlot[] {
+  const sorted = sortSlots(slots);
+  const merged: TimeSlot[] = [];
+  for (const slot of sorted) {
+    const last = merged[merged.length - 1];
+    if (last && last.close === slot.open) {
+      merged[merged.length - 1] = { open: last.open, close: slot.close };
+    } else {
+      merged.push({ ...slot });
+    }
+  }
+  return merged.filter((s) => {
+    const o = parseTimeMinutes(s.open);
+    const c = parseTimeMinutes(s.close);
+    return o != null && c != null && c > o;
+  });
+}
+
+function mapToRules(map: Map<Weekday, TimeSlot[]>): OpeningHoursRule[] {
+  const rules: OpeningHoursRule[] = [];
+  for (const day of WEEKDAYS) {
+    const slots = map.get(day);
+    if (!slots?.length) continue;
+    rules.push({ days: [day], slots: mergeSlots(slots) });
+  }
+  return coalesceDayRules(rules);
+}
+
+function coalesceDayRules(rules: OpeningHoursRule[]): OpeningHoursRule[] {
+  const bySignature = new Map<string, Weekday[]>();
+  for (const rule of rules) {
+    const sig = JSON.stringify(rule.slots);
+    const days = bySignature.get(sig) ?? [];
+    days.push(...rule.days);
+    bySignature.set(sig, days);
+  }
+  const out: OpeningHoursRule[] = [];
+  for (const [sig, days] of bySignature) {
+    out.push({
+      days: sortWeekdays([...new Set(days)]),
+      slots: JSON.parse(sig) as TimeSlot[],
+    });
+  }
+  return out;
+}
+
+function sortWeekdays(days: Weekday[]): Weekday[] {
+  const order = new Map(WEEKDAYS.map((d, i) => [d, i]));
+  return [...days].sort((a, b) => (order.get(a) ?? 0) - (order.get(b) ?? 0));
+}
+
+function convertLocalSlotToUtcFixed(
+  map: Map<Weekday, TimeSlot[]>,
+  localDay: Weekday,
+  slot: TimeSlot,
+  timeZone: string,
+): void {
+  const openMin = parseTimeMinutes(slot.open);
+  const closeMin = parseTimeMinutes(slot.close);
+  if (openMin == null || closeMin == null) return;
+
+  const openDate = refDateForWeekday(localDay);
+  let closeDate = openDate;
+  const closeTime = slot.close;
+
+  if (closeMin <= openMin) {
+    closeDate = addDaysToIsoDate(openDate, 1);
+  }
+
+  const openUtc = localDateTimeToUtc(openDate, slot.open, timeZone);
+  const closeUtc = localDateTimeToUtc(closeDate, closeTime, timeZone);
+
+  const openDay = weekdayFromUtcDate(openUtc);
+  const closeDay = weekdayFromUtcDate(closeUtc);
+  const openStr = utcHhmmFromDate(openUtc);
+  const closeStr = utcHhmmFromDate(closeUtc);
+
+  if (openDay === closeDay) {
+    if (openStr !== closeStr) {
+      addSlotToMap(map, openDay, { open: openStr, close: closeStr });
+    }
+    return;
+  }
+
+  addSlotToMap(map, openDay, { open: openStr, close: '23:59' });
+  if (closeStr !== '00:00') {
+    addSlotToMap(map, closeDay, { open: '00:00', close: closeStr });
+  }
+}
+
+function convertUtcSlotToLocal(
+  map: Map<Weekday, TimeSlot[]>,
+  utcDay: Weekday,
+  slot: TimeSlot,
+  timeZone: string,
+): void {
+  const openMin = parseTimeMinutes(slot.open);
+  const closeMin = parseTimeMinutes(slot.close);
+  if (openMin == null || closeMin == null) return;
+
+  const openDate = refDateForWeekday(utcDay);
+  let closeDate = openDate;
+  const closeTime = slot.close;
+
+  if (closeMin <= openMin) {
+    closeDate = addDaysToIsoDate(openDate, 1);
+  }
+
+  const openUtc = new Date(`${openDate}T${slot.open}:00.000Z`);
+  const closeUtc = new Date(`${closeDate}T${closeTime}:00.000Z`);
+
+  const openLocal = formatZoned(openUtc, timeZone);
+  const closeLocal = formatZoned(closeUtc, timeZone);
+
+  if (openLocal.day === closeLocal.day) {
+    if (openLocal.time !== closeLocal.time) {
+      addSlotToMap(map, openLocal.day, { open: openLocal.time, close: closeLocal.time });
+    }
+    return;
+  }
+
+  addSlotToMap(map, openLocal.day, { open: openLocal.time, close: '23:59' });
+  if (closeLocal.time !== '00:00') {
+    addSlotToMap(map, closeLocal.day, { open: '00:00', close: closeLocal.time });
+  }
+}
+
+function formatZoned(utc: Date, timeZone: string): { day: Weekday; time: string } {
+  const parts = new Intl.DateTimeFormat('en-US', {
+    timeZone,
+    weekday: 'long',
+    hour: '2-digit',
+    minute: '2-digit',
+    hour12: false,
+  }).formatToParts(utc);
+  const weekdayRaw = parts.find((p) => p.type === 'weekday')?.value?.toLowerCase();
+  const hour = parts.find((p) => p.type === 'hour')?.value ?? '00';
+  const minute = parts.find((p) => p.type === 'minute')?.value ?? '00';
+  const dayMap: Record<string, Weekday> = {
+    monday: 'monday',
+    tuesday: 'tuesday',
+    wednesday: 'wednesday',
+    thursday: 'thursday',
+    friday: 'friday',
+    saturday: 'saturday',
+    sunday: 'sunday',
+  };
+  const day = dayMap[weekdayRaw ?? 'monday'] ?? 'monday';
+  return { day, time: `${hour.padStart(2, '0')}:${minute.padStart(2, '0')}` };
+}
+
+export function convertLocalToUtc(
+  local: LocalOpeningHoursInput,
+  timeZone: string,
+): OpeningHours {
+  const map = new Map<Weekday, TimeSlot[]>();
+
+  for (const rule of local.rules) {
+    for (const day of rule.days) {
+      for (const slot of rule.slots) {
+        convertLocalSlotToUtcFixed(map, day, slot, timeZone);
+      }
+    }
+  }
+
+  const exceptions = local.exceptions?.map((exc) => {
+    if (exc.closed) return exc;
+    const excMap = new Map<Weekday, TimeSlot[]>();
+    for (const slot of exc.slots) {
+      convertLocalSlotToUtcFixed(excMap, 'monday', slot, timeZone);
+    }
+    const merged = [...excMap.values()].flat();
+    return { ...exc, slots: merged.length ? mergeSlots(merged) : exc.slots };
+  });
+
+  return {
+    version: 1,
+    storage: 'utc',
+    rules: mapToRules(map),
+    exceptions,
+  };
+}
+
+export function convertUtcToLocal(
+  utc: OpeningHours,
+  timeZone: string,
+): LocalOpeningHoursInput {
+  const map = new Map<Weekday, TimeSlot[]>();
+
+  for (const rule of utc.rules) {
+    for (const day of rule.days) {
+      for (const slot of rule.slots) {
+        convertUtcSlotToLocal(map, day, slot, timeZone);
+      }
+    }
+  }
+
+  const exceptions = utc.exceptions?.map((exc) => {
+    if (exc.closed) return exc;
+    const excMap = new Map<Weekday, TimeSlot[]>();
+    for (const slot of exc.slots) {
+      convertUtcSlotToLocal(excMap, 'monday', slot, timeZone);
+    }
+    const merged = [...excMap.values()].flat();
+    return { ...exc, slots: merged.length ? mergeSlots(merged) : exc.slots };
+  });
+
+  return {
+    rules: mapToRules(map),
+    exceptions,
+  };
+}
+
+export function localRulesFromRange(
+  fromDay: Weekday,
+  toDay: Weekday,
+  slots: TimeSlot[],
+  exceptDays: Weekday[] = [],
+): OpeningHoursRule {
+  const fromIdx = WEEKDAYS.indexOf(fromDay);
+  const toIdx = WEEKDAYS.indexOf(toDay);
+  const except = new Set(exceptDays);
+  const days: Weekday[] = [];
+  if (fromIdx <= toIdx) {
+    for (let i = fromIdx; i <= toIdx; i++) {
+      const d = WEEKDAYS[i];
+      if (!except.has(d)) days.push(d);
+    }
+  } else {
+    for (let i = fromIdx; i < 7; i++) {
+      const d = WEEKDAYS[i];
+      if (!except.has(d)) days.push(d);
+    }
+    for (let i = 0; i <= toIdx; i++) {
+      const d = WEEKDAYS[i];
+      if (!except.has(d)) days.push(d);
+    }
+  }
+  return { days, slots: [...slots] };
+}
+
+export { nextWeekday };