domma-cms 0.102.1 → 0.104.0

package/plugins/booking/public/lib/clean.js

@@ -0,0 +1,141 @@
+/**
+ * The shapes Booking stores, cleaned from whatever a form sent. PURE, shared
+ * by the server (which trusts only these) and the admin (which uses them to
+ * show the same errors before saving).
+ *
+ * @module booking/public/lib/clean
+ */
+
+import {DAY_KEYS, isDate, toMinutes} from './time.js';
+
+export const KINDS = ['person', 'resource'];
+export const STATUSES = ['pending', 'confirmed', 'completed', 'no-show', 'cancelled'];
+export const COLOURS = ['blue', 'green', 'teal', 'purple', 'pink', 'orange', 'red', 'grey'];
+
+const objectOr = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : {});
+const str = (v, max = 200) => String(v ?? '').trim().slice(0, max);
+const int = (v, min, max, fallback) => {
+    const n = Math.round(Number(v));
+    return Number.isFinite(n) ? Math.max(min, Math.min(max, n)) : fallback;
+};
+export const EMAIL_RE = /^[^\s@<>"]+@[^\s@<>"]+\.[^\s@<>"]+$/;
+
+/** URL-safe name: "Hair cut & finish" -> "hair-cut-finish". */
+export function slugify(s) {
+    return String(s || '').toLowerCase().normalize('NFKD').replace(/[̀-ͯ]/g, '')
+        .replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 60) || 'service';
+}
+
+/** Weekly hours: {mon: [{from:'09:00', to:'17:00'}]} with nonsense dropped. */
+export function cleanHours(input) {
+    const out = {};
+    for (const day of DAY_KEYS) {
+        const list = Array.isArray(input?.[day]) ? input[day] : [];
+        out[day] = list
+            .map(w => ({from: str(w?.from, 5), to: str(w?.to, 5)}))
+            .filter(w => Number.isFinite(toMinutes(w.from)) && Number.isFinite(toMinutes(w.to)) && toMinutes(w.to) > toMinutes(w.from))
+            .slice(0, 8);
+    }
+    return out;
+}
+
+/** Days off / closures: [{from, to, label}], `to` defaulting to `from`. */
+export function cleanDaysOff(input) {
+    return (Array.isArray(input) ? input : [])
+        .map(o => ({from: str(o?.from, 10), to: str(o?.to || o?.from, 10), label: str(o?.label, 80)}))
+        .filter(o => isDate(o.from) && isDate(o.to) && o.to >= o.from)
+        .sort((a, b) => a.from.localeCompare(b.from))
+        .slice(0, 200);
+}
+
+/** Office hours Monday to Friday, the starting point for a new bookable. */
+export const WEEKDAYS_9_TO_5 = Object.fromEntries(DAY_KEYS.map(d => [d, ['mon', 'tue', 'wed', 'thu', 'fri'].includes(d) ? [{from: '09:00', to: '17:00'}] : []]));
+
+/**
+ * A person or a resource.
+ *
+ * @returns {{data: object, errors: Object<string, string>}}
+ */
+export function cleanBookable(input, current = {}) {
+    const v = {...current, ...input};
+    const errors = {};
+    const data = {
+        name: str(v.name, 80),
+        kind: KINDS.includes(v.kind) ? v.kind : 'person',
+        description: str(v.description, 500),
+        userId: str(v.userId, 64),
+        email: str(v.email, 200),
+        colour: COLOURS.includes(v.colour) ? v.colour : 'blue',
+        hours: cleanHours(v.hours ?? WEEKDAYS_9_TO_5),
+        daysOff: cleanDaysOff(v.daysOff),
+        calendarBusy: v.calendarBusy !== false,
+        active: v.active !== false,
+        order: int(v.order, 0, 100000, 0)
+    };
+    if (!data.name) errors.name = 'Give it a name.';
+    if (data.email && !EMAIL_RE.test(data.email)) errors.email = 'An email address, or leave it empty.';
+    return {data, errors};
+}
+
+/**
+ * A service.
+ *
+ * @returns {{data: object, errors: Object<string, string>}}
+ */
+export function cleanService(input, current = {}) {
+    const v = {...current, ...input};
+    const errors = {};
+    const duration = int(v.duration, 5, 24 * 60, 60);
+    const data = {
+        name: str(v.name, 80),
+        slug: slugify(v.slug || v.name),
+        description: str(v.description, 1000),
+        duration,
+        bufferBefore: int(v.bufferBefore, 0, 480, 0),
+        bufferAfter: int(v.bufferAfter, 0, 480, 0),
+        step: int(v.step, 5, 24 * 60, duration >= 60 ? 30 : Math.max(5, duration)),
+        minNoticeMinutes: int(v.minNoticeMinutes, 0, 60 * 24 * 60, 120),
+        maxAdvanceDays: int(v.maxAdvanceDays, 1, 365, 60),
+        bookables: [...new Set((Array.isArray(v.bookables) ? v.bookables : []).map(x => str(x, 64)).filter(Boolean))].slice(0, 100),
+        chooseBookable: v.chooseBookable !== false,
+        colour: COLOURS.includes(v.colour) ? v.colour : 'blue',
+        public: v.public !== false,
+        active: v.active !== false,
+        order: int(v.order, 0, 100000, 0),
+        // Pro keeps its own fields here; the free Tool carries them untouched.
+        // Merged per extension, so saving one extension's section never drops another's.
+        ext: {...objectOr(current.ext), ...objectOr(input?.ext)}
+    };
+    if (!data.name) errors.name = 'Give the service a name.';
+    if (!data.bookables.length) errors.bookables = 'Pick at least one person or room who provides it.';
+    return {data, errors};
+}
+
+/**
+ * The customer's details on a booking.
+ *
+ * @param   {object} input
+ * @param   {{askPhone?: boolean, phoneRequired?: boolean}} [rules]
+ * @returns {{data: {name: string, email: string, phone: string, notes: string}, errors: Object<string, string>}}
+ */
+export function cleanCustomer(input, {askPhone = true, phoneRequired = false} = {}) {
+    const errors = {};
+    const data = {
+        name: str(input?.name, 120),
+        email: str(input?.email, 200).toLowerCase(),
+        phone: askPhone ? str(input?.phone, 40) : '',
+        notes: str(input?.notes, 2000)
+    };
+    if (!data.name) errors.name = 'Your name, please.';
+    if (!EMAIL_RE.test(data.email)) errors.email = 'An email address we can confirm the booking to.';
+    if (askPhone && phoneRequired && !data.phone) errors.phone = 'A phone number, please.';
+    if (data.phone && !/^[+()\d\s.-]{5,40}$/.test(data.phone)) errors.phone = 'Digits, spaces and + ( ) - only.';
+    return {data, errors};
+}
+
+/** One-line label for a booking's time, in the business zone: "Tue 15/07/2031, 09:00". */
+export function whenLabel(wall) {
+    const [y, m, d] = wall.date.split('-');
+    const day = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'][wall.weekday];
+    return `${day} ${d}/${m}/${y}, ${wall.time}`;
+}

