wip

packages/racing/domain/value-objects/LeagueTimezone.ts

@@ -0,0 +1,14 @@
+export class LeagueTimezone {
+  private readonly id: string;
+
+  constructor(id: string) {
+    if (!id || id.trim().length === 0) {
+      throw new Error('LeagueTimezone id must be a non-empty string');
+    }
+    this.id = id;
+  }
+
+  getId(): string {
+    return this.id;
+  }
+}

packages/racing/domain/value-objects/MonthlyRecurrencePattern.ts

@@ -0,0 +1,11 @@
+import type { Weekday } from './Weekday';
+
+export class MonthlyRecurrencePattern {
+  readonly ordinal: 1 | 2 | 3 | 4;
+  readonly weekday: Weekday;
+
+  constructor(ordinal: 1 | 2 | 3 | 4, weekday: Weekday) {
+    this.ordinal = ordinal;
+    this.weekday = weekday;
+  }
+}

packages/racing/domain/value-objects/RaceTimeOfDay.ts

@@ -0,0 +1,34 @@
+export class RaceTimeOfDay {
+  readonly hour: number;
+  readonly minute: number;
+
+  constructor(hour: number, minute: number) {
+    if (!Number.isInteger(hour) || hour < 0 || hour > 23) {
+      throw new Error(`RaceTimeOfDay hour must be between 0 and 23, got ${hour}`);
+    }
+    if (!Number.isInteger(minute) || minute < 0 || minute > 59) {
+      throw new Error(`RaceTimeOfDay minute must be between 0 and 59, got ${minute}`);
+    }
+
+    this.hour = hour;
+    this.minute = minute;
+  }
+
+  static fromString(value: string): RaceTimeOfDay {
+    const match = /^(\d{2}):(\d{2})$/.exec(value);
+    if (!match) {
+      throw new Error(`RaceTimeOfDay string must be in HH:MM 24h format, got "${value}"`);
+    }
+
+    const hour = Number(match[1]);
+    const minute = Number(match[2]);
+
+    return new RaceTimeOfDay(hour, minute);
+  }
+
+  toString(): string {
+    const hh = this.hour.toString().padStart(2, '0');
+    const mm = this.minute.toString().padStart(2, '0');
+    return `${hh}:${mm}`;
+  }
+}

packages/racing/domain/value-objects/RecurrenceStrategy.ts

@@ -0,0 +1,53 @@
+import { WeekdaySet } from './WeekdaySet';
+import { MonthlyRecurrencePattern } from './MonthlyRecurrencePattern';
+
+export type RecurrenceStrategyKind = 'weekly' | 'everyNWeeks' | 'monthlyNthWeekday';
+
+export type WeeklyRecurrence = {
+  kind: 'weekly';
+  weekdays: WeekdaySet;
+};
+
+export type EveryNWeeksRecurrence = {
+  kind: 'everyNWeeks';
+  intervalWeeks: number;
+  weekdays: WeekdaySet;
+};
+
+export type MonthlyNthWeekdayRecurrence = {
+  kind: 'monthlyNthWeekday';
+  monthlyPattern: MonthlyRecurrencePattern;
+};
+
+export type RecurrenceStrategy =
+  | WeeklyRecurrence
+  | EveryNWeeksRecurrence
+  | MonthlyNthWeekdayRecurrence;
+
+export class RecurrenceStrategyFactory {
+  static weekly(weekdays: WeekdaySet): RecurrenceStrategy {
+    return {
+      kind: 'weekly',
+      weekdays,
+    };
+  }
+
+  static everyNWeeks(intervalWeeks: number, weekdays: WeekdaySet): RecurrenceStrategy {
+    if (!Number.isInteger(intervalWeeks) || intervalWeeks < 1 || intervalWeeks > 12) {
+      throw new Error('everyNWeeks intervalWeeks must be an integer between 1 and 12');
+    }
+
+    return {
+      kind: 'everyNWeeks',
+      intervalWeeks,
+      weekdays,
+    };
+  }
+
+  static monthlyNthWeekday(monthlyPattern: MonthlyRecurrencePattern): RecurrenceStrategy {
+    return {
+      kind: 'monthlyNthWeekday',
+      monthlyPattern,
+    };
+  }
+}

