@voyant-travel/bookings-react 0.119.3

package/dist/admin/index.js

@@ -0,0 +1,331 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// agent-quality: file-size exception -- owner: bookings-react; existing UI surface stays co-located until a dedicated split preserves behavior and tests.
+import { defineAdminExtension, } from "@voyant-travel/admin";
+// Importing the slot id also binds the crm-ui `AdminDestinations`
+// augmentation (`person.list`, `organization.list`, ...) into this program;
+// this package already peer-depends on `@voyant-travel/relationships-react/ui`.
+import { personDetailBookingsTabSlot } from "@voyant-travel/relationships-react/admin";
+import * as React from "react";
+import { z } from "zod";
+// Lean statics only: the client module (fetcher), query-key types, and the
+// skeletons. Query options and page data helpers resolve via dynamic import
+// inside the loaders so the data layer (clients + response schemas) stays
+// out of the workspace-chrome chunk that evaluates this factory.
+import { defaultFetcher } from "../client.js";
+import { BookingDetailSkeleton } from "./booking-detail-skeleton.js";
+import { BookingsListSkeleton } from "./bookings-list-skeleton.js";
+export { BookingDetailSkeleton } from "./booking-detail-skeleton.js";
+export { BookingsListSkeleton } from "./bookings-list-skeleton.js";
+export { bookingDetailFinanceEndSlot, bookingDetailFinanceStartSlot, bookingDetailInvoicesTabSlot, } from "./slots.js";
+const bookingsListSortBySchema = z.enum([
+    "bookingNumber",
+    "status",
+    "sellAmount",
+    "pax",
+    "startDate",
+    "endDate",
+    "createdAt",
+]);
+const bookingsListSortDirSchema = z.enum(["asc", "desc"]);
+/**
+ * Search contract for the bookings list page: the URL projection of
+ * `BookingListFiltersState` (filters, sort, paging). Package-owned so the
+ * route file, the host, and the extension contribution validate the same
+ * shape. Defaults are absent from the URL — see
+ * {@link bookingsFiltersToSearch}.
+ */
+export const bookingsIndexSearchSchema = z.object({
+    search: z.string().optional(),
+    status: z.string().optional(),
+    productId: z.string().optional(),
+    optionId: z.string().optional(),
+    supplierId: z.string().optional(),
+    productCategoryId: z.string().optional(),
+    personId: z.string().optional(),
+    organizationId: z.string().optional(),
+    availabilitySlotId: z.string().optional(),
+    dateFrom: z.string().optional(),
+    dateTo: z.string().optional(),
+    paxMin: z.string().optional(),
+    paxMax: z.string().optional(),
+    sortBy: bookingsListSortBySchema.optional(),
+    sortDir: bookingsListSortDirSchema.optional(),
+    offset: z.coerce.number().int().min(0).optional(),
+});
+/** URL search params → `BookingList` initial state. Empty / `"all"` /
+ * default values are absent in the URL; we let `BookingList`'s defaults
+ * fill them in. */
+export function bookingsSearchToFilters(search) {
+    return {
+        search: search.search,
+        status: search.status,
+        productId: search.productId ?? null,
+        optionId: search.optionId ?? null,
+        supplierId: search.supplierId ?? null,
+        productCategoryId: search.productCategoryId ?? null,
+        personId: search.personId ?? null,
+        organizationId: search.organizationId ?? null,
+        availabilitySlotId: search.availabilitySlotId ?? null,
+        dateFrom: search.dateFrom ?? null,
+        dateTo: search.dateTo ?? null,
+        paxMin: search.paxMin,
+        paxMax: search.paxMax,
+        sortBy: search.sortBy,
+        sortDir: search.sortDir,
+        offset: search.offset,
+    };
+}
+/** Project the filter snapshot back into URL search params, dropping
+ * any value that matches the component's default so the URL stays
+ * clean when the operator is viewing the unfiltered list. */
+export function bookingsFiltersToSearch(filters) {
+    return {
+        search: filters.search || undefined,
+        status: filters.status === "all" ? undefined : filters.status,
+        productId: filters.productId ?? undefined,
+        optionId: filters.optionId ?? undefined,
+        supplierId: filters.supplierId ?? undefined,
+        productCategoryId: filters.productCategoryId ?? undefined,
+        personId: filters.personId ?? undefined,
+        organizationId: filters.organizationId ?? undefined,
+        availabilitySlotId: filters.availabilitySlotId ?? undefined,
+        dateFrom: filters.dateFrom ?? undefined,
+        dateTo: filters.dateTo ?? undefined,
+        paxMin: filters.paxMin || undefined,
+        paxMax: filters.paxMax || undefined,
+        sortBy: filters.sortBy === "createdAt" ? undefined : filters.sortBy,
+        sortDir: filters.sortDir === "desc" ? undefined : filters.sortDir,
+        offset: filters.offset === 0 ? undefined : filters.offset,
+    };
+}
+/** Tab values of the canonical `BookingDetailPage`, as a search-param schema. */
+export const bookingDetailTabSchema = z.enum([
+    "items",
+    "travelers",
+    "finance",
+    "invoices",
+    "documents",
+    "suppliers",
+    "activity",
+    "metadata",
+]);
+/**
+ * Search contract for the booking detail page. `productId`/`slotId` only
+ * matter for the `"new"` pseudo-id: a deep link with a product pre-chosen
+ * redirects into the unified booking journey (host route concern).
+ */
+export const bookingDetailSearchSchema = z.object({
+    productId: z.string().optional(),
+    slotId: z.string().optional(),
+    tab: bookingDetailTabSchema.optional(),
+});
+/**
+ * Search contract for the packaged "New booking" entry page. A deep link
+ * with `productId` pre-chosen (e.g. launched from a product page) forwards
+ * straight into the unified booking journey; `slotId` pins the departure.
+ */
+export const bookingNewSearchSchema = z.object({
+    productId: z.string().optional(),
+    slotId: z.string().optional(),
+});
+/**
+ * Search contract for the unified booking journey page — the URL projection
+ * of the journey's entry state (provenance, pre-pinned departure/option/
+ * rate, side-panel preview hints). Key PRESENCE is meaningful: callers pass
+ * only the fields their selection actually carries.
+ */
+export const bookingJourneySearchSchema = z.object({
+    sourceKind: z.string().min(1),
+    sourceConnectionId: z.string().optional(),
+    sourceRef: z.string().optional(),
+    departureId: z.string().optional(),
+    departureDate: z.string().optional(),
+    optionId: z.string().optional(),
+    roomTypeId: z.string().optional(),
+    ratePlanId: z.string().optional(),
+    board: z.string().optional(),
+    entityName: z.string().optional(),
+    entityImageUrl: z.string().optional(),
+    /** Stable draft id — refresh-safe. When absent, the journey page
+     *  generates a fresh id on mount. */
+    draftId: z.string().optional(),
+});
+/** Map the host-supplied route runtime onto the bookings data client shape. */
+function loaderClient(runtime) {
+    return { baseUrl: runtime.baseUrl, fetcher: runtime.fetcher ?? defaultFetcher };
+}
+const LazyPersonBookingsWidget = React.lazy(() => import("./person-bookings-widget.js").then((module) => ({
+    default: module.PersonBookingsWidget,
+})));
+/**
+ * Suspense-wrapped lazy mount of {@link LazyPersonBookingsWidget}. The widget
+ * registry takes a sync component, but the card (and the booking-list stack
+ * behind it) must not load with workspace chrome — the chunk fetches when the
+ * CRM person page actually renders the Bookings tab.
+ */
+function PersonBookingsWidgetLoader(props) {
+    return (_jsx(React.Suspense, { fallback: null, children: _jsx(LazyPersonBookingsWidget, { ...props }) }));
+}
+function adminWidgetComponent(Widget) {
+    return function AdminWidgetComponent(props) {
+        return _jsx(Widget, { ...props });
+    };
+}
+const PersonBookingsWidgetContribution = adminWidgetComponent(PersonBookingsWidgetLoader);
+/**
+ * The bookings admin contribution (packaged-admin RFC Phase 3,
+ * `@voyant-travel/<domain>-ui/admin` convention).
+ *
+ * NAVIGATION: deliberately none. The Bookings nav item is part of the BASE
+ * operator navigation — see `createOperatorAdminNavigation` in
+ * `@voyant-travel/admin` — so contributing nav entries here would duplicate it.
+ * If the base nav ever drops the bookings item, this extension is where the
+ * entry moves.
+ *
+ * ROUTES: full implementations (packaged-admin RFC §4.8) — the package-owned
+ * search contracts ({@link bookingsIndexSearchSchema} for the list,
+ * {@link bookingDetailSearchSchema} for the detail page), loaders that
+ * prefetch through the host-supplied runtime, and lazy `page` modules. The
+ * PAGES are package-owned too: {@link BookingsHost} and
+ * {@link BookingDetailHost} bind the canonical bookings pages to their data
+ * wiring (bookings/finance provider context) and resolve every cross-route
+ * link through the semantic destinations declared above — no app RPC client,
+ * no host route tree.
+ *
+ * `component:` stays unattached; each contribution carries a lazy `page`
+ * loader instead. The host binder wraps it in the router's lazy-component
+ * machinery (so the page lands in its own chunk) and hands the resolved
+ * component its route state as `AdminRoutePageProps` — which is how the
+ * param/search-taking bookings pages mount without a host route file. The
+ * `page` thunks below dynamically import the SPECIFIC page modules, never
+ * this barrel, so the factory itself never pins page code into the
+ * workspace-chrome chunk.
+ *
+ * WIDGETS: the crm-ui ↔ bookings-ui cycle resolution (RFC §4.7). The CRM
+ * person detail page mounts a Bookings tab, but this package depends on
+ * `@voyant-travel/relationships-react/ui`, so crm-ui's host cannot import the bookings-owned
+ * card. Instead this extension contributes {@link PersonBookingsWidget} on
+ * the `person.details.bookings-tab` slot crm-ui's `PersonDetailHost`
+ * exposes; the host mounts its Bookings tab whenever a contribution targets
+ * that slot and hands the widget its typed slot context
+ * (`PersonDetailBookingsTabContext`) as props.
+ */
+export function createBookingsAdminExtension(options = {}) {
+    const { basePath = "/bookings", labels = {}, indexHeaderActions, detailPageComponent } = options;
+    const { bookings = "Bookings" } = labels;
+    return defineAdminExtension({
+        id: "bookings",
+        routes: [
+            {
+                id: "bookings-index",
+                path: basePath,
+                title: bookings,
+                // Route-backed destination (RFC §4.7 endgame): the key resolves by
+                // pure path interpolation of this route, so the host's resolver is
+                // generated (`voyant admin generate --destinations`). `booking.detail`
+                // is deliberately NOT bound: its resolver constructs the `tab` search
+                // param, which is beyond path interpolation — it stays hand-written.
+                destination: "booking.list",
+                ssr: "data-only",
+                validateSearch: (search) => bookingsIndexSearchSchema.parse(search),
+                pendingComponent: BookingsListSkeleton,
+                // Dynamic import on purpose: the query options pull the bookings
+                // data layer (client + response schemas), and a static import here
+                // would pin it into the workspace-chrome chunk that evaluates this
+                // factory. The loader and the page resolve shared modules once.
+                loader: async ({ queryClient, runtime }) => {
+                    const { getBookingsQueryOptions } = await import("../query-options.js");
+                    return queryClient.ensureQueryData(getBookingsQueryOptions(loaderClient(runtime)));
+                },
+                page: async () => {
+                    const module = await import("./pages/bookings-index-page.js");
+                    const Page = module.default;
+                    // Tiny wrapper only — the heavy page stays in its own chunk; this
+                    // closure just threads the app-owned header actions through.
+                    return {
+                        default: (props) => (_jsx(Page, { ...props, headerActions: indexHeaderActions })),
+                    };
+                },
+            },
+            {
+                id: "bookings-detail",
+                path: `${basePath}/$id`,
+                title: bookings,
+                ssr: "data-only",
+                validateSearch: (search) => bookingDetailSearchSchema.parse(search),
+                pendingComponent: BookingDetailSkeleton,
+                // The static `/bookings/new` route (the "bookings-new" contribution
+                // below) outranks this param route for the `"new"` segment, but the
+                // loader stays defensive — nothing to prefetch for a pseudo-id.
+                loader: async ({ queryClient, runtime, params }) => {
+                    const id = params.id;
+                    if (!id || id === "new")
+                        return;
+                    // Dynamic import on purpose — see the index loader above.
+                    const { getBookingActivityQueryOptions, getBookingNotesQueryOptions, getBookingQueryOptions, getSupplierStatusesQueryOptions, getTravelersQueryOptions, } = await import("../query-options.js");
+                    const client = loaderClient(runtime);
+                    // Critical: booking itself drives the header. Everything else
+                    // (travelers, supplier statuses, activity, notes) is per-section
+                    // and renders progressively.
+                    await queryClient.ensureQueryData(getBookingQueryOptions(client, id));
+                    void queryClient.prefetchQuery(getTravelersQueryOptions(client, id));
+                    void queryClient.prefetchQuery(getSupplierStatusesQueryOptions(client, id));
+                    void queryClient.prefetchQuery(getBookingActivityQueryOptions(client, id));
+                    void queryClient.prefetchQuery(getBookingNotesQueryOptions(client, id));
+                },
+                page: async () => {
+                    const module = await (detailPageComponent
+                        ? detailPageComponent()
+                        : import("./pages/booking-detail-page.js"));
+                    const Page = module.default;
+                    return {
+                        default: ({ params, search, updateSearch }) => (_jsx(Page, { id: params.id ?? "", activeTab: search.tab, onTabChange: (tab) => updateSearch((prev) => ({ ...prev, tab }), { replace: true }) })),
+                    };
+                },
+            },
+            {
+                id: "bookings-new",
+                path: `${basePath}/new`,
+                title: bookings,
+                // Route-backed destination (RFC §4.7 endgame): the key resolves by
+                // pure path interpolation of this route (no params), so the host's
+                // resolver is generated.
+                destination: "booking.create",
+                validateSearch: (search) => bookingNewSearchSchema.parse(search),
+                page: () => import("./pages/booking-new-page.js"),
+            },
+            {
+                id: "bookings-compose",
+                path: `${basePath}/compose`,
+                title: bookings,
+                // Alias route: forwards to the host's trips via the
+                // `trip.create` destination (see the page module).
+                page: () => import("./pages/booking-compose-page.js"),
+            },
+            {
+                id: "bookings-journey",
+                // Deliberately OUTSIDE `basePath`: the journey mounts on the catalog
+                // plane (`bookingJourney.start` hrefs point here), flat under the
+                // workspace layout so it renders without catalog section nesting —
+                // the same semantics the old escaped `catalog_.journey` route file
+                // had. NOT destination-annotated: `bookingJourney.start` constructs
+                // search params, which is beyond path interpolation — its resolver
+                // stays hand-written in the host map.
+                path: "/catalog/journey/$entityModule/$entityId",
+                title: bookings,
+                validateSearch: (search) => bookingJourneySearchSchema.parse(search),
+                page: () => import("./pages/booking-journey-page.js"),
+            },
+        ],
+        widgets: [
+            {
+                id: "bookings-person-bookings",
+                slot: personDetailBookingsTabSlot,
+                // The widget registry is untyped (`Record<string, unknown>` props);
+                // the typed contract is `PersonDetailBookingsTabContext`, which
+                // crm-ui's person detail host passes verbatim to this slot's widgets.
+                component: PersonBookingsWidgetContribution,
+            },
+        ],
+    });
+}

