@aglyn/plugins-bookings 1.0.0-beta.143

package/src/lib/components/bookings-console-page.js

@@ -0,0 +1,743 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ 'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { checkQuota, crmContactByEmailHref, pluginDocsHelp } from "@aglyn/aglyn";
+import { BOOKINGS_BOOKER_PARAM, normalizeContactEmail } from "@aglyn/aglyn";
+import { PLATFORM_BRAND_NAME } from "@aglyn/aglyn/app-utils/platform-brand";
+import { isBookingReminderDue } from "../model/index.js";
+import { AppLink, CardDisplay, HelpTip, useConfirmationContext } from "@aglyn/shared-ui-jsx";
+import QuotaReadoutComponent from "@aglyn/shared-ui-jsx/components/quota-readout.component";
+import { useSnackbar } from "@aglyn/shared-ui-snackstack";
+import { Timestamp } from "@aglyn/shared-util-timestamp";
+import { Button, Dialog, DialogActions, DialogContent, DialogTitle, FormControlLabel, Stack, Switch, TextField, Typography } from "@mui/material";
+import { collection, doc, limit, orderBy, query, setDoc, updateDoc } from "firebase/firestore";
+import { useParams, useSearchParams } from "next/navigation";
+import { useCallback, useState } from "react";
+import { useFirestore, useFirestoreCollection, useHostResourceApi, useUser, writeGuardedBySeed } from "@aglyn/tenant-feature-instance";
+import { authorizedFetch } from "@aglyn/shared-util-http/authorized-token";
+const WEEKDAYS = [
+    'Sun',
+    'Mon',
+    'Tue',
+    'Wed',
+    'Thu',
+    'Fri',
+    'Sat'
+];
+/** "09:00-12:00, 13:00-17:00" → open intervals in minutes. */ function parseWindows(input) {
+    const windows = [];
+    for (const chunk of input.split(',')){
+        const match = chunk.trim().match(/^(\d{1,2}):(\d{2})\s*-\s*(\d{1,2}):(\d{2})$/);
+        if (!match) continue;
+        const start = Number(match[1]) * 60 + Number(match[2]);
+        const end = Number(match[3]) * 60 + Number(match[4]);
+        if (end > start && end <= 24 * 60) windows.push({
+            start,
+            end
+        });
+    }
+    return windows;
+}
+function formatWindows(windows) {
+    const pad = (minutes)=>`${String(Math.floor(minutes / 60)).padStart(2, '0')}:${String(minutes % 60).padStart(2, '0')}`;
+    return (windows != null ? windows : []).map((window)=>`${pad(window.start)}-${pad(window.end)}`).join(', ');
+}
+/**
+ * Bookings manager (AGL-159): bookable services with weekly availability
+ * windows, and the upcoming-bookings list with cancel. Visitors book via
+ * the org /api/bookings endpoints; confirmations email through the
+ * env-gated Resend path. Plan-gated (`bookings` flag + `servicesPerHost`).
+ */ export function BookingsConsolePage(props) {
+    var _ref, _ref1, _ref2, _ref3, _ref4, _ref5, _ref6;
+    const { hostId, entitled, org } = props;
+    const firestore = useFirestore();
+    const createHostResource = useHostResourceApi();
+    const { enqueueSnackbar } = useSnackbar();
+    const { confirm } = useConfirmationContext();
+    // The id token the refund route authenticates with (AGL-2315).
+    const { data: user } = useUser();
+    /*
+   * Where a booker's CONTACT is (AGL-2622). A booking updated a person in
+   * the CRM by the address it carried, and the row links there by that
+   * address — the Contacts list holds the id nothing here does and opens
+   * the record on one match. The address comes from the SHARED builder
+   * rather than the CRM plugin, the way the commerce dialog's does: a
+   * plugin importing a sibling is a cycle waiting for its third edge, and
+   * the shared builder is pinned against the CRM's own routes by a spec.
+   * `null` until the route params settle, so no row renders a link to
+   * nowhere.
+   */ const params = useParams();
+    const siteContext = (params == null ? void 0 : params.orgSlug) && (params == null ? void 0 : params.host) ? {
+        orgSlug: String(params.orgSlug),
+        host: String(params.host)
+    } : null;
+    /*
+   * The list narrowed to one booker (AGL-2660): a contact's record links
+   * here with `?email=`, and the page answers with every booking that
+   * address holds — past ones too, because that link asks about a
+   * person's history rather than the week ahead. The same match rule as
+   * the row's own "View in CRM": the address, normalized, equal. `null`
+   * outside a router, where there is no query to read.
+   */ const searchParams = useSearchParams();
+    const bookerFilter = normalizeContactEmail(searchParams == null ? void 0 : searchParams.get(BOOKINGS_BOOKER_PARAM));
+    const { basePath } = props;
+    const { data: serviceDocs, status: servicesStatus, /**
+     * The rows this editor is seeded from are unconfirmed by the server
+     * (AGL-1358). Editing copies a whole stored service into `draft` and
+     * writes all of it back, so `merge: true` protects nothing. `windows` is
+     * the weekly availability map, rebuilt in full on every save: a cached
+     * seed re-opens slots that were closed and closes ones customers can
+     * already book, and `priceUsd` goes back to whatever that snapshot
+     * charged.
+     */ fromCache: servicesFromCache } = useFirestoreCollection(()=>query(collection(firestore, 'hosts', hostId, 'services'), limit(100)), [
+        firestore,
+        hostId
+    ], {
+        idField: '$id'
+    });
+    const { data: bookingDocs } = useFirestoreCollection(()=>query(collection(firestore, 'hosts', hostId, 'bookings'), orderBy('startsAtMs', 'desc'), limit(100)), [
+        firestore,
+        hostId
+    ], {
+        idField: '$id'
+    });
+    const services = [
+        ...serviceDocs != null ? serviceDocs : []
+    ].filter((service)=>!service.deletedAt).sort((a, b)=>{
+        var _a_name, _b_name;
+        return String((_a_name = a.name) != null ? _a_name : '').localeCompare(String((_b_name = b.name) != null ? _b_name : ''));
+    });
+    const upcoming = [
+        ...bookingDocs != null ? bookingDocs : []
+    ].filter((booking)=>booking.endsAtMs >= Date.now()).sort((a, b)=>a.startsAtMs - b.startsAtMs);
+    // Newest first when narrowed to a booker — the listener already orders
+    // by start, descending — so the history reads down from the latest.
+    const shown = bookerFilter ? (bookingDocs != null ? bookingDocs : []).filter((booking)=>normalizeContactEmail(booking.email) === bookerFilter) : upcoming;
+    /**
+   * The 24-hour reminder queue (AGL-2431).
+   *
+   * Reminders are sent by the `booking-reminders` beat, not by anything on
+   * this page, and until that beat existed they were never sent at all — the
+   * feature had a designed email template, white-label branding and an
+   * `x-cron-secret` door, and no scheduler pointed at it. So the merchant had
+   * no way to tell working from broken, and still would not if this card
+   * merely asserted that reminders happen.
+   *
+   * READ-ONLY, and deliberately no "send now" button: the beat runs hourly
+   * and stamps `reminderSentAt`, so a manual sender would race it for a
+   * reminder nobody can un-send. Same call AGL-2227 made for the recovery
+   * queue.
+   *
+   * `isBookingReminderDue` is the sender's own predicate, against one instant
+   * shared by both counts, so this is the queue the next pass will drain
+   * rather than an approximation of it.
+   */ const reminderNowMs = Date.now();
+    const reminderQueue = (bookingDocs != null ? bookingDocs : []).filter((booking)=>isBookingReminderDue(booking, reminderNowMs)).length;
+    const remindersSent = (bookingDocs != null ? bookingDocs : []).filter((booking)=>booking.reminderSentAt).length;
+    const [draft, setDraft] = useState(null);
+    const handleAdd = useCallback(()=>{
+        if (!entitled) {
+            return void enqueueSnackbar('Bookings require a Starter plan — see Billing to upgrade', {
+                variant: 'warning',
+                persist: false
+            });
+        }
+        const quota = checkQuota(org, 'servicesPerHost', services.length);
+        if (!quota.allowed) {
+            return void enqueueSnackbar(`Service limit reached (${quota.limit}) — upgrade in Billing`, {
+                variant: 'warning',
+                persist: false
+            });
+        }
+        setDraft({
+            id: null,
+            name: '',
+            durationMinutes: '30',
+            priceUsd: '0',
+            timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC',
+            description: '',
+            windowText: WEEKDAYS.map((_, index)=>index >= 1 && index <= 5 ? '09:00-17:00' : ''),
+            // A booking is a meeting the record has; the follow-up is opt-in.
+            crmMeetingActivity: true,
+            crmFollowUpTask: false
+        });
+    }, [
+        entitled,
+        org,
+        services.length,
+        enqueueSnackbar
+    ]);
+    const handleSave = useCallback(async ()=>{
+        if (!draft || !draft.name.trim()) return;
+        const windows = {};
+        draft.windowText.forEach((text, weekday)=>{
+            const parsed = parseWindows(text);
+            if (parsed.length) windows[weekday] = parsed;
+        });
+        const fields = _extends({
+            name: draft.name.trim().slice(0, 80),
+            durationMinutes: Math.max(5, Math.min(480, Math.round(Number(draft.durationMinutes) || 30))),
+            priceUsd: Math.max(0, Math.round(Number(draft.priceUsd) || 0)),
+            timezone: draft.timezone.trim() || 'UTC'
+        }, draft.description.trim() && {
+            description: draft.description.trim().slice(0, 500)
+        }, {
+            windows,
+            // Written explicitly rather than only when on: an edit that switches
+            // the meeting off has to land a `false`, and `merge: true` would keep
+            // an absent key exactly as it was.
+            crmMeetingActivity: draft.crmMeetingActivity,
+            crmFollowUpTask: draft.crmFollowUpTask
+        });
+        try {
+            if (draft.id) {
+                /**
+         * Edit stays client-direct (no quota consumed) — and is refused when
+         * its seed was never confirmed by the server (AGL-1358). `fields` is
+         * every editable key of the stored service, `windows` included, so
+         * `merge: true` has nothing left to protect.
+         *
+         * The guard WRAPS the write. An early return is a shape you can keep
+         * while losing the protection; here the write is only reachable
+         * through the verdict.
+         */ const verdict = await writeGuardedBySeed({
+                    subject: 'service',
+                    unreadable: servicesStatus === 'error',
+                    fromCache: servicesFromCache
+                }, async ()=>{
+                    await setDoc(doc(firestore, 'hosts', hostId, 'services', draft.id), _extends({}, fields, {
+                        updatedAt: Timestamp.now()
+                    }), {
+                        merge: true
+                    });
+                });
+                // Before `setDraft(null)`, so a refusal keeps the dialog open with
+                // every window that was typed. A save that silently does nothing
+                // sends the user back to retype a form that will be refused again
+                // just as quietly.
+                if (!verdict.ok) {
+                    return void enqueueSnackbar(verdict.message, {
+                        variant: 'warning',
+                        persist: false
+                    });
+                }
+            } else {
+                // New service rides the quota-enforcing resources API (AGL-473) —
+                // it also re-checks the `bookings` entitlement server-side.
+                await createHostResource({
+                    hostId,
+                    resource: 'service',
+                    data: fields
+                });
+            }
+            setDraft(null);
+            enqueueSnackbar('Service saved', {
+                variant: 'success',
+                persist: false
+            });
+        } catch (error) {
+            var _ref;
+            console.error(error);
+            enqueueSnackbar((_ref = error == null ? void 0 : error.message) != null ? _ref : 'An error has occurred', {
+                variant: 'error',
+                allowDuplicate: true
+            });
+        }
+    }, [
+        draft,
+        firestore,
+        hostId,
+        createHostResource,
+        enqueueSnackbar,
+        servicesStatus,
+        servicesFromCache
+    ]);
+    const handleDeleteService = useCallback((service)=>async ()=>{
+            const confirmed = await confirm({
+                title: 'Delete this service?',
+                description: `"${service.name}" stops accepting bookings.`,
+                confirmationText: 'Delete',
+                confirmationButtonProps: {
+                    color: 'error'
+                }
+            }).then(()=>true).catch(()=>false);
+            if (!confirmed) return;
+            await updateDoc(doc(firestore, 'hosts', hostId, 'services', service.$id), {
+                deletedAt: Timestamp.now()
+            });
+        }, [
+        confirm,
+        firestore,
+        hostId
+    ]);
+    /**
+   * Cancelling a PAID booking refunds the guest (AGL-2315).
+   *
+   * This used to be one `updateDoc` writing `status: 'canceled'`, for a paid
+   * booking exactly as for a free one. The slot reopened, the appointment was
+   * gone, and the guest had paid for it — the money moved nowhere and nothing
+   * in the console said so. That was survivable only while the charge settled
+   * in Aglyn's own balance and could be given back by hand; a paid booking is
+   * a destination charge now, so the funds are at the MERCHANT and there is no
+   * later opportunity to notice.
+   *
+   * So a paid booking cancels through the refund route, which reverses the
+   * merchant's share and Aglyn's fee, and which sets `canceled` itself once
+   * the money is actually back. A FAILED refund deliberately leaves the
+   * booking standing: a cancelled-and-unrefunded appointment is the worst of
+   * the three outcomes, and an admin who sees the row still there knows the
+   * cancel did not happen.
+   */ const handleCancelBooking = useCallback((booking)=>async ()=>{
+            var _booking_paidAmountCents, _booking_refundedCents;
+            const paidCents = Math.max(0, Number((_booking_paidAmountCents = booking.paidAmountCents) != null ? _booking_paidAmountCents : 0));
+            const refundedCents = Math.max(0, Number((_booking_refundedCents = booking.refundedCents) != null ? _booking_refundedCents : 0));
+            const outstandingCents = Math.max(0, paidCents - refundedCents);
+            const refundable = outstandingCents > 0;
+            const confirmed = await confirm({
+                title: 'Cancel this booking?',
+                description: `${booking.name} (${booking.email}) — the slot reopens.` + (refundable ? ` $${(outstandingCents / 100).toFixed(2)} is refunded to them` + ' through Stripe.' : ''),
+                confirmationText: refundable ? 'Cancel and refund' : 'Cancel booking',
+                confirmationButtonProps: {
+                    color: 'error'
+                }
+            }).then(()=>true).catch(()=>false);
+            if (!confirmed) return;
+            if (refundable) {
+                var _ref;
+                var _globalThis_crypto_randomUUID, _globalThis_crypto;
+                // `randomUUID` needs a secure context, which the console always is,
+                // but fall back rather than throw on a refund.
+                const attemptKey = (_ref = (_globalThis_crypto = globalThis.crypto) == null ? void 0 : (_globalThis_crypto_randomUUID = _globalThis_crypto.randomUUID) == null ? void 0 : _globalThis_crypto_randomUUID.call(_globalThis_crypto)) != null ? _ref : `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+                try {
+                    const response = await authorizedFetch(user, '/api/bookings/refund', {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'Idempotency-Key': attemptKey
+                        },
+                        body: JSON.stringify({
+                            hostId,
+                            bookingId: booking.$id
+                        })
+                    });
+                    const payload = await response.json().catch(()=>null);
+                    if (!response.ok) {
+                        var _ref1;
+                        // A 409 is a guard REFUSING with a body that says what to do
+                        // instead — a booking paid before the PaymentIntent was recorded
+                        // names the Stripe dashboard — not the refund machinery failing.
+                        // It surfaces verbatim, the AGL-1818 rule.
+                        enqueueSnackbar((_ref1 = payload == null ? void 0 : payload.error) != null ? _ref1 : 'Refund failed', {
+                            variant: response.status === 409 ? 'warning' : 'error',
+                            allowDuplicate: true
+                        });
+                        // The booking stays. See the note above: cancelled-and-unrefunded
+                        // is worse than not cancelled.
+                        return;
+                    }
+                    // The route wrote `canceled` itself once the money was back.
+                    enqueueSnackbar('Booking canceled and refunded', {
+                        variant: 'success',
+                        persist: false
+                    });
+                    return;
+                } catch (unused) {
+                    enqueueSnackbar('Refund failed — the booking was not canceled', {
+                        variant: 'error',
+                        allowDuplicate: true
+                    });
+                    return;
+                }
+            }
+            await updateDoc(doc(firestore, 'hosts', hostId, 'bookings', booking.$id), {
+                status: 'canceled'
+            });
+            enqueueSnackbar('Booking canceled', {
+                variant: 'success',
+                persist: false
+            });
+        }, [
+        confirm,
+        firestore,
+        hostId,
+        enqueueSnackbar,
+        user
+    ]);
+    return /*#__PURE__*/ _jsxs(Stack, {
+        spacing: 3,
+        children: [
+            /*#__PURE__*/ _jsx(CardDisplay, {
+                header: 'Services',
+                help: pluginDocsHelp('bookings', {
+                    anchor: '#set-up-bookings',
+                    excerpt: 'The bookable services this site offers — how long each takes, ' + 'what it costs, and the hours it can be booked in.'
+                }),
+                contentGutterX: true,
+                contentGutterY: true,
+                children: /*#__PURE__*/ _jsxs(Stack, {
+                    spacing: 1,
+                    children: [
+                        services.length === 0 ? /*#__PURE__*/ _jsx(Typography, {
+                            variant: "body2",
+                            color: "text.secondary",
+                            children: 'Define a bookable service — duration, price, and weekly ' + 'availability — then visitors can book from your site.'
+                        }) : services.map((service)=>{
+                            var _service_timezone;
+                            return /*#__PURE__*/ _jsxs(Stack, {
+                                direction: "row",
+                                spacing: 1,
+                                sx: {
+                                    alignItems: 'center'
+                                },
+                                children: [
+                                    /*#__PURE__*/ _jsxs(Stack, {
+                                        sx: {
+                                            flex: 1,
+                                            minWidth: 0
+                                        },
+                                        children: [
+                                            /*#__PURE__*/ _jsx(Typography, {
+                                                variant: "body2",
+                                                noWrap: true,
+                                                children: service.name
+                                            }),
+                                            /*#__PURE__*/ _jsx(Typography, {
+                                                variant: "caption",
+                                                color: "text.secondary",
+                                                noWrap: true,
+                                                children: `${service.durationMinutes} min` + (Number(service.priceUsd) > 0 ? ` · $${service.priceUsd}` : ' · free') + ` · ${(_service_timezone = service.timezone) != null ? _service_timezone : 'UTC'}`
+                                            })
+                                        ]
+                                    }),
+                                    /*#__PURE__*/ _jsx(Button, {
+                                        size: "small",
+                                        onClick: ()=>{
+                                            var _service_name, _service_durationMinutes, _service_priceUsd, _service_timezone, _service_description;
+                                            return setDraft({
+                                                id: service.$id,
+                                                name: (_service_name = service.name) != null ? _service_name : '',
+                                                durationMinutes: String((_service_durationMinutes = service.durationMinutes) != null ? _service_durationMinutes : 30),
+                                                priceUsd: String((_service_priceUsd = service.priceUsd) != null ? _service_priceUsd : 0),
+                                                timezone: (_service_timezone = service.timezone) != null ? _service_timezone : 'UTC',
+                                                description: (_service_description = service.description) != null ? _service_description : '',
+                                                windowText: WEEKDAYS.map((_, index)=>{
+                                                    var _service_windows;
+                                                    return formatWindows((_service_windows = service.windows) == null ? void 0 : _service_windows[index]);
+                                                }),
+                                                // Absent reads as ON for the meeting and OFF for the
+                                                // follow-up — the model's defaults, seeded so the
+                                                // switches show what the service actually does.
+                                                crmMeetingActivity: service.crmMeetingActivity !== false,
+                                                crmFollowUpTask: service.crmFollowUpTask === true
+                                            });
+                                        },
+                                        children: 'Edit'
+                                    }),
+                                    /*#__PURE__*/ _jsx(Button, {
+                                        size: "small",
+                                        color: "error",
+                                        onClick: handleDeleteService(service),
+                                        children: 'Delete'
+                                    })
+                                ]
+                            }, service.$id);
+                        }),
+                        /*#__PURE__*/ _jsx(Button, {
+                            size: "small",
+                            color: "primary",
+                            sx: {
+                                alignSelf: 'flex-start'
+                            },
+                            onClick: handleAdd,
+                            children: 'Add service'
+                        }),
+                        /*#__PURE__*/ _jsx(QuotaReadoutComponent, {
+                            ready: org != null,
+                            used: services.length,
+                            limit: checkQuota(org, 'servicesPerHost', services.length).limit,
+                            noun: "service"
+                        })
+                    ]
+                })
+            }),
+            /*#__PURE__*/ _jsxs(CardDisplay, {
+                header: bookerFilter ? `Bookings for ${bookerFilter}` : 'Upcoming bookings',
+                help: pluginDocsHelp('bookings', {
+                    anchor: '#manage',
+                    excerpt: 'Bookings taken on this site, with the customer and the slot each ' + 'one holds.'
+                }),
+                contentGutterX: true,
+                contentGutterY: true,
+                children: [
+                    bookerFilter ? /*#__PURE__*/ _jsxs(Typography, {
+                        variant: "caption",
+                        color: "text.secondary",
+                        component: "div",
+                        sx: {
+                            mb: 1
+                        },
+                        children: [
+                            'Every booking this address holds, newest first. ',
+                            basePath ? /*#__PURE__*/ _jsx(AppLink, {
+                                href: basePath,
+                                children: 'Show upcoming bookings'
+                            }) : null
+                        ]
+                    }) : null,
+                    /*#__PURE__*/ _jsxs(Typography, {
+                        variant: "caption",
+                        color: "text.secondary",
+                        component: "div",
+                        sx: {
+                            mb: 1
+                        },
+                        children: [
+                            `24-hour reminders · ${reminderQueue} due in the next pass · ` + `${remindersSent} already sent`,
+                            /*#__PURE__*/ _jsx(HelpTip, _extends({}, pluginDocsHelp('bookings', {
+                                anchor: '#reminders'
+                            }), {
+                                sx: {
+                                    ml: 0.5,
+                                    fontSize: '0.9em'
+                                }
+                            }))
+                        ]
+                    }),
+                    shown.length === 0 ? /*#__PURE__*/ _jsx(Typography, {
+                        variant: "body2",
+                        color: "text.secondary",
+                        children: bookerFilter ? 'No bookings for this address.' : 'No upcoming bookings.'
+                    }) : /*#__PURE__*/ _jsx(Stack, {
+                        spacing: 1,
+                        children: shown.map((booking)=>/*#__PURE__*/ _jsxs(Stack, {
+                                direction: "row",
+                                spacing: 1,
+                                sx: {
+                                    alignItems: 'center'
+                                },
+                                children: [
+                                    /*#__PURE__*/ _jsxs(Stack, {
+                                        sx: {
+                                            flex: 1,
+                                            minWidth: 0
+                                        },
+                                        children: [
+                                            /*#__PURE__*/ _jsxs(Typography, {
+                                                variant: "body2",
+                                                noWrap: true,
+                                                children: [
+                                                    `${booking.serviceName} — ${booking.name}`,
+                                                    booking.status === 'canceled' ? ' (canceled)' : ''
+                                                ]
+                                            }),
+                                            /*#__PURE__*/ _jsx(Typography, {
+                                                variant: "caption",
+                                                color: "text.secondary",
+                                                noWrap: true,
+                                                children: `${new Date(booking.startsAtMs).toLocaleString()} · ${booking.email}`
+                                            })
+                                        ]
+                                    }),
+                                    siteContext && booking.email ? /*#__PURE__*/ _jsx(Button, _extends({
+                                        component: AppLink
+                                    }, {
+                                        componentVariant: 'naked',
+                                        nativeButton: false
+                                    }, {
+                                        href: crmContactByEmailHref(siteContext, String(booking.email)),
+                                        size: "small",
+                                        children: 'View in CRM'
+                                    })) : null,
+                                    booking.status !== 'canceled' ? /*#__PURE__*/ _jsx(Button, {
+                                        size: "small",
+                                        color: "error",
+                                        onClick: handleCancelBooking(booking),
+                                        children: 'Cancel'
+                                    }) : null
+                                ]
+                            }, booking.$id))
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsxs(Dialog, {
+                open: Boolean(draft),
+                onClose: ()=>setDraft(null),
+                maxWidth: "sm",
+                fullWidth: true,
+                children: [
+                    /*#__PURE__*/ _jsx(DialogTitle, {
+                        children: (draft == null ? void 0 : draft.id) ? 'Edit service' : 'Add service'
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogContent, {
+                        sx: {
+                            display: 'flex',
+                            flexDirection: 'column',
+                            gap: 1.5,
+                            pt: 1
+                        },
+                        children: [
+                            /*#__PURE__*/ _jsx(TextField, {
+                                label: "Name",
+                                value: (_ref = draft == null ? void 0 : draft.name) != null ? _ref : '',
+                                onChange: (event)=>setDraft((prev)=>prev ? _extends({}, prev, {
+                                            name: event.target.value
+                                        }) : prev),
+                                size: "small",
+                                autoFocus: true,
+                                sx: {
+                                    mt: 1
+                                }
+                            }),
+                            /*#__PURE__*/ _jsxs(Stack, {
+                                direction: "row",
+                                spacing: 1,
+                                children: [
+                                    /*#__PURE__*/ _jsx(TextField, {
+                                        label: "Duration (minutes)",
+                                        value: (_ref1 = draft == null ? void 0 : draft.durationMinutes) != null ? _ref1 : '',
+                                        onChange: (event)=>setDraft((prev)=>prev ? _extends({}, prev, {
+                                                    durationMinutes: event.target.value.replace(/[^0-9]/g, '')
+                                                }) : prev),
+                                        size: "small"
+                                    }),
+                                    /*#__PURE__*/ _jsx(TextField, {
+                                        label: "Price (USD, 0 = free)",
+                                        // WHAT THIS PRICE DOES NOT INCLUDE (AGL-2028).
+                                        //
+                                        // A paid booking is charged exactly this figure: the handler
+                                        // sends no tax parameter at all, by a stated decision (AGL-2000)
+                                        // — whether a service is taxable is jurisdiction-specific and
+                                        // frequently the opposite answer from goods, so applying the
+                                        // commerce plugin's GOODS sales rate would be confidently wrong
+                                        // rather than merely absent.
+                                        //
+                                        // That decision was recorded in the source and in the
+                                        // `storefrontTaxCollected` ledger, and in neither place can the
+                                        // merchant see it. A service business is one of the three named
+                                        // ICPs, and one who configured a rate in Commerce → Settings →
+                                        // Taxes has every reason to assume it covers the appointments
+                                        // they sell on the same site. Saying so here is the half of
+                                        // AGL-2028 that holds however the rate question is answered.
+                                        //
+                                        // States the MECHANISM and makes no remittance determination —
+                                        // the same line `describeOrderTaxMode` holds. Who owes which
+                                        // authority what attaches by operation of law and is counsel's
+                                        // call (AGL-1904/AGL-1956).
+                                        helperText: `${PLATFORM_BRAND_NAME} charges this price as typed — no tax is added. Your Commerce tax settings are a goods sales rate and do not apply to bookings.`,
+                                        value: (_ref2 = draft == null ? void 0 : draft.priceUsd) != null ? _ref2 : '',
+                                        onChange: (event)=>setDraft((prev)=>prev ? _extends({}, prev, {
+                                                    priceUsd: event.target.value.replace(/[^0-9]/g, '')
+                                                }) : prev),
+                                        size: "small"
+                                    }),
+                                    /*#__PURE__*/ _jsx(TextField, {
+                                        label: "Timezone",
+                                        value: (_ref3 = draft == null ? void 0 : draft.timezone) != null ? _ref3 : '',
+                                        onChange: (event)=>setDraft((prev)=>prev ? _extends({}, prev, {
+                                                    timezone: event.target.value
+                                                }) : prev),
+                                        size: "small",
+                                        sx: {
+                                            minWidth: 180
+                                        }
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ _jsx(TextField, {
+                                label: "Description (optional)",
+                                value: (_ref4 = draft == null ? void 0 : draft.description) != null ? _ref4 : '',
+                                onChange: (event)=>setDraft((prev)=>prev ? _extends({}, prev, {
+                                            description: event.target.value
+                                        }) : prev),
+                                size: "small",
+                                multiline: true,
+                                minRows: 2
+                            }),
+                            /*#__PURE__*/ _jsx(Typography, {
+                                variant: "overline",
+                                color: "text.secondary",
+                                children: 'Weekly availability'
+                            }),
+                            WEEKDAYS.map((day, index)=>{
+                                var _ref;
+                                return /*#__PURE__*/ _jsx(TextField, {
+                                    label: day,
+                                    placeholder: "09:00-12:00, 13:00-17:00 (empty = closed)",
+                                    value: (_ref = draft == null ? void 0 : draft.windowText[index]) != null ? _ref : '',
+                                    onChange: (event)=>setDraft((prev)=>prev ? _extends({}, prev, {
+                                                windowText: prev.windowText.map((text, i)=>i === index ? event.target.value : text)
+                                            }) : prev),
+                                    size: "small"
+                                }, day);
+                            }),
+                            /*#__PURE__*/ _jsx(Typography, {
+                                variant: "overline",
+                                color: "text.secondary",
+                                children: 'CRM'
+                            }),
+                            /*#__PURE__*/ _jsx(FormControlLabel, {
+                                control: /*#__PURE__*/ _jsx(Switch, {
+                                    checked: (_ref5 = draft == null ? void 0 : draft.crmMeetingActivity) != null ? _ref5 : true,
+                                    onChange: (event)=>setDraft((prev)=>prev ? _extends({}, prev, {
+                                                crmMeetingActivity: event.target.checked
+                                            }) : prev),
+                                    size: "small"
+                                }),
+                                label: "Log a meeting on the CRM record when this service is booked"
+                            }),
+                            /*#__PURE__*/ _jsx(FormControlLabel, {
+                                control: /*#__PURE__*/ _jsx(Switch, {
+                                    checked: (_ref6 = draft == null ? void 0 : draft.crmFollowUpTask) != null ? _ref6 : false,
+                                    onChange: (event)=>setDraft((prev)=>prev ? _extends({}, prev, {
+                                                crmFollowUpTask: event.target.checked
+                                            }) : prev),
+                                    size: "small"
+                                }),
+                                label: "Create a follow-up task on the CRM record when this service is booked"
+                            }),
+                            /*#__PURE__*/ _jsx(Typography, {
+                                variant: "caption",
+                                color: "text.secondary",
+                                children: 'The follow-up is due one business day after the slot, on whoever ' + 'owns the record. Nothing is filed on a site whose CRM is off.'
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogActions, {
+                        children: [
+                            /*#__PURE__*/ _jsx(Button, {
+                                onClick: ()=>setDraft(null),
+                                children: 'Cancel'
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                variant: "contained",
+                                color: "primary",
+                                disabled: !(draft == null ? void 0 : draft.name.trim()),
+                                onClick: handleSave,
+                                children: 'Save service'
+                            })
+                        ]
+                    })
+                ]
+            })
+        ]
+    });
+}
+BookingsConsolePage.displayName = 'BookingsConsolePage';
+export default BookingsConsolePage;
+
+//# sourceMappingURL=bookings-console-page.js.map