@wasto/sdk 1.0.3 → 1.0.5

package/src/opening-hours/types.ts

@@ -1,53 +1,53 @@
-export const WEEKDAYS = [
-  'monday',
-  'tuesday',
-  'wednesday',
-  'thursday',
-  'friday',
-  'saturday',
-  'sunday',
-] as const;
-
-export type Weekday = (typeof WEEKDAYS)[number];
-
-export type TimeSlot = { open: string; close: string };
-
-export type OpeningHoursRule = { days: Weekday[]; slots: TimeSlot[] };
-
-export type OpeningHoursExceptionClosed = {
-  date: string;
-  closed: true;
-  label?: string;
-};
-
-export type OpeningHoursExceptionOpen = {
-  date: string;
-  closed: false;
-  slots: TimeSlot[];
-  label?: string;
-};
-
-export type OpeningHoursException =
-  | OpeningHoursExceptionClosed
-  | OpeningHoursExceptionOpen;
-
-/** Horaires structurés persistés en UTC+0 */
-export type OpeningHours = {
-  version: 1;
-  storage: 'utc';
-  rules: OpeningHoursRule[];
-  exceptions?: OpeningHoursException[];
-};
-
-export type HoursInputMode = 'structured' | 'text';
-
-export type WeeklyHoursRow = {
-  day: Weekday;
-  label: string;
-  closed: boolean;
-  slots: TimeSlot[];
-};
-
-export type OpeningHoursValidationResult =
-  | { ok: true; value: OpeningHours }
-  | { ok: false; errors: string[] };
+export const WEEKDAYS = [
+  'monday',
+  'tuesday',
+  'wednesday',
+  'thursday',
+  'friday',
+  'saturday',
+  'sunday',
+] as const;
+
+export type Weekday = (typeof WEEKDAYS)[number];
+
+export type TimeSlot = { open: string; close: string };
+
+export type OpeningHoursRule = { days: Weekday[]; slots: TimeSlot[] };
+
+export type OpeningHoursExceptionClosed = {
+  date: string;
+  closed: true;
+  label?: string;
+};
+
+export type OpeningHoursExceptionOpen = {
+  date: string;
+  closed: false;
+  slots: TimeSlot[];
+  label?: string;
+};
+
+export type OpeningHoursException =
+  | OpeningHoursExceptionClosed
+  | OpeningHoursExceptionOpen;
+
+/** Horaires structurés persistés en UTC+0 */
+export type OpeningHours = {
+  version: 1;
+  storage: 'utc';
+  rules: OpeningHoursRule[];
+  exceptions?: OpeningHoursException[];
+};
+
+export type HoursInputMode = 'structured' | 'text';
+
+export type WeeklyHoursRow = {
+  day: Weekday;
+  label: string;
+  closed: boolean;
+  slots: TimeSlot[];
+};
+
+export type OpeningHoursValidationResult =
+  | { ok: true; value: OpeningHours }
+  | { ok: false; errors: string[] };

package/src/opening-hours/validate.ts

