@opndev/tennis-match-center 0.0.3 → 0.0.4

package/lib/paired-court-planner.mjs

@@ -53,9 +53,16 @@ import { courtCanHost } from './occupancy.mjs'
  *   FOUR_TEAM_TEMPLATE. A round's pairs.length is courtsPerRound.
  * @param {(group: {id: number, teamIds: number[]}) => Array<{slot: number, pairIndex: number, index: number}>} params.matchesFor
  *   A group's own matches, flattened and indexed in play order.
+ * @param {?(groupId: number, index: number) => boolean} [params.done]
+ *   Which of them are already played, for a day laid out into a plan
+ *   that exists.
  * @returns {Array<Array<{groupId: number, index: number}|null>>} slot by court
  */
-export function unitLayout(groups, { template, matchesFor }) {
+export function unitLayout(groups, { template, matchesFor, done = null }) {
+  if (done) {
+    return remainderLayout(groups, { template, matchesFor, done })
+  }
+
   const slots = []
 
   for (const round of template) {
@@ -71,7 +78,15 @@ export function unitLayout(groups, { template, matchesFor }) {
               match => match.slot === round.slot && match.pairIndex === pairIndex
             )
 
-            return index === -1 ? null : { groupId: group.id, index }
+            // A fixture already played keeps its place in the
+            // numbering and leaves a hole in the layout - the index
+            // is what a cell is booked as, so it cannot be squeezed
+            // out by renumbering what is left.
+            if (index === -1 || done?.(group.id, index)) {
+              return null
+            }
+
+            return { groupId: group.id, index }
           })
           .filter(Boolean)
       })
@@ -87,6 +102,54 @@ export function unitLayout(groups, { template, matchesFor }) {
   return slots
 }
 
