@wasto/sdk 1.0.3 → 1.0.5

package/src/opening-hours/convert.ts

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