package/plugins/booking/public/lib/page-format.js

@@ -0,0 +1,121 @@
+/**
+ * What the booking page shows, worked out without a DOM: dates in words,
+ * lengths, the week strip, and whether to name the time zone. PURE, shared by
+ * the server-rendered page (plugin.public.js) and the browser (booking.js).
+ *
+ * @module booking/public/lib/page-format
+ */
+
+import {addDays, weekdayOf} from './time.js';
+
+const DAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+const SHORT = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+
+/** '2031-07-15' -> '15/07/2031'. */
+export function ddmmyyyy(date) {
+    const [y, m, d] = String(date || '').split('-');
+    return y && m && d ? `${d}/${m}/${y}` : '';
+}
+
+/** '2031-07-15' -> 'Tuesday 15/07/2031' (or 'Tue 15/07/2031' when short). */
+export function dayLabel(date, {short = false} = {}) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(String(date || ''))) return '';
+    return `${(short ? SHORT : DAYS)[weekdayOf(date)]} ${ddmmyyyy(date)}`;
+}
+
+/** The week strip's parts for one date: {weekday: 'Tue', day: '15', month: '07'}. */
+export function dayParts(date) {
+    const [, m, d] = String(date).split('-');
+    return {weekday: SHORT[weekdayOf(date)], day: String(Number(d)), month: m};
+}
+
+/** 45 -> '45 minutes', 60 -> '1 hour', 90 -> '1 hour 30 minutes'. */
+export function lengthLabel(minutes) {
+    const n = Math.max(0, Math.round(Number(minutes) || 0));
+    const h = Math.floor(n / 60);
+    const m = n % 60;
+    const parts = [];
+    if (h) parts.push(`${h} hour${h === 1 ? '' : 's'}`);
+    if (m || !h) parts.push(`${m} minute${m === 1 ? '' : 's'}`);
+    return parts.join(' ');
+}
+
+/** The seven dates of a strip starting at `start`. */
+export function weekOf(start) {
+    return Array.from({length: 7}, (_, i) => addDays(start, i));
+}
+
+/**
+ * Where the strip may go from `start`, inside the bookable range.
+ *
+ * @param   {string} start
+ * @param   {{first: string, last: string}} range
+ * @returns {{prev: string, next: string}} '' when that way is out of range
+ */
+export function weekMoves(start, range) {
+    const prev = addDays(start, -7);
+    const next = addDays(start, 7);
+    return {
+        prev: range?.first && start > range.first ? (prev < range.first ? range.first : prev) : '',
+        next: range?.last && next <= range.last ? next : ''
+    };
+}
+
+/**
+ * A note for customers whose clock is somewhere else: '' when the page's zone
+ * is theirs (or theirs cannot be told).
+ *
+ * @param   {string} siteZone
+ * @param   {string} [viewerZone]
+ */
+export function zoneNote(siteZone, viewerZone) {
+    if (!siteZone || !viewerZone || siteZone === viewerZone) return '';
+    return `Times are ${siteZone.replace(/_/g, ' ')} time.`;
+}
+
+/** The token from a manage address ('/booking/manage/<id>?t=<token>'). */
+export function tokenFrom(manage) {
+    const m = /[?&]t=([\w-]+)/.exec(String(manage || ''));
+    return m ? m[1] : '';
+}
+
+/** The .ics address for a booking. */
+export const icsUrl = (id, t) => `/api/plugins/booking/public/booking/${encodeURIComponent(id)}/ics?t=${encodeURIComponent(t)}`;
+
+/** "3 places left", "1 place left", "Full". */
+export function placesText(left) {
+    const n = Math.max(0, Math.round(Number(left) || 0));
+    return n ? `${n} place${n === 1 ? '' : 's'} left` : 'Full';
+}
+
+/**
+ * The booking form's extra questions (Booking Pro): what the page sends, and
+ * what it can tell before sending. Errors are keyed `answers.<id>`, the same
+ * as the server's, so both show in the same place.
+ *
+ * @param   {{id: string, label: string, kind: string, required?: boolean, options?: string[]}[]} fields
+ * @param   {Object<string, *>} values - as the controls hold them (strings; true/false for yes/no)
+ * @returns {{answers: Object<string, *>, errors: Object<string, string>}}
+ */
+export function answersFor(fields, values = {}) {
+    const answers = {};
+    const errors = {};
+    for (const f of fields || []) {
+        const key = `answers.${f.id}`;
+        const v = values[f.id];
+        if (f.kind === 'yesno') {
+            answers[f.id] = v === true;
+            if (f.required && v !== true) errors[key] = `${f.label}: please tick to confirm.`;
+            continue;
+        }
+        const text = String(v ?? '').trim();
+        if (!text) {
+            if (f.required) errors[key] = `${f.label}: please answer.`;
+            continue;
+        }
+        if (f.kind === 'number' && !Number.isFinite(Number(text))) { errors[key] = `${f.label}: a number, please.`; continue; }
+        if (f.kind === 'email' && !/^[^\s@<>"]+@[^\s@<>"]+\.[^\s@<>"]+$/.test(text)) { errors[key] = `${f.label}: an email address, please.`; continue; }
+        answers[f.id] = f.kind === 'number' ? Number(text) : text;
+    }
+    return {answers, errors};
+}

package/plugins/booking/public/lib/slots.js

@@ -0,0 +1,247 @@
+/**
+ * Which times can be booked - the one place that decides.
+ *
+ * The booking page asks it, the admin asks it, and the server asks it AGAIN
+ * inside the write lock before any booking is saved, so two people choosing
+ * the same slot in the same second cannot both have it. PURE: everything it
+ * needs is passed in, nothing is read.
+ *
+ * A booking blocks more than its own length: the service's buffer before and
+ * after (setting up, cleaning a room, travel). Each booking stores the span it
+ * blocks (`blockStart`, `blockEnd`), so changing a service's buffers later
+ * never moves what existing bookings hold.
+ *
+ * @module booking/public/lib/slots
+ */
+
+import {DAY_KEYS, addDays, atWallClock, daysBetween, isDate, minutes, overlaps, toMinutes, weekdayOf, wallClock} from './time.js';
+
+/** Statuses that hold their time. A cancelled booking frees it. */
+export const HOLDING = new Set(['confirmed', 'pending', 'completed', 'no-show']);
+
+/**
+ * A bookable's opening windows on one date, in minutes since midnight, after
+ * its days off and the business's closures. Windows are merged and sorted.
+ *
+ * @param   {object} bookable - {hours: {mon: [{from, to}]}, daysOff: [{from, to}]}
+ * @param   {string} date
+ * @param   {{from: string, to: string}[]} [closures] - the whole business's
+ * @returns {{from: number, to: number}[]}
+ */
+export function windowsOn(bookable, date, closures = []) {
+    const off = [...(bookable?.daysOff || []), ...(closures || [])]
+        .some(o => isDate(o?.from) && date >= o.from && date <= (isDate(o.to) ? o.to : o.from));
+    if (off) return [];
+    const list = (bookable?.hours?.[DAY_KEYS[weekdayOf(date)]] || [])
+        .map(w => ({from: toMinutes(w?.from), to: toMinutes(w?.to)}))
+        .filter(w => Number.isFinite(w.from) && Number.isFinite(w.to) && w.to > w.from)
+        .sort((a, b) => a.from - b.from);
+    const merged = [];
+    for (const w of list) {
+        const last = merged[merged.length - 1];
+        if (last && w.from <= last.to) last.to = Math.max(last.to, w.to);
+        else merged.push({...w});
+    }
+    return merged;
+}
+
+/**
+ * The span a booking at `start` for `service` blocks, as ms.
+ *
+ * @returns {{start: number, end: number, blockStart: number, blockEnd: number}}
+ */
+export function spanOf(service, start) {
+    const s = typeof start === 'number' ? start : new Date(start).getTime();
+    const end = s + minutes(service.duration);
+    return {start: s, end, blockStart: s - minutes(service.bufferBefore || 0), blockEnd: end + minutes(service.bufferAfter || 0)};
+}
+
+/** The bookables a booking holds: its own, and any it took along (a room with a trainer - Booking Pro). */
+export const holdsOf = (b) => (Array.isArray(b?.holds) && b.holds.length ? b.holds : [b?.bookableId]).filter(Boolean);
+
+/**
+ * Bookings of the same session - same service, same start, same person or
+ * room - are one class that people join (Booking Pro's places). They never
+ * clash with each other; they count towards the class's places instead.
+ */
+export const sameSession = (b, serviceId, startMs, bookableId) =>
+    b.serviceId === serviceId && b.bookableId === bookableId && new Date(b.startAt).getTime() === startMs;
+
+/** The rules a service runs under when no extension adds any. */
+export const PLAIN = Object.freeze({capacity: 1, companions: [], maxPerDay: 0});
+
+/**
+ * How many places are left for this span on one bookable: 0 when it is taken.
+ * `capacity` 1 (the plain case) answers 1 or 0.
+ *
+ * @param   {{start: number, end: number, blockStart: number, blockEnd: number}} span
+ * @param   {string} bookableId
+ * @param   {object[]} bookings - existing ones, any bookable
+ * @param   {{startAt: string, endAt: string}[]} [busy] - this bookable's other commitments (its Calendar)
+ * @param   {string} [ignoreId] - a booking being moved does not clash with itself
+ * @param   {{serviceId?: string, capacity?: number, primary?: boolean, sessionOf?: string, maxPerDay?: number, dayOf?: Function}} [opts]
+ *          primary: this bookable is the one booked (a companion never hosts a session);
+ *          sessionOf: for a companion, the primary whose session may share it.
+ */
+export function placesLeft(span, bookableId, bookings, busy = [], ignoreId = '', opts = {}) {
+    const capacity = Math.max(1, Number(opts.capacity) || 1);
+    const host = opts.primary === false ? opts.sessionOf : bookableId;
+    let joined = 0;
+    for (const b of bookings || []) {
+        if (b.id === ignoreId || !HOLDING.has(b.status) || !holdsOf(b).includes(bookableId)) continue;
+        const bs = new Date(b.blockStart || b.startAt).getTime();
+        const be = new Date(b.blockEnd || b.endAt).getTime();
+        if (!overlaps(span.blockStart, span.blockEnd, bs, be)) continue;
+        if (capacity > 1 && host && sameSession(b, opts.serviceId, span.start, host)) { joined++; continue; }
+        return 0;
+    }
+    for (const x of busy || []) {
+        // Busy time is the person's own; buffers are ours to keep, so compare the booking itself.
+        if (overlaps(span.start, span.end, new Date(x.startAt).getTime(), new Date(x.endAt).getTime())) return 0;
+    }
+    // A day's limit counts sessions, not people in them: joining a class that already runs is never over it.
+    if (opts.maxPerDay > 0 && !joined && typeof opts.dayOf === 'function') {
+        const day = opts.dayOf(span.start);
+        const sessions = new Set();
+        for (const b of bookings || []) {
+            if (b.id === ignoreId || !HOLDING.has(b.status) || b.bookableId !== bookableId || opts.dayOf(new Date(b.startAt).getTime()) !== day) continue;
+            sessions.add(`${b.serviceId}|${b.startAt}`);
+        }
+        if (sessions.size >= opts.maxPerDay) return 0;
+    }
+    return Math.max(0, capacity - joined);
+}
+
+/** Is a bookable free for this span? (The plain, one-place case of placesLeft.) */
+export function isFree(span, bookableId, bookings, busy = [], ignoreId = '') {
+    return placesLeft(span, bookableId, bookings, busy, ignoreId) > 0;
+}
+
+/**
+ * Who can take a booking at this span: for each candidate with a place left,
+ * the companions it would take along (one from each group, preferring those
+ * its session already holds). Candidates a companion group cannot serve drop out.
+ *
+ * @param   {object} p
+ * @param   {object} p.service
+ * @param   {{id: string}[]} p.candidates
+ * @param   {{id: string}[][]} [p.companions] - groups of bookables; one of each is needed as well
+ * @param   {object} p.span
+ * @param   {object[]} p.bookings
+ * @param   {Object<string, object[]>} [p.busy]
+ * @param   {string} [p.ignoreId]
+ * @param   {object} [p.rules]
+ * @param   {Function} [p.dayOf]
+ * @returns {{bookableId: string, holds: string[], left: number}[]}
+ */
+export function whoCanTake({service, candidates, companions = [], span, bookings, busy = {}, ignoreId = '', rules = PLAIN, dayOf}) {
+    const out = [];
+    for (const bk of candidates || []) {
+        const left = placesLeft(span, bk.id, bookings, busy[bk.id], ignoreId,
+            {serviceId: service.id, capacity: rules.capacity, primary: true, maxPerDay: rules.maxPerDay, dayOf});
+        if (!left) continue;
+        const session = (bookings || []).find(b => b.id !== ignoreId && HOLDING.has(b.status) && sameSession(b, service.id, span.start, bk.id));
+        const holds = [bk.id];
+        let ok = true;
+        for (const group of companions || []) {
+            const options = [...group].sort((a, b) => Number(holdsOf(session).includes(b.id)) - Number(holdsOf(session).includes(a.id)));
+            const pick = options.find(c => c.id !== bk.id && !holds.includes(c.id)
+                && placesLeft(span, c.id, bookings, busy[c.id], ignoreId, {serviceId: service.id, capacity: rules.capacity, primary: false, sessionOf: bk.id}) > 0);
+            if (!pick) { ok = false; break; }
+            holds.push(pick.id);
+        }
+        if (ok) out.push({bookableId: bk.id, holds, left});
+    }
+    return out;
+}
+
+/**
+ * Every bookable start for a service, day by day.
+ *
+ * @param   {object} input
+ * @param   {object} input.service - {id, duration, bufferBefore, bufferAfter, step, minNoticeMinutes, maxAdvanceDays, bookables}
+ * @param   {object[]} input.bookables - the service's providers (active ones)
+ * @param   {object[]} input.bookings
+ * @param   {Object<string, object[]>} [input.busy] - bookableId -> busy spans
+ * @param   {string} input.from - first date
+ * @param   {string} input.to - last date
+ * @param   {Date|number} input.now
+ * @param   {string} input.tz
+ * @param   {{from: string, to: string}[]} [input.closures]
+ * @param   {string} [input.ignoreId]
+ * @param   {object} [input.rules] - capacity, companions (groups of bookables), maxPerDay - from extensions
+ * @param   {boolean} [input.includeFull] - also list starts whose class is full ({full: true}), for a waiting list
+ * @returns {{date: string, slots: {start: string, end: string, time: string, bookableIds: string[], left: number, full?: boolean}[]}[]}
+ */
+export function slotsFor({service, bookables, bookings, busy = {}, from, to, now, tz, closures = [], ignoreId = '', rules = PLAIN, includeFull = false}) {
+    const nowMs = new Date(now).getTime();
+    const earliest = nowMs + minutes(Number(service.minNoticeMinutes) || 0);
+    const latest = Number(service.maxAdvanceDays) > 0 ? nowMs + Number(service.maxAdvanceDays) * 86400000 : Infinity;
+    const step = Math.max(5, Number(service.step) || Number(service.duration) || 30);
+    const dayOf = (ms) => wallClock(ms, tz).date;
+    const days = [];
+    if (!isDate(from) || !isDate(to) || !(Number(service.duration) > 0)) return days;
+    const companions = rules.companions || [];
+
+    for (const date of daysBetween(from, to, 92)) {
+        const byStart = new Map();
+        for (const bk of bookables || []) {
+            for (const w of windowsOn(bk, date, closures)) {
+                for (let m = w.from; m + Number(service.duration) <= w.to; m += step) {
+                    const start = atWallClock(date, m, tz).getTime();
+                    // A start the clocks skipped lands on another wall time - it is not this one.
+                    if (wallClock(start, tz).minutes !== m || wallClock(start, tz).date !== date) continue;
+                    if (start < earliest || start > latest) continue;
+                    const span = spanOf(service, start);
+                    const key = String(start);
+                    const [can] = whoCanTake({service, candidates: [bk], companions, span, bookings, busy, ignoreId, rules, dayOf});
+                    if (!can) {
+                        const fullSession = includeFull && rules.capacity > 1
+                            && (bookings || []).some(b => b.id !== ignoreId && HOLDING.has(b.status) && sameSession(b, service.id, start, bk.id));
+                        if (fullSession && !byStart.has(key)) {
+                            byStart.set(key, {start: new Date(start).toISOString(), end: new Date(span.end).toISOString(), time: wallClock(start, tz).time, bookableIds: [], left: 0, full: true, fullIds: [bk.id]});
+                        } else if (fullSession && byStart.get(key).full) byStart.get(key).fullIds.push(bk.id);
+                        continue;
+                    }
+                    const slot = byStart.get(key);
+                    if (!slot || slot.full) {
+                        byStart.set(key, {start: new Date(start).toISOString(), end: new Date(span.end).toISOString(), time: wallClock(start, tz).time, bookableIds: [bk.id], left: can.left});
+                    } else {
+                        slot.bookableIds.push(bk.id);
+                        slot.left = Math.max(slot.left, can.left);
+                    }
+                }
+            }
+        }
+        const slots = [...byStart.values()].sort((a, b) => a.start.localeCompare(b.start));
+        days.push({date, slots});
+    }
+    return days;
+}
+
+/**
+ * Who takes a booking made for "anyone": a class that already runs first (so
+ * people end up together, not in two half-empty sessions), then the provider
+ * with the fewest bookings that day, then the first listed.
+ *
+ * @param   {string[]} ids - free at that time
+ * @param   {object[]} bookings
+ * @param   {string} date
+ * @param   {string} tz
+ * @param   {{serviceId?: string, start?: number}} [session]
+ * @returns {string}
+ */
+export function pickBookable(ids, bookings, date, tz, session = {}) {
+    if (!ids.length) return '';
+    const running = session.serviceId ? ids.find(id => (bookings || []).some(b => HOLDING.has(b.status) && sameSession(b, session.serviceId, session.start, id))) : '';
+    if (running) return running;
+    const load = (id) => (bookings || []).filter(b => b.bookableId === id && HOLDING.has(b.status) && wallClock(b.startAt, tz).date === date).length;
+    return [...ids].map((id, i) => ({id, i, n: load(id)})).sort((a, b) => a.n - b.n || a.i - b.i)[0].id;
+}
+
+/** The first date that could have a slot, and the last, for a service - the booking page's range. */
+export function bookingRange(service, now, tz) {
+    const first = wallClock(new Date(new Date(now).getTime() + minutes(Number(service.minNoticeMinutes) || 0)), tz).date;
+    const days = Math.max(1, Math.min(365, Number(service.maxAdvanceDays) || 60));
+    return {first, last: addDays(wallClock(now, tz).date, days)};
+}

package/plugins/booking/public/lib/time.js

@@ -0,0 +1,131 @@
+/**
+ * Wall-clock time in a named zone, without a library.
+ *
+ * Bookings are stored as UTC instants. Opening hours are wall-clock times
+ * ("09:00 on Mondays") in the business's zone, which moves against UTC twice a
+ * year. Everything that turns one into the other is here, PURE and shared by
+ * the server, the admin and the booking page (public/ is served; lib/ is not).
+ *
+ * Dates are 'YYYY-MM-DD' strings and times 'HH:MM', never Date objects, until
+ * the moment they become an instant: a Date carries the host's zone, and the
+ * host is not where the business is.
+ *
+ * @module booking/public/lib/time
+ */
+
+export const DAY_KEYS = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
+const MINUTE = 60000;
+
+const formatters = new Map();
+function partsFormatter(tz) {
+    if (!formatters.has(tz)) {
+        formatters.set(tz, new Intl.DateTimeFormat('en-GB', {
+            timeZone: tz, hourCycle: 'h23', year: 'numeric', month: '2-digit', day: '2-digit',
+            hour: '2-digit', minute: '2-digit', second: '2-digit', weekday: 'short'
+        }));
+    }
+    return formatters.get(tz);
+}
+
+/** A zone name Intl accepts, else 'Europe/London'. */
+export function cleanZone(tz) {
+    const name = String(tz || '').trim();
+    if (!name) return 'Europe/London';
+    try { partsFormatter(name); return name; } catch { return 'Europe/London'; }
+}
+
+/** The wall clock in `tz` at an instant: {date, time, weekday (0 = Sunday), minutes (since midnight)}. */
+export function wallClock(instant, tz) {
+    const at = instant instanceof Date ? instant : new Date(instant);
+    const p = {};
+    for (const {type, value} of partsFormatter(cleanZone(tz)).formatToParts(at)) p[type] = value;
+    const hour = p.hour === '24' ? '00' : p.hour;
+    return {
+        date: `${p.year}-${p.month}-${p.day}`,
+        time: `${hour}:${p.minute}`,
+        weekday: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'].indexOf(p.weekday),
+        minutes: Number(hour) * 60 + Number(p.minute)
+    };
+}
+
+/** How far `tz` is ahead of UTC at an instant, in milliseconds. */
+export function zoneOffset(instant, tz) {
+    const at = instant instanceof Date ? instant : new Date(instant);
+    const p = {};
+    for (const {type, value} of partsFormatter(cleanZone(tz)).formatToParts(at)) p[type] = value;
+    const asUtc = Date.UTC(Number(p.year), Number(p.month) - 1, Number(p.day), Number(p.hour === '24' ? 0 : p.hour), Number(p.minute), Number(p.second));
+    return asUtc - Math.floor(at.getTime() / 1000) * 1000;
+}
+
+/**
+ * The instant a wall-clock time in `tz` happens.
+ *
+ * A time the clocks skip (01:30 on the spring-forward night in London) comes
+ * out an hour later, as a wall clock would read it; a time that happens twice
+ * (the autumn night) is the first of the two.
+ *
+ * @param   {string} date - 'YYYY-MM-DD'
+ * @param   {string|number} time - 'HH:MM', or minutes since midnight
+ * @param   {string} tz
+ * @returns {Date}
+ */
+export function atWallClock(date, time, tz) {
+    const [y, m, d] = String(date).split('-').map(Number);
+    const mins = typeof time === 'number' ? time : toMinutes(time);
+    const guess = Date.UTC(y, m - 1, d, 0, mins);
+    // The zone's offset a day either side: across a change they differ, and
+    // the wall time belongs to one of them, both (autumn), or neither (spring).
+    const before = zoneOffset(new Date(guess - 86400000), tz);
+    const after = zoneOffset(new Date(guess + 86400000), tz);
+    const want = ((mins % 1440) + 1440) % 1440;
+    const fits = [guess - before, guess - after].filter(t => wallClock(new Date(t), tz).minutes === want);
+    return new Date(fits.length ? Math.min(...fits) : guess - before);
+}
+
+/** 'HH:MM' -> minutes since midnight (NaN when it is not a time). '24:00' is 1440, the end of a day. */
+export function toMinutes(time) {
+    const m = /^(\d{1,2}):(\d{2})$/.exec(String(time ?? '').trim());
+    if (!m) return NaN;
+    const h = Number(m[1]);
+    const min = Number(m[2]);
+    if (min > 59 || h > 24 || (h === 24 && min)) return NaN;
+    return h * 60 + min;
+}
+
+/** Minutes since midnight -> 'HH:MM'. */
+export function fromMinutes(mins) {
+    const n = Math.max(0, Math.min(1440, Math.round(mins)));
+    return `${String(Math.floor(n / 60)).padStart(2, '0')}:${String(n % 60).padStart(2, '0')}`;
+}
+
+/** A calendar date `n` days on (UTC arithmetic on a date only - no zone involved). */
+export function addDays(date, n) {
+    const [y, m, d] = String(date).split('-').map(Number);
+    return new Date(Date.UTC(y, m - 1, d + n)).toISOString().slice(0, 10);
+}
+
+/** 0 (Sunday) to 6 for a calendar date. */
+export function weekdayOf(date) {
+    const [y, m, d] = String(date).split('-').map(Number);
+    return new Date(Date.UTC(y, m - 1, d)).getUTCDay();
+}
+
+/** Is this a real 'YYYY-MM-DD'? */
+export function isDate(date) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(String(date ?? ''))) return false;
+    const [y, m, d] = date.split('-').map(Number);
+    const t = new Date(Date.UTC(y, m - 1, d));
+    return t.getUTCFullYear() === y && t.getUTCMonth() === m - 1 && t.getUTCDate() === d;
+}
+
+/** Days from `from` to `to`, both included. */
+export function daysBetween(from, to, limit = 400) {
+    const out = [];
+    for (let d = from; d <= to && out.length < limit; d = addDays(d, 1)) out.push(d);
+    return out;
+}
+
+/** Do [aStart, aEnd) and [bStart, bEnd) overlap? Instants as ms. */
+export const overlaps = (aStart, aEnd, bStart, bEnd) => aStart < bEnd && bStart < aEnd;
+
+export const minutes = (n) => n * MINUTE;

package/plugins/booking/templates/booking.html

@@ -0,0 +1,5 @@
+<main class="container bk-page" id="dm-booking" data-booking-page="{{page}}">
+{{body}}
+</main>
+<link rel="stylesheet" href="/plugins/booking/public/booking.css?v={{assetV}}">
+<script type="module" src="/plugins/booking/public/booking.js?v={{assetV}}"></script>