package/dist/admin/journey-billing-duplicate-warning.d.ts

@@ -0,0 +1,3 @@
+import type { BillingExtrasContext } from "../journey/index.js";
+export declare function JourneyBillingDuplicateWarning({ buyerType, personId, organizationId, productId, departureSlotId, }: BillingExtrasContext): React.ReactElement | null;
+//# sourceMappingURL=journey-billing-duplicate-warning.d.ts.map

package/dist/admin/journey-billing-duplicate-warning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"journey-billing-duplicate-warning.d.ts","sourceRoot":"","sources":["../../src/admin/journey-billing-duplicate-warning.tsx"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAA;AAE/D,wBAAgB,8BAA8B,CAAC,EAC7C,SAAS,EACT,QAAQ,EACR,cAAc,EACd,SAAS,EACT,eAAe,GAChB,EAAE,oBAAoB,GAAG,KAAK,CAAC,YAAY,GAAG,IAAI,CA0ClD"}

package/dist/admin/journey-billing-duplicate-warning.js

@@ -0,0 +1,26 @@
+"use client";
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Heads-up shown under the billing block when the picked lead (person for B2C,
+ * organization for B2B) already has a booking on the selected departure — with
+ * a link to each. Helps operators avoid accidental duplicate bookings.
+ */
+import { useAdminNavigate, useOperatorAdminMessages } from "@voyant-travel/admin";
+import { useBookings } from "../hooks/use-bookings.js";
+export function JourneyBillingDuplicateWarning({ buyerType, personId, organizationId, productId, departureSlotId, }) {
+    const t = useOperatorAdminMessages().bookings.detail.bookingJourney;
+    const navigate = useAdminNavigate();
+    const leadId = buyerType === "B2B" ? organizationId : personId;
+    // Only a scheduled departure (slot) gives a precise duplicate match.
+    const enabled = Boolean(leadId && departureSlotId);
+    const query = useBookings({
+        ...(buyerType === "B2B" ? { organizationId } : { personId }),
+        productId,
+        availabilitySlotId: departureSlotId,
+        enabled,
+    });
+    const existing = (query.data?.data ?? []).filter((booking) => booking.status !== "cancelled");
+    if (!enabled || existing.length === 0)
+        return null;
+    return (_jsxs("div", { className: "space-y-1 rounded-md border border-amber-300 bg-amber-50 p-3 text-amber-900 text-sm dark:border-amber-700 dark:bg-amber-950 dark:text-amber-100", children: [_jsxs("p", { children: ["\u26A0 ", t.duplicateDepartureWarning] }), _jsx("ul", { className: "space-y-0.5", children: existing.map((booking) => (_jsxs("li", { children: [_jsx("button", { type: "button", className: "font-medium underline underline-offset-2 hover:opacity-80", onClick: () => navigate("booking.detail", { bookingId: booking.id }), children: booking.bookingNumber }), booking.items?.[0]?.title ? (_jsxs("span", { className: "text-amber-900/80 dark:text-amber-100/80", children: [" ", "\u00B7 ", booking.items[0].title] })) : null] }, booking.id))) })] }));
+}

package/dist/admin/journey-departure-picker.d.ts

@@ -0,0 +1,7 @@
+import type { DeparturePickerProps } from "../journey/index.js";
+export declare function JourneyDeparturePicker({ productId, optionId, slotId, departureDate, onChange, lockDeparture, }: DeparturePickerProps & {
+    /** The departure is fixed (a sourced offer's date came in pre-selected) —
+     *  show it read-only rather than a re-editable input. */
+    lockDeparture?: boolean;
+}): React.ReactElement;
+//# sourceMappingURL=journey-departure-picker.d.ts.map

package/dist/admin/journey-departure-picker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"journey-departure-picker.d.ts","sourceRoot":"","sources":["../../src/admin/journey-departure-picker.tsx"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAA;AA4B/D,wBAAgB,sBAAsB,CAAC,EACrC,SAAS,EACT,QAAQ,EACR,MAAM,EACN,aAAa,EACb,QAAQ,EACR,aAAqB,GACtB,EAAE,oBAAoB,GAAG;IACxB;6DACyD;IACzD,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,GAAG,KAAK,CAAC,YAAY,CAsIrB"}

package/dist/admin/journey-departure-picker.js

@@ -0,0 +1,100 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useSlots } from "@voyant-travel/operations-react/availability";
+import { Combobox, ComboboxCollection, ComboboxContent, ComboboxEmpty, ComboboxInput, ComboboxItem, ComboboxList, } from "@voyant-travel/ui/components/combobox";
+import { Input } from "@voyant-travel/ui/components/input";
+import { Label } from "@voyant-travel/ui/components/label";
+import { useEffect, useMemo, useState } from "react";
+import { getBookableDepartureSlots } from "../components/booking-create-utils.js";
+import { useBookingsUiMessagesOrDefault } from "../i18n/provider.js";
+/**
+ * Admin departure picker for the booking journey's `"departure"`
+ * sub-step. Loads the owned product's scheduled departures from
+ * availability and lets the operator pick a real one (filtered by the
+ * chosen product option). When the product has no scheduled
+ * departures, it falls back to a free date so non-scheduled
+ * products can still be booked.
+ *
+ * Wired into `<BookingJourneyHost />` via the journey's
+ * `renderDeparturePicker` slot.
+ */
+const dateFormatter = new Intl.DateTimeFormat(undefined, {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+});
+export function JourneyDeparturePicker({ productId, optionId, slotId, departureDate, onChange, lockDeparture = false, }) {
+    const messages = useBookingsUiMessagesOrDefault().bookingCreateDialog;
+    // Stable "now" so the slot query + future filter don't churn every render.
+    const [nowIso] = useState(() => new Date().toISOString());
+    const query = useSlots({
+        productId: productId || undefined,
+        status: "open",
+        startsAtFrom: nowIso,
+        limit: 100,
+        enabled: Boolean(productId) && !lockDeparture,
+    });
+    const slots = useMemo(() => getBookableDepartureSlots((query.data?.data ?? []), {
+        nowIso,
+        optionId,
+    }), [query.data?.data, nowIso, optionId]);
+    const slotMap = useMemo(() => new Map(slots.map((s) => [s.id, s])), [slots]);
+    const formatLabel = (slot) => {
+        const date = dateFormatter.format(new Date(slot.startsAt));
+        const remaining = !slot.unlimited && typeof slot.remainingPax === "number"
+            ? ` · ${slot.remainingPax} ${messages.labels.remainingCapacity}`
+            : "";
+        return `${date}${remaining}`;
+    };
+    const [inputValue, setInputValue] = useState(() => {
+        const current = slotId ? slotMap.get(slotId) : undefined;
+        return current ? formatLabel(current) : "";
+    });
+    // The draft keeps the picked slotId across step navigation, but this
+    // component's input is local state and re-seeds to "" on remount (before
+    // slots load). Reflect the selected slot's label once it resolves so a
+    // revisited departure shows as selected rather than empty.
+    // biome-ignore lint/correctness/useExhaustiveDependencies: formatLabel is render-stable; slotId/slotMap are the real triggers -- owner: bookings-react; existing suppression is intentional pending typed cleanup.
+    useEffect(() => {
+        if (!slotId)
+            return;
+        const slot = slotMap.get(slotId);
+        if (slot)
+            setInputValue((prev) => (prev ? prev : formatLabel(slot)));
+    }, [slotId, slotMap]);
+    // Sourced offer with a fixed date (came in pre-selected) → show it read-only.
+    // A different date would be a different offer, so there's nothing to edit.
+    if (lockDeparture && departureDate) {
+        return (_jsxs("div", { className: "space-y-1", children: [_jsx(Label, { children: messages.fields.departure }), _jsx("p", { className: "font-medium text-sm", children: dateFormatter.format(new Date(`${departureDate.slice(0, 10)}T00:00:00`)) })] }));
+    }
+    // No scheduled departures for this product → a free date so the operator can
+    // still set a departure for non-scheduled products. (No time field — tour /
+    // package departures are by date.)
+    if (!query.isLoading && slots.length === 0) {
+        return (_jsxs("div", { className: "space-y-1", children: [_jsx(Label, { htmlFor: "bj-departure-date", children: messages.fields.departure }), _jsx(Input, { id: "bj-departure-date", type: "date", className: "sm:max-w-xs", value: departureDate ?? "", onChange: (e) => onChange({ departureDate: e.target.value || null }) })] }));
+    }
+    return (_jsxs("div", { className: "flex flex-col gap-1", children: [_jsxs(Label, { children: [messages.fields.departure, " ", _jsx("span", { className: "text-destructive", children: "*" })] }), _jsxs(Combobox, { items: slots.map((s) => s.id), value: slotId || null, inputValue: inputValue, autoHighlight: true, disabled: query.isLoading, filter: () => true, itemToStringLabel: (id) => {
+                    const slot = slotMap.get(id);
+                    return slot ? formatLabel(slot) : id;
+                }, itemToStringValue: (id) => id, onInputValueChange: (next) => setInputValue(next), onValueChange: (next) => {
+                    const id = next ?? "";
+                    const slot = id ? slotMap.get(id) : undefined;
+                    if (!slot) {
+                        onChange({ slotId: null, departureDate: null });
+                        setInputValue("");
+                        return;
+                    }
+                    onChange({
+                        slotId: slot.id,
+                        // Anchor the free-date field on the slot's date so downstream
+                        // (payment schedules, hold) has a concrete departure date.
+                        departureDate: slot.startsAt.slice(0, 10),
+                    });
+                    setInputValue(formatLabel(slot));
+                }, children: [_jsx(ComboboxInput, { placeholder: messages.placeholders.departure, showClear: Boolean(slotId) }), _jsxs(ComboboxContent, { children: [_jsx(ComboboxEmpty, { children: messages.placeholders.departureEmpty }), _jsx(ComboboxList, { children: _jsx(ComboboxCollection, { children: (id) => {
+                                        const slot = slotMap.get(id);
+                                        if (!slot)
+                                            return null;
+                                        return (_jsx(ComboboxItem, { value: slot.id, children: formatLabel(slot) }, slot.id));
+                                    } }) })] })] })] }));
+}

package/dist/admin/journey-units-picker.d.ts

@@ -0,0 +1,11 @@
+import type { UnitsPickerProps } from "../journey/index.js";
+/**
+ * Admin rooms/units picker for the booking journey's `"option-units"`
+ * sub-step. Wraps the shared `OptionUnitsStepperSection` (which loads the
+ * product's option units + per-slot availability) and mirrors the picked
+ * quantities into the journey draft's `configure.optionSelections`.
+ *
+ * Wired into `<BookingJourneyHost />` via the `renderUnitsPicker` slot.
+ */
+export declare function JourneyUnitsPicker({ productId, optionId, slotId, selections, onChange, }: UnitsPickerProps): React.ReactElement;
+//# sourceMappingURL=journey-units-picker.d.ts.map

package/dist/admin/journey-units-picker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"journey-units-picker.d.ts","sourceRoot":"","sources":["../../src/admin/journey-units-picker.tsx"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAA0B,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAEnF;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,SAAS,EACT,QAAQ,EACR,MAAM,EACN,UAAU,EACV,QAAQ,GACT,EAAE,gBAAgB,GAAG,KAAK,CAAC,YAAY,CAuDvC"}

package/dist/admin/journey-units-picker.js

@@ -0,0 +1,60 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef, useState } from "react";
+import { emptyOptionUnitsStepperValue, OptionUnitsStepperSection, } from "../components/option-units-stepper-section.js";
+/**
+ * Admin rooms/units picker for the booking journey's `"option-units"`
+ * sub-step. Wraps the shared `OptionUnitsStepperSection` (which loads the
+ * product's option units + per-slot availability) and mirrors the picked
+ * quantities into the journey draft's `configure.optionSelections`.
+ *
+ * Wired into `<BookingJourneyHost />` via the `renderUnitsPicker` slot.
+ */
+export function JourneyUnitsPicker({ productId, optionId, slotId, selections, onChange, }) {
+    // Seed the stepper from any selections already on the draft (refresh /
+    // step revisit). Local state mirrors the departure picker's approach.
+    const [value, setValue] = useState(() => {
+        const quantities = {};
+        for (const selection of selections) {
+            if (selection.optionUnitId)
+                quantities[selection.optionUnitId] = selection.quantity;
+        }
+        return Object.keys(quantities).length > 0 ? { quantities } : emptyOptionUnitsStepperValue;
+    });
+    // The loaded unit metadata (optionId + name per unit) needed to rebuild
+    // `optionSelections` from the quantity map.
+    // Loaded unit metadata is kept in a ref, NOT state: it's only read when
+    // the operator changes a quantity, never rendered. Using state here would
+    // make `onUnitsChange` (which fires as units load) re-render → the stepper
+    // re-emits → setDraft → re-quote → re-render … an infinite loop.
+    const unitsRef = useRef([]);
+    const emit = (quantities) => {
+        const next = [];
+        for (const unit of unitsRef.current) {
+            const quantity = quantities[unit.optionUnitId] ?? 0;
+            if (quantity <= 0)
+                continue;
+            const unitOptionId = unit.optionId ?? optionId;
+            if (!unitOptionId)
+                continue;
+            next.push({
+                optionId: unitOptionId,
+                optionUnitId: unit.optionUnitId,
+                optionUnitName: unit.unitName,
+                quantity,
+            });
+        }
+        onChange(next);
+    };
+    return (_jsx(OptionUnitsStepperSection, { value: value, onChange: (nextValue) => {
+            setValue(nextValue);
+            emit(nextValue.quantities);
+        }, productId: productId, slotId: slotId ?? undefined, optionId: optionId, 
+        // The journey nests rooms under the chosen option — show only that
+        // option's units (New having no rooms correctly shows none).
+        restrictToOption: true, enabled: true, 
+        // Record loaded units without triggering a render (see unitsRef note).
+        onUnitsChange: (loadedUnits) => {
+            unitsRef.current = loadedUnits;
+        } }));
+}

package/dist/admin/journey-voucher-picker.d.ts

@@ -0,0 +1,3 @@
+import type { VoucherPickerProps } from "../journey/index.js";
+export declare function JourneyVoucherPicker({ value, onApply }: VoucherPickerProps): React.ReactElement;
+//# sourceMappingURL=journey-voucher-picker.d.ts.map

package/dist/admin/journey-voucher-picker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"journey-voucher-picker.d.ts","sourceRoot":"","sources":["../../src/admin/journey-voucher-picker.tsx"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAc7D,wBAAgB,oBAAoB,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,kBAAkB,GAAG,KAAK,CAAC,YAAY,CAgF/F"}

package/dist/admin/journey-voucher-picker.js

@@ -0,0 +1,71 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Admin voucher picker — an async combobox over the admin vouchers list.
+ * Staff search by code and pick a voucher (the full remaining balance is
+ * redeemed); they never need to know the exact code, unlike storefront
+ * customers. Wired into `<BookingJourneyHost />` via `renderVoucherPicker`.
+ */
+import { useOperatorAdminMessages } from "@voyant-travel/admin";
+import { useVouchers } from "@voyant-travel/finance-react";
+import { Combobox, ComboboxCollection, ComboboxContent, ComboboxEmpty, ComboboxInput, ComboboxItem, ComboboxList, } from "@voyant-travel/ui/components/combobox";
+import { Label } from "@voyant-travel/ui/components/label";
+import { useEffect, useState } from "react";
+function formatMoney(cents, currency) {
+    try {
+        return new Intl.NumberFormat(undefined, { style: "currency", currency }).format(cents / 100);
+    }
+    catch {
+        return `${(cents / 100).toFixed(2)} ${currency}`;
+    }
+}
+function voucherLabel(voucher) {
+    return `${voucher.code} · ${formatMoney(voucher.remainingAmountCents, voucher.currency)}`;
+}
+export function JourneyVoucherPicker({ value, onApply }) {
+    const t = useOperatorAdminMessages().bookings.detail.bookingJourney;
+    const [inputValue, setInputValue] = useState("");
+    const [search, setSearch] = useState("");
+    // Active vouchers with a remaining balance, filtered by the typed code.
+    const query = useVouchers({
+        status: "active",
+        hasBalance: true,
+        search: search || undefined,
+        limit: 20,
+    });
+    const vouchers = query.data?.data ?? [];
+    const byId = new Map(vouchers.map((v) => [v.id, v]));
+    const selectedId = value.voucherId ?? null;
+    // Reflect a pre-selected voucher's label once its record loads.
+    useEffect(() => {
+        if (selectedId && byId.has(selectedId)) {
+            setInputValue(voucherLabel(byId.get(selectedId)));
+        }
+    }, [selectedId, byId]);
+    return (_jsxs("div", { className: "space-y-1", children: [_jsx(Label, { children: t.voucherPickerLabel }), _jsxs(Combobox, { items: vouchers.map((v) => v.id), value: selectedId, inputValue: inputValue, autoHighlight: true, itemToStringLabel: (id) => {
+                    const v = byId.get(id);
+                    return v ? voucherLabel(v) : id;
+                }, itemToStringValue: (id) => id, onInputValueChange: (next) => {
+                    setInputValue(next);
+                    setSearch(next);
+                    if (!next)
+                        onApply(null);
+                }, onValueChange: (next) => {
+                    const id = next ?? null;
+                    if (!id) {
+                        onApply(null);
+                        setInputValue("");
+                        return;
+                    }
+                    const v = byId.get(id);
+                    if (v) {
+                        onApply({ voucherId: v.id, amountCents: v.remainingAmountCents });
+                        setInputValue(voucherLabel(v));
+                    }
+                }, children: [_jsx(ComboboxInput, { placeholder: t.voucherSearchPlaceholder, showClear: !!selectedId }), _jsxs(ComboboxContent, { children: [_jsx(ComboboxEmpty, { children: t.voucherEmpty }), _jsx(ComboboxList, { children: _jsx(ComboboxCollection, { children: (id) => {
+                                        const v = byId.get(id);
+                                        if (!v)
+                                            return null;
+                                        return (_jsx(ComboboxItem, { value: v.id, children: _jsxs("div", { className: "flex min-w-0 flex-col", children: [_jsx("span", { className: "truncate font-medium", children: v.code }), _jsx("span", { className: "truncate text-muted-foreground text-xs", children: formatMoney(v.remainingAmountCents, v.currency) })] }) }, v.id));
+                                    } }) })] })] })] }));
+}

package/dist/admin/pages/booking-compose-page.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Legacy alias: `/bookings/compose` → the trips. The composer used
+ * to live here; it moved under the trips area, and this packaged page keeps
+ * the old URL working by forwarding to the `trip.create` destination (the
+ * host resolves it to its composer route). `replace` keeps route-redirect
+ * history semantics — the alias never lands in history.
+ */
+export default function BookingComposePage(): null;
+//# sourceMappingURL=booking-compose-page.d.ts.map

package/dist/admin/pages/booking-compose-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"booking-compose-page.d.ts","sourceRoot":"","sources":["../../../src/admin/pages/booking-compose-page.tsx"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,kBAAkB,SAQzC"}