+/**
+ * The same, for groups part-way through.
+ *
+ * A round with two of its fixtures played is not a round of two with
+ * a hole where they were: the hole is a court standing empty and the
+ * group finishing later than it needs to. Two groups with three
+ * fixtures left each should finish together, this morning, rather
+ * than waiting out each other's gaps all day.
+ *
+ * So the remainder is packed rather than skipped. Each group's own
+ * matches keep their order and their numbers - the number is what a
+ * cell is booked as - but they are dealt out in turns of
+ * courtsPerRound, group after group, until everyone is done. A group
+ * with nothing left takes no turn.
+ *
+ * @param {Array} groups
+ * @param {Object} params see unitLayout
+ * @returns {Array<Array<{groupId: number, index: number}|null>>}
+ */
+function remainderLayout(groups, { template, matchesFor, done }) {
+  const width = Math.max(...template.map(round => round.pairs.length))
+
+  const left = groups.map(group => ({
+    id: group.id,
+    matches: matchesFor(group)
+      .map((match, index) => ({ ...match, index }))
+      .filter(match => !done(group.id, match.index)),
+  }))
+
+  const slots = []
+
+  while (left.some(group => group.matches.length > 0)) {
+    for (const group of left) {
+      if (group.matches.length === 0) {
+        continue
+      }
+
+      const turn = group.matches.splice(0, width)
+
+      slots.push(Array.from({ length: width }, (_, courtIndex) =>
+        turn[courtIndex] ? { groupId: group.id, index: turn[courtIndex].index } : null
+      ))
+    }
+  }
+
+  return slots
+}
+
 /**
  * Places an already-computed layout (see unitLayout) onto the lowest
  * stretch of courts that is actually free, and the earliest start on

package/lib/planning-day.mjs

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 import { courtUsableAt, runFits } from './court-runs.mjs'
+import { placeLayout } from './paired-court-planner.mjs'
 
 /**
  * How long before dark an unlit court stops taking new play, where the
@@ -180,4 +181,168 @@ export class PlanningDay {
       this.date, block.court_id, slot.start_minutes, slot.end_minutes
     )
   }
+
+  /**
+   * Lays one unit of groups onto this day: its share of the unit's
+   * sequence for today, on the courts of its lane.
+   *
+   * @param {Object} unit
+   * @param {Function} unitLayoutFn Lays the unit's groups out in order,
+   *   leaving out the fixtures its second argument says are done.
+   * @param {Array} fallbackSlots Used when the competition has none.
+   * @param {Function} done Whether a fixture is already in the plan.
+   * @returns {number|boolean} how many courts it took, or false
+   */
+  placeGroupUnit(unit, unitLayoutFn, fallbackSlots, done) {
+    const { date } = this
+    const blocks = this.plan.blocks
+    const unitDates = unit.dates.slice(0, 2)
+    const dayIndex = unitDates.indexOf(date)
+
+    if (dayIndex === -1 || unit.placed.has(date)) {
+      return false
+    }
+
+    const unitSlots = this.slotsByCompetition
+      .get(unit.entries[0].competition.id) ?? fallbackSlots
+
+    if (unitSlots.length === 0 || unitSlots[0].phase === 'knockout') {
+      return false
+    }
+
+    const groups = unit.entries.map(entry => ({
+      id: entry.group.id,
+      teamIds: entry.group.team_ids,
+      groupSize: entry.group.pool_size,
+    }))
+
+    // Which fixtures belong to today is a question about the whole
+    // unit. Asked of what is left after some were played, the first
+    // half of the remainder is not today's half.
+    const sequence = unitLayoutFn(groups, () => false)
+    const firstDay = Math.floor(sequence.length / unitDates.length)
+    const share = dayIndex === 0
+      ? sequence.slice(0, firstDay)
+      : sequence.slice(firstDay)
+
+    const fixtures = share.flat().filter(Boolean)
+    const owed = new Set(
+      fixtures
+        .filter(cell => !done(cell.groupId, cell.index))
+        .map(cell => `${cell.groupId}:${cell.index}`)
+    )
+
+    const layout = owed.size === fixtures.length
+      ? share
+      : unitLayoutFn(
+        groups, (groupId, index) => !owed.has(`${groupId}:${index}`)
+      )
+
+    const before = blocks.length
+
+    const placed = placeLayout({
+      layout,
+      lookup: groupId => {
+        const entry = unit.entries.find(x => x.group.id === groupId)
+
+        return {
+          id: entry.group.id,
+          competitionId: entry.competition.id,
+          divisionId: entry.group.division_id ?? null,
+          divisionName: entry.group.division_name ?? null,
+          divisionGender: entry.group.division_gender ?? null,
+          groupName: entry.group.name ?? null,
+        }
+      },
+      courts: this.courtsFor(unit.isPro),
+      slots: unitSlots,
+      date,
+      occupancy: this.occupancy,
+      darkFrom: this.darkFromMinutes,
+      blocks,
+    })
+
+    if (placed) {
+      unit.placed.add(date)
+      return new Set(blocks.slice(before).map(block => block.court_id)).size
+    }
+
+    return false
+  }
+
+  /**
+   * Lays out the units that are due today, a lane at a time.
+   *
+   * A division gets a share of the lane's courts in proportion to its
+   * units, so one division cannot take the whole room before another
+   * has been looked at. What the shares left over is then offered to
+   * whoever has not been placed.
+   *
+   * @param {Array} units
+   * @param {Function} unitLayoutFn Lays a unit's groups out in order.
+   * @param {Array} fallbackSlots Used when a competition has none.
+   * @param {Function} done Whether a fixture is already in the plan.
+   */
+  placeGroupUnits(units, unitLayoutFn, fallbackSlots, done) {
+    const { date } = this
+
+    for (const kind of [true, false]) {
+      const due = units.filter(unit =>
+        unit.isPro === kind && !unit.placed.has(date)
+          && unit.dates.includes(date)
+      )
+
+      if (due.length === 0) {
+        continue
+      }
+
+      const order = []
+
+      for (const unit of due) {
+        if (!order.includes(unit.divisionId)) {
+          order.push(unit.divisionId)
+        }
+      }
+
+      const roomCourts = this.courtsFor(kind).length
+
+      const quota = new Map(order.map((divisionId, index) => {
+        const mine = due.filter(unit => unit.divisionId === divisionId)
+        const share = mine.length / due.length
+
+        return [
+          divisionId,
+          index === order.length - 1
+            ? Infinity
+            : Math.max(2, Math.round(share * roomCourts)),
+        ]
+      }))
+
+      const claimed = new Map()
+
+      for (const unit of due) {
+        const mine = claimed.get(unit.divisionId) ?? 0
+
+        if (mine >= (quota.get(unit.divisionId) ?? Infinity)) {
+          continue
+        }
+
+        const courtsUsed = this.placeGroupUnit(
+          unit, unitLayoutFn, fallbackSlots, done
+        )
+
+        if (courtsUsed) {
+          claimed.set(
+            unit.divisionId, (claimed.get(unit.divisionId) ?? 0) + courtsUsed
+          )
+        }
+      }
+
+      for (const unit of due) {
+        if (!unit.placed.has(date)) {
+          this.placeGroupUnit(unit, unitLayoutFn, fallbackSlots, done)
+        }
+      }
+    }
+  }
 }