packages/racing/domain/value-objects/ScheduledRaceSlot.ts

@@ -0,0 +1,20 @@
+import { LeagueTimezone } from './LeagueTimezone';
+
+export class ScheduledRaceSlot {
+  readonly roundNumber: number;
+  readonly scheduledAt: Date;
+  readonly timezone: LeagueTimezone;
+
+  constructor(params: { roundNumber: number; scheduledAt: Date; timezone: LeagueTimezone }) {
+    if (!Number.isInteger(params.roundNumber) || params.roundNumber <= 0) {
+      throw new Error('ScheduledRaceSlot.roundNumber must be a positive integer');
+    }
+    if (!(params.scheduledAt instanceof Date) || Number.isNaN(params.scheduledAt.getTime())) {
+      throw new Error('ScheduledRaceSlot.scheduledAt must be a valid Date');
+    }
+
+    this.roundNumber = params.roundNumber;
+    this.scheduledAt = params.scheduledAt;
+    this.timezone = params.timezone;
+  }
+}

packages/racing/domain/value-objects/SeasonSchedule.ts

@@ -0,0 +1,36 @@
+import { RaceTimeOfDay } from './RaceTimeOfDay';
+import { LeagueTimezone } from './LeagueTimezone';
+import type { RecurrenceStrategy } from './RecurrenceStrategy';
+
+export class SeasonSchedule {
+  readonly startDate: Date;
+  readonly timeOfDay: RaceTimeOfDay;
+  readonly timezone: LeagueTimezone;
+  readonly recurrence: RecurrenceStrategy;
+  readonly plannedRounds: number;
+
+  constructor(params: {
+    startDate: Date;
+    timeOfDay: RaceTimeOfDay;
+    timezone: LeagueTimezone;
+    recurrence: RecurrenceStrategy;
+    plannedRounds: number;
+  }) {
+    if (!(params.startDate instanceof Date) || Number.isNaN(params.startDate.getTime())) {
+      throw new Error('SeasonSchedule.startDate must be a valid Date');
+    }
+    if (!Number.isInteger(params.plannedRounds) || params.plannedRounds <= 0) {
+      throw new Error('SeasonSchedule.plannedRounds must be a positive integer');
+    }
+
+    this.startDate = new Date(
+      params.startDate.getFullYear(),
+      params.startDate.getMonth(),
+      params.startDate.getDate(),
+    );
+    this.timeOfDay = params.timeOfDay;
+    this.timezone = params.timezone;
+    this.recurrence = params.recurrence;
+    this.plannedRounds = params.plannedRounds;
+  }
+}

packages/racing/domain/value-objects/Weekday.ts

@@ -0,0 +1,25 @@
+export type Weekday = 'Mon' | 'Tue' | 'Wed' | 'Thu' | 'Fri' | 'Sat' | 'Sun';
+
+export const ALL_WEEKDAYS: Weekday[] = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'];
+
+export function weekdayToIndex(day: Weekday): number {
+  switch (day) {
+    case 'Mon':
+      return 1;
+    case 'Tue':
+      return 2;
+    case 'Wed':
+      return 3;
+    case 'Thu':
+      return 4;
+    case 'Fri':
+      return 5;
+    case 'Sat':
+      return 6;
+    case 'Sun':
+      return 7;
+    default:
+      // This should be unreachable because Weekday is a closed union.
+      throw new Error(`Unknown weekday: ${day}`);
+  }
+}

packages/racing/domain/value-objects/WeekdaySet.ts

@@ -0,0 +1,23 @@
+import type { Weekday } from './Weekday';
+import { weekdayToIndex } from './Weekday';
+
+export class WeekdaySet {
+  private readonly days: Weekday[];
+
+  constructor(days: Weekday[]) {
+    if (!Array.isArray(days) || days.length === 0) {
+      throw new Error('WeekdaySet requires at least one weekday');
+    }
+
+    const unique = Array.from(new Set(days));
+    this.days = unique.sort((a, b) => weekdayToIndex(a) - weekdayToIndex(b));
+  }
+
+  getAll(): Weekday[] {
+    return [...this.days];
+  }
+
+  includes(day: Weekday): boolean {
+    return this.days.includes(day);
+  }
+}