@opndev/tennis-match-center 0.0.2 → 0.0.4

package/lib/components/roster-board.mjs

@@ -5,6 +5,37 @@
 import { HTMLElementSugar } from '@skirbi/sugar'
 import { seedGroups, groupName } from '../roster-seeding.mjs'
 
+const DAY = new Intl.DateTimeFormat('en-GB', {
+  weekday: 'short',
+  day: 'numeric',
+  month: 'short',
+  timeZone: 'UTC',
+})
+
+/**
+ * The day an ISO timestamp falls on, read off the string so the event's
+ * own clock is what is said, not the browser's.
+ *
+ * @param {string} iso
+ * @returns {string}
+ */
+function dayOf(iso) {
+  return DAY.format(new Date(`${iso.slice(0, 10)}T12:00:00Z`))
+}
+
+/**
+ * When a group starts playing, as far as the planning knows it: the
+ * first match of each day it plays.
+ *
+ * @param {Array<string>} starts - ISO timestamps, one per day
+ * @returns {string}
+ */
+export function startsLine(starts) {
+  return starts
+    .map(iso => `${dayOf(iso)}, ${iso.slice(11, 16)}`)
+    .join(' / ')
+}
+
 /**
  * <tennis-roster-board api="..." save-api="...">
  *
@@ -173,11 +204,11 @@ export class TennisRosterBoardElement extends HTMLElementSugar {
         .map(id => this.saved.teams.find(team => team.id === id))
         .filter(Boolean)
 
-      columns.appendChild(this.columnFor(group.name, teams))
+      columns.appendChild(this.columnFor(group.name, teams, group.starts))
     }
   }
 
-  columnFor(currentGroupName, teams) {
+  columnFor(currentGroupName, teams, starts = []) {
     const column = document.createElement('div')
 
     column.dataset.group = currentGroupName ?? ''
@@ -212,6 +243,15 @@ export class TennisRosterBoardElement extends HTMLElementSugar {
     count.textContent = String(teams.length)
     heading.appendChild(count)
 
+    if (starts?.length) {
+      const when = document.createElement('p')
+
+      when.dataset.planned = ''
+      when.title = 'First match of the group, per day'
+      when.textContent = startsLine(starts)
+      column.appendChild(when)
+    }
+
     const list = document.createElement('div')
     list.dataset.list = ''
     column.appendChild(list)

package/lib/components/schedule-board.mjs

@@ -10,7 +10,7 @@ import { competitionHue, divisionHues } from '../division-hues.mjs'
 import { setNameText } from '../flags.mjs'
 import { rowsForDate } from '../day-rows.mjs'
 import { courtCanTake, toMinutes } from '../lighting.mjs'
-import { PX_PER_MINUTE, TennisDayGridElement } from './day-grid.mjs'
+import { TennisDayGridElement } from './day-grid.mjs'
 import { withBusyButton } from '../busy-button.mjs'
 
 const KNOCKOUT_ROUND_ORDER = ['R256', 'R128', 'R64', 'R32', 'R16', 'QF', 'SF', 'F']
@@ -468,10 +468,15 @@ export class TennisScheduleBoardElement extends HTMLElementSugar {
    * Sent as a delete rather than as an empty save: which rows to drop
    * follows from the event and the date, and a board that holds one
    * day at a time could not send the rest of them to be replaced.
+   *
+   * A played match is not dropped. The database refuses to let the
+   * planner delete or move one, so the server keeps it - and a board
+   * that emptied its own copy anyway would show a morning that has
+   * been played as an empty morning until the next reload.
    */
   clearAll() {
     return this.clear(this.getConfig()['clear-api'], null, () => {
-      this.matches = []
+      this.matches = this.matches.filter(match => match.played === true)
       this.unscheduledByCompetition = new Map()
     })
   }
@@ -482,7 +487,9 @@ export class TennisScheduleBoardElement extends HTMLElementSugar {
     }
 
     return this.clear(`${this.getConfig()['day-api']}/${date}`, date, () => {
-      this.matches = this.matches.filter(match => match.date !== date)
+      this.matches = this.matches.filter(match =>
+        match.date !== date || match.played === true
+      )
     })
   }
 
@@ -948,9 +955,6 @@ export class TennisScheduleBoardElement extends HTMLElementSugar {
       rows: this.rowsFor(date),
       cellFor: (court, courtIndex, slot) => this.cellFor(court, date, slot),
       compact: this.$('[data-narrow-empty]')?.checked ?? false,
-      // A scheduled cell carries four names and what is being played,
-      // where a planned one carries a division and a group.
-      scale: PX_PER_MINUTE * 2,
     })
 
     return grid

package/lib/court-bands.mjs

@@ -20,13 +20,18 @@
  *   division needs across every section, keyed by division id.
  * @param {number[]} params.capacities How many courts each section can
  *   actually host (already filtered for lit/usable, per caller).
