TruePresence Developer Reference

function getVirtueWeek(date):

  1. Find the current liturgical year:
     - If date >= Advent1(current_calendar_year), liturgical year starts this year
     - Else, liturgical year started last year's Advent 1

  2. Calculate key dates for this liturgical year:
     - advent1         = First Sunday of Advent
     - christmas       = Dec 25
     - baptism         = Sunday after Epiphany (see formula below)
     - ashWednesday    = Easter - 46 days
     - easter          = Computus algorithm
     - pentecost       = Easter + 49 days
     - nextAdvent1     = First Sunday of Advent next year

  3. Determine phase and virtue week:

     IF date is in [advent1, Dec 24]:
        virtue_week = floor((date - advent1) / 7) + 1      // 1-4

     ELSE IF date is in [Dec 25, baptism - 1]:
        virtue_week = 5 + floor((date - Dec 25) / 7)       // 5-6

     ELSE IF date is in [baptism, ashWednesday - 1]:        // FLEX ZONE
        virtue_week = 7 + floor(days_elapsed / total * 7)
        clamp(7, 13)

     ELSE IF date is in [ashWednesday, easter - 1]:
        virtue_week = 14 + floor((date - ashWed) / 7)      // 14-19

     ELSE IF date is in [easter, pentecost + 6]:
        virtue_week = 20 + floor((date - easter) / 7)      // 20-27

     ELSE IF date is in [pentecost + 7, nextAdvent1 - 1]:   // FLEX ZONE
        virtue_week = 28 + floor(days_elapsed / total * 25)
        clamp(28, 52)

// === Date Helpers ===

function getEasterDate(year) {
  // Anonymous Gregorian algorithm (Meeus/Jones/Butcher)
  const a = year % 19;
  const b = Math.floor(year / 100);
  const c = year % 100;
  const d = Math.floor(b / 4);
  const e = b % 4;
  const f = Math.floor((b + 8) / 25);
  const g = Math.floor((b - f + 1) / 3);
  const h = (19 * a + b - d - g + 15) % 30;
  const i = Math.floor(c / 4);
  const k = c % 4;
  const l = (32 + 2 * e + 2 * i - h - k) % 7;
  const m = Math.floor((a + 11 * h + 22 * l) / 451);
  const month = Math.floor((h + l - 7 * m + 114) / 31);
  const day = ((h + l - 7 * m + 114) % 31) + 1;
  return new Date(year, month - 1, day);
}

function getAdvent1(year) {
  const nov30 = new Date(year, 10, 30);
  const dow = nov30.getDay();
  if (dow === 0) return nov30;
  if (dow <= 3) return new Date(year, 10, 30 - dow);
  return new Date(year, 10, 30 + (7 - dow));
}

function getBaptismOfLord(year) {
  const jan2 = new Date(year, 0, 2);
  const dow = jan2.getDay();
  const epiphany = dow === 0 ? jan2 : new Date(year, 0, 2 + (7 - dow));
  const epDay = epiphany.getDate();
  if (epDay >= 7) return new Date(year, 0, epDay + 1);
  return new Date(year, 0, epDay + 7);
}

function daysBetween(a, b) {
  return Math.floor((b - a) / (1000 * 60 * 60 * 24));
}

function clamp(val, min, max) {
  return Math.max(min, Math.min(max, val));
}

// === Main Function ===

function getVirtueWeek(date) {
  const d = new Date(date.getFullYear(), date.getMonth(), date.getDate());
  const advent1ThisYear = getAdvent1(d.getFullYear());
  let liturgicalYearStart = d >= advent1ThisYear
    ? d.getFullYear() : d.getFullYear() - 1;

  const advent1    = getAdvent1(liturgicalYearStart);
  const christmas  = new Date(liturgicalYearStart, 11, 25);
  const easterYear = liturgicalYearStart + 1;
  const baptism    = getBaptismOfLord(easterYear);
  const easter     = getEasterDate(easterYear);
  const ashWed     = new Date(easter.getTime() - 46 * 86400000);
  const pentecost  = new Date(easter.getTime() + 49 * 86400000);
  const nextAdvent1 = getAdvent1(liturgicalYearStart + 1);

  if (d >= nextAdvent1) return 1;

  // ADVENT (1-4)
  if (d >= advent1 && d < christmas)
    return clamp(Math.floor(daysBetween(advent1, d) / 7) + 1, 1, 4);

  // CHRISTMAS (5-6)
  if (d >= christmas && d < baptism)
    return clamp(5 + Math.floor(daysBetween(christmas, d) / 7), 5, 6);

  // ORDINARY TIME I (7-13) — flex
  if (d >= baptism && d < ashWed) {
    const total = daysBetween(baptism, ashWed);
    const elapsed = daysBetween(baptism, d);
    return clamp(7 + Math.floor((elapsed / total) * 7), 7, 13);
  }

  // LENT (14-19)
  if (d >= ashWed && d < easter)
    return clamp(14 + Math.floor(daysBetween(ashWed, d) / 7), 14, 19);

  // EASTER (20-27)
  const pentEnd = new Date(pentecost.getTime() + 7 * 86400000);
  if (d >= easter && d < pentEnd)
    return clamp(20 + Math.floor(daysBetween(easter, d) / 7), 20, 27);

  // ORDINARY TIME II (28-52) — flex
  if (d >= pentEnd && d < nextAdvent1) {
    const total = daysBetween(pentEnd, nextAdvent1);
    const elapsed = daysBetween(pentEnd, d);
    return clamp(28 + Math.floor((elapsed / total) * 25), 28, 52);
  }

  return 1;
}