Domain Resolvers: Context-Aware Decision Logic

export interface Resolver<Input, Output> {
  resolve(params: Input): Output;
}

class ShiftSegmentResolver implements Resolver<
  { point: Point; meta: WorkDayMeta },
  LabeledSegmentRange[]
>

export interface Point {
  start: number; // minutes from midnight
  end: number;
}

export interface LabeledSegmentRange {
  point: Point;
  percent: number;
  key: string; // "hours20" | "hours50" | "hours100" | "shabbat150" | "shabbat200"
}

export interface WorkDayMeta {
  date: string;
  typeDay: WorkDayType;              // Regular | SpecialPartialStart | SpecialFull
  crossDayContinuation: boolean;
  holidayKey?: HolidayKey;
}

private findSegments(target: Point, src: LabeledSegmentRange[]): LabeledSegmentRange[] {
  // Locate the first and last overlapping segments, then clip start/end to target bounds.
  // Segments with zero net duration are discarded.
}

class HolidayResolverService implements HolidayResolver

// HolidayResolver = Resolver<
//   { weekday: number; eventTitles: string[] },
//   WorkDayType
// >

resolve(params: { weekday: number; eventTitles: string[] }): WorkDayType

Rosh Hashana, Rosh Hashana II, Yom Kippur, Sukkot I,
Shmini Atzeret, Pesach I, Pesach VII, Yom HaAtzma'ut, Shavuot I

Erev Rosh Hashana, Erev Yom Kippur, Erev Sukkot, Erev Pesach,
Erev Shavuot, Yom HaZikaron, Sukkot VII (Hoshana Rabba),
Pesach VI (CH'M)

class WorkDayInfoResolver implements DayInfoResolver

export interface DayInfoResolver {
  isSpecialFullDay(day: WorkDayInfo): boolean;
  isPartialHolidayStart(day: WorkDayInfo): boolean;
  hasCrossDayContinuation(day: WorkDayInfo): boolean;
  formatHebrewWorkDay(day: WorkDayInfo): string;
}

class DefaultMonthResolver implements MonthResolver

export interface MonthResolver {
  getAvailableMonths(year: number): number[];
  getAvailableMonthOptions(year: number): { value: number; label: string }[];
  resolveDefaultMonth(year: number): number;
  getMonthName(monthIndex: number): string;
  getAllMonthNames(): string[];
  getCurrentYear(): number;
}

class TimelinePerDiemRateResolver implements Resolver<
  { year: number; month: number },
  number  // ILS per point (Tier A rate)
>

class TimelineMealAllowanceRateResolver implements Resolver<
  { year: number; month: number },
  MealAllowanceRates
>

export interface MealAllowanceRates {
  small: number; // ILS per small meal allowance point
  large: number; // ILS per large meal allowance point
}

class MealAllowanceResolver implements Resolver<
  { day: MealAllowanceDayInfo; rates: MealAllowanceRates },
  MealAllowance
>

resolve(params: { day: MealAllowanceDayInfo; rates: MealAllowanceRates }): MealAllowance {
  const large = largeCalculator.calculate({ day, rate: rates.large });

  if (large.points > 0) {
    // Large wins — small is zeroed
    return { large, small: { points: 0, amount: 0 } };
  }

  const small = smallCalculator.calculate({ day, rate: rates.small });
  return { large: { points: 0, amount: 0 }, small };
}