@@ -1,182 +1,182 @@
-import {
-  WEEKDAYS,
-  type OpeningHours,
-  type OpeningHoursException,
-  type OpeningHoursRule,
-  type OpeningHoursValidationResult,
-  type TimeSlot,
-  type Weekday,
-} from './types';
-import { parseTimeMinutes, slotsOverlap, sortSlots } from './time';
-
-const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
-
-function isPlainObject(v: unknown): v is Record<string, unknown> {
-  return v != null && typeof v === 'object' && !Array.isArray(v);
-}
-
-function validateTimeSlot(slot: unknown, path: string, errors: string[]): slot is TimeSlot {
-  if (!isPlainObject(slot)) {
-    errors.push(`${path} : créneau invalide`);
-    return false;
-  }
-  const open = slot.open;
-  const close = slot.close;
-  if (typeof open !== 'string' || parseTimeMinutes(open) == null) {
-    errors.push(`${path}.open : heure invalide (HH:mm)`);
-    return false;
-  }
-  if (typeof close !== 'string' || parseTimeMinutes(close) == null) {
-    errors.push(`${path}.close : heure invalide (HH:mm)`);
-    return false;
-  }
-  const openMin = parseTimeMinutes(open)!;
-  const closeMin = parseTimeMinutes(close)!;
-  if (closeMin <= openMin) {
-    errors.push(`${path} : l'heure de fermeture doit être après l'ouverture (UTC)`);
-    return false;
-  }
-  return true;
-}
-
-function validateRule(rule: unknown, index: number, errors: string[]): rule is OpeningHoursRule {
-  if (!isPlainObject(rule)) {
-    errors.push(`rules[${index}] : règle invalide`);
-    return false;
-  }
-  if (!Array.isArray(rule.days) || rule.days.length === 0) {
-    errors.push(`rules[${index}].days : au moins un jour requis`);
-    return false;
-  }
-  for (const day of rule.days) {
-    if (typeof day !== 'string' || !WEEKDAYS.includes(day as Weekday)) {
-      errors.push(`rules[${index}].days : jour invalide (${String(day)})`);
-    }
-  }
-  if (!Array.isArray(rule.slots) || rule.slots.length === 0) {
-    errors.push(`rules[${index}].slots : au moins un créneau requis`);
-    return false;
-  }
-  const slots: TimeSlot[] = [];
-  rule.slots.forEach((slot, slotIndex) => {
-    if (validateTimeSlot(slot, `rules[${index}].slots[${slotIndex}]`, errors)) {
-      slots.push(slot);
-    }
-  });
-  const sorted = sortSlots(slots);
-  for (let i = 0; i < sorted.length - 1; i++) {
-    if (slotsOverlap(sorted[i], sorted[i + 1])) {
-      errors.push(`rules[${index}].slots : créneaux qui se chevauchent`);
-      break;
-    }
-  }
-  return errors.length === 0;
-}
-
-function validateException(
-  exc: unknown,
-  index: number,
-  errors: string[],
-): exc is OpeningHoursException {
-  if (!isPlainObject(exc)) {
-    errors.push(`exceptions[${index}] : exception invalide`);
-    return false;
-  }
-  if (typeof exc.date !== 'string' || !DATE_RE.test(exc.date)) {
-    errors.push(`exceptions[${index}].date : date invalide (YYYY-MM-DD)`);
-    return false;
-  }
-  if (exc.closed === true) return true;
-  if (exc.closed === false) {
-    if (!Array.isArray(exc.slots) || exc.slots.length === 0) {
-      errors.push(`exceptions[${index}].slots : requis si non fermé`);
-      return false;
-    }
-    exc.slots.forEach((slot, slotIndex) => {
-      validateTimeSlot(slot, `exceptions[${index}].slots[${slotIndex}]`, errors);
-    });
-    return true;
-  }
-  errors.push(`exceptions[${index}].closed : booléen requis`);
-  return false;
-}
-
-export function validateOpeningHours(input: unknown): OpeningHoursValidationResult {
-  const errors: string[] = [];
-  if (!isPlainObject(input)) {
-    return { ok: false, errors: ['Horaires : objet attendu'] };
-  }
-  if (input.version !== 1) {
-    errors.push('version : doit être 1');
-  }
-  if (input.storage !== 'utc') {
-    errors.push('storage : doit être "utc"');
-  }
-  if (!Array.isArray(input.rules)) {
-    errors.push('rules : tableau attendu');
-    return { ok: false, errors };
-  }
-  input.rules.forEach((rule, index) => validateRule(rule, index, errors));
-
-  const daySet = new Set<Weekday>();
-  if (Array.isArray(input.rules)) {
-    for (const rule of input.rules) {
-      if (!isPlainObject(rule) || !Array.isArray(rule.days)) continue;
-      for (const day of rule.days) {
-        if (typeof day === 'string' && WEEKDAYS.includes(day as Weekday)) {
-          const wd = day as Weekday;
-          if (daySet.has(wd)) {
-            errors.push(`rules : le jour ${wd} apparaît dans plusieurs règles`);
-          }
-          daySet.add(wd);
-        }
-      }
-    }
-  }
-
-  if (input.exceptions != null) {
-    if (!Array.isArray(input.exceptions)) {
-      errors.push('exceptions : tableau attendu');
-    } else {
-      input.exceptions.forEach((exc, index) => validateException(exc, index, errors));
-    }
-  }
-
-  if (errors.length > 0) {
-    return { ok: false, errors };
-  }
-
-  return {
-    ok: true,
-    value: {
-      version: 1,
-      storage: 'utc',
-      rules: (input.rules as OpeningHoursRule[]).map((r) => ({
-        days: [...r.days],
-        slots: sortSlots([...r.slots]),
-      })),
-      exceptions: input.exceptions as OpeningHoursException[] | undefined,
-    },
-  };
-}
-
-/** Valide des horaires saisis en heure locale (même structure, sans storage/version). */
-export function validateLocalOpeningHours(input: {
-  rules: OpeningHoursRule[];
-  exceptions?: OpeningHoursException[];
-}): OpeningHoursValidationResult {
-  return validateOpeningHours({
-    version: 1,
-    storage: 'utc',
-    rules: input.rules,
-    exceptions: input.exceptions,
-  });
-}
-
-export function createEmptyOpeningHours(): OpeningHours {
-  return { version: 1, storage: 'utc', rules: [] };
-}
-
-export function createEmptyLocalRules(): OpeningHoursRule[] {
-  return [];
-}
+import {
+  WEEKDAYS,
+  type OpeningHours,
+  type OpeningHoursException,
+  type OpeningHoursRule,
+  type OpeningHoursValidationResult,
+  type TimeSlot,
+  type Weekday,
+} from './types';
+import { parseTimeMinutes, slotsOverlap, sortSlots } from './time';
+
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+
+function isPlainObject(v: unknown): v is Record<string, unknown> {
+  return v != null && typeof v === 'object' && !Array.isArray(v);
+}
+
+function validateTimeSlot(slot: unknown, path: string, errors: string[]): slot is TimeSlot {
+  if (!isPlainObject(slot)) {
+    errors.push(`${path} : créneau invalide`);
+    return false;
+  }
+  const open = slot.open;
+  const close = slot.close;
+  if (typeof open !== 'string' || parseTimeMinutes(open) == null) {
+    errors.push(`${path}.open : heure invalide (HH:mm)`);
+    return false;
+  }
+  if (typeof close !== 'string' || parseTimeMinutes(close) == null) {
+    errors.push(`${path}.close : heure invalide (HH:mm)`);
+    return false;
+  }
+  const openMin = parseTimeMinutes(open)!;
+  const closeMin = parseTimeMinutes(close)!;
+  if (closeMin <= openMin) {
+    errors.push(`${path} : l'heure de fermeture doit être après l'ouverture (UTC)`);
+    return false;
+  }
+  return true;
+}
+
+function validateRule(rule: unknown, index: number, errors: string[]): rule is OpeningHoursRule {
+  if (!isPlainObject(rule)) {
+    errors.push(`rules[${index}] : règle invalide`);
+    return false;
+  }
+  if (!Array.isArray(rule.days) || rule.days.length === 0) {
+    errors.push(`rules[${index}].days : au moins un jour requis`);
+    return false;
+  }
+  for (const day of rule.days) {
+    if (typeof day !== 'string' || !WEEKDAYS.includes(day as Weekday)) {
+      errors.push(`rules[${index}].days : jour invalide (${String(day)})`);
+    }
+  }
+  if (!Array.isArray(rule.slots) || rule.slots.length === 0) {
+    errors.push(`rules[${index}].slots : au moins un créneau requis`);
+    return false;
+  }
+  const slots: TimeSlot[] = [];
+  rule.slots.forEach((slot, slotIndex) => {
+    if (validateTimeSlot(slot, `rules[${index}].slots[${slotIndex}]`, errors)) {
+      slots.push(slot);
+    }
+  });
+  const sorted = sortSlots(slots);
+  for (let i = 0; i < sorted.length - 1; i++) {
+    if (slotsOverlap(sorted[i], sorted[i + 1])) {
+      errors.push(`rules[${index}].slots : créneaux qui se chevauchent`);
+      break;
+    }
+  }
+  return errors.length === 0;
+}
+
+function validateException(
+  exc: unknown,
+  index: number,
+  errors: string[],
+): exc is OpeningHoursException {
+  if (!isPlainObject(exc)) {
+    errors.push(`exceptions[${index}] : exception invalide`);
+    return false;
+  }
+  if (typeof exc.date !== 'string' || !DATE_RE.test(exc.date)) {
+    errors.push(`exceptions[${index}].date : date invalide (YYYY-MM-DD)`);
+    return false;
+  }
+  if (exc.closed === true) return true;
+  if (exc.closed === false) {
+    if (!Array.isArray(exc.slots) || exc.slots.length === 0) {
+      errors.push(`exceptions[${index}].slots : requis si non fermé`);
+      return false;
+    }
+    exc.slots.forEach((slot, slotIndex) => {
+      validateTimeSlot(slot, `exceptions[${index}].slots[${slotIndex}]`, errors);
+    });
+    return true;
+  }
+  errors.push(`exceptions[${index}].closed : booléen requis`);
+  return false;
+}
+
+export function validateOpeningHours(input: unknown): OpeningHoursValidationResult {
+  const errors: string[] = [];
+  if (!isPlainObject(input)) {
+    return { ok: false, errors: ['Horaires : objet attendu'] };
+  }
+  if (input.version !== 1) {
+    errors.push('version : doit être 1');
+  }
+  if (input.storage !== 'utc') {
+    errors.push('storage : doit être "utc"');
+  }
+  if (!Array.isArray(input.rules)) {
+    errors.push('rules : tableau attendu');
+    return { ok: false, errors };
+  }
+  input.rules.forEach((rule, index) => validateRule(rule, index, errors));
+
+  const daySet = new Set<Weekday>();
+  if (Array.isArray(input.rules)) {
+    for (const rule of input.rules) {
+      if (!isPlainObject(rule) || !Array.isArray(rule.days)) continue;
+      for (const day of rule.days) {
+        if (typeof day === 'string' && WEEKDAYS.includes(day as Weekday)) {
+          const wd = day as Weekday;
+          if (daySet.has(wd)) {
+            errors.push(`rules : le jour ${wd} apparaît dans plusieurs règles`);
+          }
+          daySet.add(wd);
+        }
+      }
+    }
+  }
+
+  if (input.exceptions != null) {
+    if (!Array.isArray(input.exceptions)) {
+      errors.push('exceptions : tableau attendu');
+    } else {
+      input.exceptions.forEach((exc, index) => validateException(exc, index, errors));
+    }
+  }
+
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+
+  return {
+    ok: true,
+    value: {
+      version: 1,
+      storage: 'utc',
+      rules: (input.rules as OpeningHoursRule[]).map((r) => ({
+        days: [...r.days],
+        slots: sortSlots([...r.slots]),
+      })),
+      exceptions: input.exceptions as OpeningHoursException[] | undefined,
+    },
+  };
+}
+
+/** Valide des horaires saisis en heure locale (même structure, sans storage/version). */
+export function validateLocalOpeningHours(input: {
+  rules: OpeningHoursRule[];
+  exceptions?: OpeningHoursException[];
+}): OpeningHoursValidationResult {
+  return validateOpeningHours({
+    version: 1,
+    storage: 'utc',
+    rules: input.rules,
+    exceptions: input.exceptions,
+  });
+}
+
+export function createEmptyOpeningHours(): OpeningHours {
+  return { version: 1, storage: 'utc', rules: [] };
+}
+
+export function createEmptyLocalRules(): OpeningHoursRule[] {
+  return [];
+}