package/lib/run-queue-planner.mjs

@@ -6,12 +6,20 @@ import { bandDistance, computeSectionBands, sectionsFor } from './court-bands.mj
 import { groupRuns } from './group-schedule.mjs'
 
 /**
- * Where a group should land the day after playing a given section:
- * S1 to S3, S2 to S4, S3 to S1, S4 to S2 - prio.pl's rotation. A
- * group that played late one day plays early the next and the other
- * way round, so nobody gets two late finishes or two early starts.
+ * Where a group should land the day after playing a given section: two
+ * sections on, wrapping round. With four that is S1 to S3, S2 to S4, S3
+ * to S1 and S4 to S2 - prio.pl's rotation, where a group that played
+ * late one day plays early the next. With three it is S1 to S3, S2 to
+ * S1 and S3 to S2, so nobody plays the same block twice running and
+ * nobody who finished late starts early.
+ *
+ * @param {number} previous The section it played last.
+ * @param {number} sectionCount
+ * @returns {?number} null where there are too few sections to rotate.
  */
-const SECTION_OFFSET = { 0: 2, 1: 3, 2: 0, 3: 1 }
+function rotationTarget(previous, sectionCount) {
+  return sectionCount >= 3 ? (previous + 2) % sectionCount : null
+}
 
 // Mirrors GameCounter::GAMES_PER_GROUP server-side: how many matches a
 // full group of this size plays. Used only to report a group with no
@@ -21,6 +29,102 @@ const GAMES_PER_POOL_SIZE = { 3: 3, 4: 6, 5: 10 }
 
 const queueKey = (competitionId, date) => `${competitionId}:${date}`
 
+/**
+ * What is left of a run once the fixtures already in the plan are
+ * taken out.
+ *
+ * @param {{positions: Array<?number>, indices: number[]}} run
+ * @param {number} groupId
+ * @param {?Function} done (groupId, index) => whether it is in the plan
+ * @returns {?Object} the run, shortened, or null when nothing is left
+ */
+export function remainderOf(run, groupId, done) {
+  if (done === null) {
+    return run
+  }
+
+  const owed = run.positions.filter(
+    position => position !== null && !done(groupId, position)
+  )
+
+  if (owed.length === 0) {
+    return null
+  }
+
+  if (owed.length === run.positions.filter(position => position !== null).length) {
+    return run
+  }
+
+  return { ...run, positions: owed, indices: owed }
+}
+
+/**
+ * How a section can be shared when courts are scarce.
+ *
+ * A run is one group on one court for its whole stretch. When courts
+ * drop out part way through a section, only the courts that last it
+ * can host a run, and the rest of the room goes spare - the front of
+ * the section has every court, the back only some. Whatever the reason
+ * a court drops out, the answer is the same: a group plays the front of
+ * its run on a court of its own while that court exists, and the back
+ * of it on one of the courts that remain, which two groups share by
+ * taking turns. Nobody waits longer than a match for their next.
+ *
+ * The section is then as long as the front plus two backs.
+ *
+ * Only the last section that loses courts is shared, and only when
+ * sharing holds more groups than whole runs do.
+ *
+ * @param {Object} params
+ * @param {Array} params.own The competition's slots that day.
+ * @param {Array} params.sections see sectionsFor
+ * @param {number} params.runLength
+ * @param {Array} params.courts
+ * @param {Function} params.usable (court, slot) => boolean
+ * @returns {?{index: number, first: number, front: number, back: number,
+ *   length: number, capacity: number}}
+ */
+export function sharedSectionFor({ own, sections, runLength, courts, usable }) {
+  for (let index = sections.length - 1; index >= 0; index--) {
+    const first = index * runLength
+    const open = courts.filter(court => usable(court, own[first]))
+
+    let front = 0
+
+    while (
+      front < runLength
+        && first + front < own.length
+        && open.every(court => usable(court, own[first + front]))
+    ) {
+      front++
+    }
+
+    // Nothing is lost during the run, or nothing is there to start with.
+    if (front === 0 || front === runLength) {
+      continue
+    }
+
+    const back = runLength - front
+    const length = front + 2 * back
+
+    if (first + length > own.length) {
+      continue
+    }
+
+    const remaining = own.slice(first + front, first + length)
+    const lasting = open.filter(court => remaining.every(slot => usable(court, slot)))
+    const capacity = Math.min(open.length, lasting.length * 2)
+
+    if (capacity <= sections[index].capacity) {
+      continue
+    }
+
+    return { index, first, front, back, length, capacity }
+  }
+
+  return null
+}
+
 /**
  * Group play for any shape whose groups run their whole round robin as
  * one unbroken stretch on one court - 5-team's ten matches over two
@@ -63,6 +167,7 @@ export function makeRunQueuePlanner() {
   const totalRunsByDivision = new Map()
 
   const nightSections = new Set()
+  const sharedByKey = new Map()
   const runLengthByDay = new Map()
 
   /**
@@ -91,7 +196,7 @@ export function makeRunQueuePlanner() {
    * @returns {Array<{date: string, count: number}>} the capacity the
    *   caller still has to account for, per date.
    */
