@opndev/tennis-match-center 0.0.1

package/lib/three-team-planner.mjs

@@ -0,0 +1,122 @@
+// SPDX-FileCopyrightText: 2026 Wesley Schwengle <wesley@opndev.io>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import { GROUP_TEMPLATES, templateMatches } from './group-schedule.mjs'
+import { buildUnits, placeLayout, unitLayout } from './paired-court-planner.mjs'
+
+/**
+ * Plans genuine 3-team groups: A v B, B v C, C v A.
+ *
+ * A 3-team round robin never needs more than one court at once (every
+ * one of its three matches shares a team with the other two, so none
+ * of them can run alongside each other) - unlike a 4-team group, which
+ * needs a pair. But a lone 3-team group still runs its whole round
+ * robin back to back with no rest between a team's own matches, the
+ * same problem 4-team bundling solves. So a singles/doubles division
+ * drawn in threes takes the very same bundling: two such groups share
+ * a court set and take turns, one group's turn a slot at a time,
+ * giving each a rest through the other's - it only ever costs one
+ * court doing it, not a pair.
+ *
+ * Team Cup is a genuine 3-team shape too (its own division's teams
+ * numbering 4 players a side, not 1 or 2) but does NOT bundle -
+ * group-schedule.mjs's own GROUP_TEMPLATES[3] comment already says
+ * why ("one court per group"). auto-planner.mjs's buildThreeTeamUnits
+ * is what tells the two apart (division.team_size, sent through as
+ * each group's own team_size) and keeps Team Cup groups out of this
+ * module's bundling entirely, each on its own dedicated unit of one -
+ * this module itself has no opinion on team_size at all, only on the
+ * groups it is actually handed.
+ *
+ * The bundling and layout mechanics live in paired-court-planner.mjs,
+ * shared with four-team-planner.mjs. This module owns only what is
+ * genuinely 3-team's own: its template (group-schedule.mjs's
+ * GROUP_TEMPLATES[3]) and the public names callers depend on.
+ *
+ * Groups are pooled across divisions on purpose - a division with a
+ * single 3-team group has nobody of its own to share with.
+ */
+
+/**
+ * @param {Object} params
+ * @param {Array<Object>} params.groups
+ *   {id, competitionId, divisionId, divisionName, divisionGender, groupName, teamIds}
+ * @param {Array<Object>} params.courts in the order they should be used
+ * @param {Array<Object>} params.slots the day's slots, with start/end minutes
+ * @param {string} params.date
+ * @param {Object} params.occupancy shared with the other planners
+ * @param {?number} params.darkFrom minutes past midnight
+ * @returns {{blocks: Array<Object>, unplaced: Array<Object>}}
+ */
+export function planThreeTeamGroups({
+  groups,
+  courts,
+  slots,
+  date,
+  occupancy,
+  darkFrom = null,
+}) {
+  const blocks = []
+  const unplaced = []
+
+  // buildUnits leaves a solitary group (nobody to bundle with) out
+  // entirely - the caller's to decide what happens to it. Here, that
+  // is placing it on its own: still one continuous run on one court,
+  // same as it always was, just with nobody to trade rest with.
+  const units = groups.length === 1 ? [groups] : threeTeamUnits(groups)
+
+  for (const unit of units) {
+    const placed = placeUnit({ unit, courts, slots, date, occupancy, darkFrom, blocks })
+
+    if (!placed) {
+      unplaced.push(...unit)
+    }
+  }
+
+  return { blocks, unplaced }
+}
+
+/**
+ * Splits the groups into units sharing a court set. A lone group (no
+ * dense/sparse choice for 3-team - see paired-court-planner.mjs's
+ * TODO) is left for the caller to place on its own, the same as
+ * four-team-planner.mjs's buildUnits does.
+ */
+export function threeTeamUnits(groups) {
+  return buildUnits(groups)
+}
+
+function placeUnit({ unit, courts, slots, date, occupancy, darkFrom, blocks }) {
+  const layout = threeTeamUnitLayout(unit.map(group => ({
+    id: group.id,
+    teamIds: group.teamIds,
+  })))
+
+  return placeLayout({
+    layout,
+    lookup: groupId => unit.find(entry => entry.id === groupId),
+    courts,
+    slots,
+    date,
+    occupancy,
+    darkFrom,
+    blocks,
+  })
+}
+
+/**
+ * Lays out a set of 3-team groups sharing one court, turn by turn - see
+ * paired-court-planner.mjs's unitLayout. A single group's own layout
+ * (unit of one, no bundling) is the degenerate case: three turns of
+ * one match each, back to back on whichever one court hosts it.
+ *
+ * @param {Array<{id: number, teamIds: number[]}>} groups
+ * @returns {Array<Array<{groupId: number, index: number}|null>>} slot by court
+ */
+export function threeTeamUnitLayout(groups) {
+  return unitLayout(groups, {
+    template: GROUP_TEMPLATES[3],
+    matchesFor: group => templateMatches({ teamIds: group.teamIds, groupSize: 3 }),
+  })
+}

package/lib/webcomponents.mjs

@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: 2026 Wesley Schwengle <wesley@opndev.io>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+/**
+ * Registers every component under its own tag.
+ *
+ * Imported for its side effect and nothing else:
+ * `import '@opndev/tennis-match-center/webcomponents'`. A component
+ * never registers itself - whether a tag is claimed, and under which
+ * name, is the page's decision. A caller wanting one component, or its
+ * own tag for it, imports the component's module and registers it.
+ */
+
+import { TennisPlanningBoardElement } from './components/planning-board.mjs'
+import { TennisRosterTeamElement } from './components/roster-team.mjs'
+import { TennisRosterBoardElement } from './components/roster-board.mjs'
+import { TennisBracketBoardElement } from './components/bracket-board.mjs'
+import { TennisScheduleBoardElement } from './components/schedule-board.mjs'
+
+TennisPlanningBoardElement.register()
+TennisRosterTeamElement.register()
+TennisRosterBoardElement.register()
+TennisBracketBoardElement.register()
+TennisScheduleBoardElement.register()

package/package.json

@@ -0,0 +1,39 @@
+{
+  "author": {
+    "email": "wesley@opndev.io",
+    "name": "Wesley Schwengle"
+  },
+  "dependencies": {
+    "@twemoji/api": ">=17.0.0"
+  },
+  "description": "Match Center",
+  "devDependencies": {
+    "jsdoc": "latest",
+    "jsdom": "latest",
+    "tap": "latest"
+  },
+  "exports": {
+    ".": "./lib/index.mjs",
+    "./webcomponents": "./lib/webcomponents.mjs"
+  },
+  "keywords": [
+    "tennis",
+    "aruba-open"
+  ],
+  "license": "AGPL-3.0-or-later",
+  "name": "@opndev/tennis-match-center",
+  "peerDependencies": {
+    "@skirbi/sugar": ">=0.1.20"
+  },
+  "private": false,
+  "scripts": {
+    "build": "rzil build",
+    "jsdoc": "jsdoc -c .jsdoc.json",
+    "pkg": "rzil pkg",
+    "release": "rzil release",
+    "test": "tap"
+  },
+  "sideEffects": true,
+  "type": "module",
+  "version": "0.0.1"
+}