+ * @param {number} [params.rotation] Which day of the competition this
+ *   is, counting from zero. Where a division's runs do not divide
+ *   evenly over the sections, the extra ones move two sections on each
+ *   day, the same way its groups do.
  * @returns {{
  *   quotasBySection: Array<Map<string|number, number>>,
  *   bandsBySection: Array<Map<string|number, {start: number, end: number}>>
  * }}
  */
-export function computeSectionBands({ divisions, totals, capacities }) {
+export function computeSectionBands({ divisions, totals, capacities, rotation = 0 }) {
   const sectionCount = capacities.length
+  const evened = evenQuotas({ divisions, totals, capacities, rotation })
   const quotasBySection = []
   const bandsBySection = []
   const granted = new Map(divisions.map(id => [id, 0]))
@@ -104,6 +109,15 @@ export function computeSectionBands({ divisions, totals, capacities }) {
       room -= 1
     }
 
+    // Where every division can be spread as evenly as its runs allow
+    // and the sections can hold it, that is the answer, whatever the
+    // capacity-driven shares above came to.
+    if (evened) {
+      for (const id of divisions) {
+        quotas.set(id, evened[section].get(id))
+      }
+    }
+
     // The band a division sits in, as a fraction of the section's own
     // courts, straight from what it was just given. Divisions come in
     // priority order, so the strongest field takes the lowest courts
@@ -129,6 +143,71 @@ export function computeSectionBands({ divisions, totals, capacities }) {
   return { quotasBySection, bandsBySection }
 }
 
+/**
+ * Each division's runs spread as evenly over the sections as they go.
+ *
+ * Every division takes the whole number of runs that divides evenly in
+ * each section, and whatever is left over goes one to a section, to the
+ * sections with the most room, so the extra run of one division sits
+ * where another's does not and the sections fill alike. Ties go to the
+ * earliest section, turned two sections on for each day of rotation:
+ * the group that had an extra run in a section yesterday is the one a
+ * rotation sends to the section two on today.
+ *
+ * Only when the sections can hold it. If they cannot, the caller's own
+ * capacity-driven shares are all there is, and this says so with null.
+ *
+ * @returns {?Array<Map<string|number, number>>} quotas by section
+ */
+function evenQuotas({ divisions, totals, capacities, rotation }) {
+  const sections = capacities.length
+
+  if (sections === 0) {
+    return null
+  }
+
+  const load = new Array(sections).fill(0)
+  const quotas = capacities.map(() => new Map())
+
+  for (const id of divisions) {
+    const base = Math.floor((totals.get(id) ?? 0) / sections)
+
+    for (let section = 0; section < sections; section++) {
+      quotas[section].set(id, base)
+      load[section] += base
+    }
+  }
+
+  // Earliest first, turned by the day: [0, 1, 2], then [2, 0, 1].
+  const turn = (2 * rotation) % sections
+  const order = Array.from({ length: sections }, (_, i) => (i + turn) % sections)
+
+  for (const id of divisions) {
+    const extra = (totals.get(id) ?? 0) % sections
+    const given = new Set()
+
+    for (let i = 0; i < extra; i++) {
+      let best = -1
+
+      for (const section of order) {
+        if (given.has(section)) {
+          continue
+        }
+
+        if (best === -1 || capacities[section] - load[section] > capacities[best] - load[best]) {
+          best = section
+        }
+      }
+
+      given.add(best)
+      load[best] += 1
+      quotas[best].set(id, quotas[best].get(id) + 1)
+    }
+  }
+
+  return load.every((runs, section) => runs <= capacities[section]) ? quotas : null
+}
+
 /**
  * How far a court (as a fraction of its list) sits from a division's
  * band. Zero inside the band; a band is an interval, not a point, so a

package/lib/four-team-planner.mjs

@@ -211,6 +211,6 @@ export function fourTeamUnitSizes(count, { dense = false } = {}) {
  * @param {Array<{id: number, teamIds: number[]}>} groups
  * @returns {Array<Array<{groupId: number, index: number}>>} slot by court
  */
-export function fourTeamUnitLayout(groups) {
-  return unitLayout(groups, { template: FOUR_TEAM_TEMPLATE, matchesFor: fourTeamMatches })
+export function fourTeamUnitLayout(groups, done = null) {
+  return unitLayout(groups, { template: FOUR_TEAM_TEMPLATE, matchesFor: fourTeamMatches, done })
 }

package/lib/index.mjs

@@ -2,6 +2,6 @@
 //
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-const VERSION = "0.0.2";export { VERSION }
+const VERSION = "0.0.4";export { VERSION }
 export { autoFillBracket } from './bracket-autofill.mjs'
 

package/lib/knockout-draw.mjs

@@ -58,6 +58,7 @@ export class KnockoutDraw {
     this.lastCourts = null
     this.lastParts = 1
     this.freeFrom = -Infinity
+    this.freeDate = null
   }
 
   /** Whether every round of the draw has been planned. */
@@ -108,11 +109,22 @@ export class KnockoutDraw {
    * Whether this draw may go on in this slot: it has a round left and
    * has had whatever rest it is owed.
    *
+   * Rest is owed within a day and a night is more of it than any rule
+   * asks, so a draw arriving on a new date is ready from its first
+   * slot. The slot index it was last free from means nothing on
+   * another day's list, which is what used to lock a draw that could
+   * not finish out of every day after it.
+   *
    * @param {number} slotIndex
+   * @param {?string} [date]
    * @returns {boolean}
    */
-  readyAt(slotIndex) {
-    return !this.done && slotIndex >= this.freeFrom
+  readyAt(slotIndex, date = null) {
+    if (this.done) {
+      return false
+    }
+
+    return date !== this.freeDate || slotIndex >= this.freeFrom
   }
 
   /**
@@ -123,19 +135,31 @@ export class KnockoutDraw {
    * narrow it leaves the parts; quarters and eighths need parts that
    * still hold matches of their own.
    *
+   * A round does not have to be a power of two. Three of a round of
+   * eight played and five left is the same thing as a bracket with
+   * byes, and five still halves - 3 then 2 - which is what pays for
+   * the rest. A cut that would leave a part with nothing in it is not
+   * offered.
+   *
    * @param {boolean} split Whether cutting is allowed at all.
    * @returns {Array<{parts: number, count: number}>} Courts needed
-   *   (count) for each number of parts.
+   *   (count) for the widest part.
    */
   cuts(split) {
     const options = []
 
     for (const parts of SPLIT_SIZES) {
-      if (parts > 1 && (!split || this.width % parts !== 0)) {
+      if (parts > 1 && !split) {
         continue
       }
 
-      const count = parts === 1 ? this.width : this.width / parts
+      const count = parts === 1 ? this.width : Math.ceil(this.width / parts)
+
+      // Every part has to hold something: a round of five in four
+      // parts is three parts and an empty one.
+      if (parts > 1 && count * (parts - 1) >= this.width) {
+        continue
+      }
 
       if (parts > 2 && count < MIN_ROUND_PART) {
         continue
@@ -190,9 +214,11 @@ export class KnockoutDraw {
    * @param {number} params.parts The cut they were booked in.
    * @param {number} params.slotIndex Where the cut started.
    * @param {number} params.restSlots Slots owed after a whole round.
+   * @param {?string} [params.date] The day that slot index belongs to.
    */
-  book({ count, parts, slotIndex, restSlots }) {
+  book({ count, parts, slotIndex, restSlots, date = null }) {
     this.placed += count
+    this.freeDate = date
 
     if (this.placedInRound + count < this.width) {
       this.placedInRound += count

package/lib/knockout-planner.mjs

@@ -4,7 +4,7 @@
 
 import { MATCH_MINUTES, REST_MINUTES } from './match-time.mjs'
 import { SPLIT_SIZES } from './knockout-draw.mjs'
-import { activePhase, activeSession } from './sessions.mjs'
+import { activePhase, activeRounds, activeSession } from './sessions.mjs'
 
 
 /**
@@ -242,7 +242,7 @@ function placeRound(item, held, day, where) {
     }
   }
 
-  draw.book({ count: placed, parts, slotIndex, restSlots })
+  draw.book({ count: placed, parts, slotIndex, restSlots, date: day.date })
 }
 
 /**
@@ -327,8 +327,11 @@ export function assignKnockout(day, { competitions, draws, sessions, split }) {
     const ownSession = activeSession(ownSessions, date)
     const restSlots = restSlotsFor(ownSession?.playtime ?? MATCH_MINUTES)
 
+    // A slot with no phase of its own belongs to a replan, which owns
+    // the whole day whatever the session had meant it for.
     const firstSlot = own.findIndex(slot =>
-      (slot.phase ?? activePhase(ownSessions, date, slot.key)) === 'knockout'
+      slot.phase === null
+        || (slot.phase ?? activePhase(ownSessions, date, slot.key)) === 'knockout'
     )
 
     if (firstSlot === -1) {
@@ -349,6 +352,7 @@ export function assignKnockout(day, { competitions, draws, sessions, split }) {
 
     for (let slotIndex = firstSlot; slotIndex < own.length; slotIndex++) {
       const slot = own[slotIndex]
+      const onRounds = activeRounds(ownSessions, date, slot.key)
 
       /** The lane's courts with nothing on them in this slot. */
       function free() {
@@ -360,7 +364,11 @@ export function assignKnockout(day, { competitions, draws, sessions, split }) {
       }
 
       let ready = units
-        .filter(draw => draw.readyAt(slotIndex))
+        .filter(draw => draw.readyAt(slotIndex, date))
+        // A session may say which rounds are on. Nothing else opens
+        // until one does, and a draw whose turn has not come waits
+        // for the day it was given rather than running ahead.
+        .filter(draw => onRounds == null || onRounds.includes(draw.round?.round))
         .sort((a, b) => (b.width - a.width) || (b.level - a.level))
 
       if (ready.length === 0) {

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)
+        }
+      }
+    }
+  }
 }