-  function enqueue({ competition, group, dates, asFull = false }) {
+  function enqueue({ competition, group, dates, asFull = false, done = null }) {
     const teams = group.team_ids ?? []
     const size = group.pool_size ?? teams.length
 
@@ -139,7 +244,16 @@ export function makeRunQueuePlanner() {
       return needed
     }
 
-    for (const run of runs) {
+    for (const template of runs) {
+      // What is already in the plan is not owed again. A run with
+      // nothing left is dropped, and one part done is what remains of
+      // it, packed - on the day the template gave it.
+      const run = remainderOf(template, group.id, done)
+
+      if (run === null) {
+        continue
+      }
+
       // A template that spans two days needs two days to span. Where
       // the competition has only one, the group plays its whole round
       // robin that day rather than losing the half with nowhere to go
@@ -198,7 +312,7 @@ export function makeRunQueuePlanner() {
    * @param {Array} params.courts The courts these runs may use.
    * @param {Function} params.usable (court, slot) => boolean
    */
-  function prepare({ slotsFor, courts, usable }) {
+  function prepare({ slotsFor, courts, usable, sharing = false }) {
     for (const [key, queue] of groupRunQueue) {
       const date = key.slice(key.indexOf(':') + 1)
       const order = []
@@ -241,6 +355,18 @@ export function makeRunQueuePlanner() {
 
       const capacities = sections.map(section => section.capacity)
 
+      // Where courts are the limit, the section that loses courts part
+      // way through may hold more groups than it has courts for the
+      // whole run - see sharedSectionFor.
+      const shared = sharing
+        ? sharedSectionFor({ own, sections, runLength, courts, usable })
+        : null
+
+      if (shared) {
+        capacities[shared.index] = shared.capacity
+        sharedByKey.set(key, shared)
+      }
+
       for (const section of sections) {
         if (section.night) {
           nightSections.add(`${key}:${section.index}`)
@@ -261,10 +387,16 @@ export function makeRunQueuePlanner() {
       // The quota/band math itself is shared with every other planner
       // shape - see court-bands.mjs. Only the run-queue bookkeeping
       // (sections, lights, offsets) stays local to this planner.
+      const dates = [...groupRunQueue.keys()]
+        .filter(other => other.startsWith(`${competitionId}:`))
+        .map(other => other.slice(other.indexOf(':') + 1))
+        .sort()
+
       const { quotasBySection, bandsBySection } = computeSectionBands({
         divisions,
         totals,
         capacities,
+        rotation: dates.indexOf(date),
       })
 
       for (let section = 0; section < sectionCount; section++) {
@@ -304,7 +436,10 @@ export function makeRunQueuePlanner() {
     return sectionCountByDate.get(date) ?? 1
   }
 
-  function pick(competitionId, date, sectionIndex, court, { proCourt = false } = {}) {
+  function pick(
+    competitionId, date, sectionIndex, court,
+    { proCourt = false, strictQuota = false } = {}
+  ) {
     const queue = groupRunQueue.get(queueKey(competitionId, date))
 
     if (!queue || queue.length === 0) {
@@ -425,7 +560,8 @@ export function makeRunQueuePlanner() {
     // it for every group, so it only orders the choice.
     const wanted = owed.filter(entry => {
       const previous = previousSection(queue[entry.index].groupId, date)
-      return previous !== null && SECTION_OFFSET[previous] === sectionIndex
+      return previous !== null
+        && rotationTarget(previous, sectionCountFor(date)) === sectionIndex
     })
 
     // Failing the exact rotation, anything but the same section again.
@@ -440,6 +576,12 @@ export function makeRunQueuePlanner() {
     const wantedSet = new Set(wanted)
     const movedSet = new Set(moved)
 
+    // Asked to stay within the quotas, a division that has had its share
+    // here gets nothing more, spare room or not.
+    if (strictQuota && owed.length === 0) {
+      return { blocked: true }
+    }
+
     const best = owed.length > 0
       ? owed.reduce((a, b) => {
         // The band comes first, always - which court a division holds
@@ -599,5 +741,19 @@ export function makeRunQueuePlanner() {
     return (queue?.length ?? 0) > 0
   }
 
-  return { enqueue, prepare, pick, commit, previousSection, queued, hasQueued, runLengthFor }
+  /**
+   * The section, if any, whose run is played on shared courts.
+   *
+   * @param {number|string} competitionId
+   * @param {string} date
+   * @returns {?Object} see sharedSectionFor
+   */
+  function sharedFor(competitionId, date) {
+    return sharedByKey.get(queueKey(competitionId, date)) ?? null
+  }
+
+  return {
+    enqueue, prepare, pick, commit, previousSection, queued, hasQueued,
+    runLengthFor, sharedFor,
+  }
 }

package/lib/sessions.mjs

@@ -22,6 +22,40 @@ export function activePhase(sessions, date, hour) {
 
   return active
 }
+/**
+ * Which knockout rounds are on, as of this date and hour.
+ *
+ * A session may name them - "R32 and R16, the 11th, 09:00" - and then
+ * those are the only rounds that open from there, in the order the
+ * draws come down. A session that names none says nothing about
+ * rounds, and whatever the draws have left plays as it always did,
+ * which is every competition that has not been told otherwise.
+ *
+ * Read the same way as the phase: the last session to have started.
+ *
+ * @param {Array} sessions in date order
+ * @param {string} date
+ * @param {string} hour
+ * @returns {?Array<string>}
+ */
+export function activeRounds(sessions, date, hour) {
+  let active = null
+
+  for (const session of sessions) {
+    const started = session.date === date && session.start_time <= hour
+
+    if (session.date < date || started) {
+      const named = session.rounds ?? (session.round ? [session.round] : null)
+
+      active = named?.length ? named : null
+    } else {
+      break
+    }
+  }
+
+  return active
+}
+
 /**
  * The slots a competition runs on a date.
  *

package/lib/three-team-planner.mjs

@@ -114,9 +114,10 @@ function placeUnit({ unit, courts, slots, date, occupancy, darkFrom, blocks }) {
  * @param {Array<{id: number, teamIds: number[]}>} groups
  * @returns {Array<Array<{groupId: number, index: number}|null>>} slot by court
  */
-export function threeTeamUnitLayout(groups) {
+export function threeTeamUnitLayout(groups, done = null) {
   return unitLayout(groups, {
     template: GROUP_TEMPLATES[3],
     matchesFor: group => templateMatches({ teamIds: group.teamIds, groupSize: 3 }),
+    done,
   })
 }

package/package.json

@@ -40,5 +40,5 @@
   },
   "sideEffects": true,
   "type": "module",
-  "version": "0.0.3"
+  "version": "0.0.4"
 }