@voyant-travel/operations-react 0.0.0

package/dist/availability/allocation/i18n/provider.js

@@ -0,0 +1,320 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createLocaleFormatters, createPackageMessagesContext, resolvePackageMessages, } from "@voyant-travel/i18n";
+export const allocationUiEn = {
+    pageTitle: "Allocation",
+    loading: "Loading allocation...",
+    empty: "Allocation data unavailable for this departure.",
+    back: "Back",
+    addRoom: "Add room",
+    addResource: "Add resource",
+    generateRooms: "Generate rooms",
+    generatingRooms: "Generating...",
+    generateResources: "Generate resources",
+    generatingResources: "Generating...",
+    autoAllocate: "Auto-allocate",
+    autoAllocating: "Allocating...",
+    createBooking: "Create booking",
+    booking: "Booking",
+    exportPassengers: "Passengers",
+    exportRooming: "Rooming",
+    auditLog: "Audit log",
+    auditLogDescription: "Recent allocation changes for this departure.",
+    auditActions: {
+        "resource.create": "Resource created",
+        "resource.update": "Resource updated",
+        "resource.delete": "Resource deleted",
+        "traveler.assign": "Traveler assigned",
+        "traveler.unassign": "Traveler unassigned",
+        "traveler.sharing-group.set": "Sharing group set",
+        "traveler.sharing-group.clear": "Sharing group cleared",
+        "sharing-group.label.update": "Group label updated",
+        "sharing-group.label.clear": "Group label cleared",
+        "resources.materialize": "Resources generated",
+        "auto-allocate": "Auto-allocate",
+    },
+    roomLabel: "Room label",
+    roomCapacity: "Capacity",
+    createRoom: "Create room",
+    resourceLabel: "Resource label",
+    resourceCapacity: "Capacity",
+    resourceOption: "Tied to option",
+    resourceOptionPlaceholder: "Select an option…",
+    resourceOptionNone: "Unassigned (manual)",
+    createResource: "Create resource",
+    editResource: "Edit resource",
+    saveResource: "Save",
+    updateResourceFailed: "Could not update resource.",
+    cancel: "Cancel",
+    unallocated: "Unallocated",
+    unallocatedDescription: "Travelers not assigned to this resource kind.",
+    unallocatedEmpty: "Everyone has been assigned.",
+    assignTraveler: "Assign",
+    assignTravelerSearch: "Search traveler...",
+    assignTravelerEmpty: "No unallocated travelers.",
+    assignTravelerSameBooking: "Same booking",
+    assignTravelerOthers: "Other bookings",
+    resourceOtherGroup: "Other",
+    rooms: "Rooms",
+    resources: "Resources",
+    vehicleSeats: "Vehicle seats",
+    vehicle: "Vehicle",
+    seat: "Seat",
+    cabins: "Cabins",
+    flightSeats: "Flight seats",
+    travelers: "Travelers",
+    capacity: "Capacity",
+    lead: "Lead",
+    sharingGroup: "Sharing group",
+    accessibility: "Accessibility",
+    dietary: "Dietary",
+    smokingAllowed: "Smoking",
+    remove: "Remove",
+    overCapacity: "Resource is full",
+    dropHere: "Drop traveler here",
+    slotCapacityLabel: "Free seats",
+    slotCapacityUnlimited: "Unlimited",
+    resourceCapacityLabel: "Provisioned",
+    resourceCapacityFits: "fits in slot",
+    resourceCapacityExact: "matches slot",
+    resourceCapacityOver: "over slot cap",
+    overCapacityWarning: "Resource capacity exceeds the slot's pax cap.",
+    noRooms: "No rooms have been added for this slot.",
+    noResources: "No resources have been added for this slot.",
+    noSeats: "No vehicle seats have been generated for this slot.",
+    noAllocationsToManage: "This slot has no allocations to manage.",
+    passengerListEmpty: "No passengers are booked on this departure yet.",
+    windowSeat: "Window",
+    aisleSeat: "Aisle",
+    middleSeat: "Middle",
+    validationTitle: "Allocation needs attention",
+    validationClear: "No validation issues",
+    validationUnallocated: "unallocated",
+    validationOverCapacity: "is over capacity",
+    validationSplitGroup: "Split sharing group",
+    allocationFailed: "Could not update allocation.",
+    createRoomFailed: "Could not create room.",
+    createResourceFailed: "Could not create resource.",
+    generateRoomsFailed: "Could not generate rooms.",
+    generateResourcesFailed: "Could not generate resources.",
+    autoAllocateFailed: "Could not auto-allocate travelers.",
+    paymentStatusLabels: {
+        paid: "Paid",
+        partial: "Partially paid",
+        unpaid: "Unpaid",
+    },
+    seatMapBuilder: {
+        heading: "Seat map",
+        description: "Click a cell to cycle through seat → aisle → door → void. Capacity is computed from the seat cells.",
+        cellKindHeading: "Cell kinds",
+        cellKindHint: "Tip: doors and voids do not count toward capacity.",
+        cellKinds: {
+            seat: "Seat",
+            aisle: "Aisle",
+            door: "Door",
+            void: "Empty space",
+        },
+        cellKindShort: {
+            seat: "S",
+            aisle: "·",
+            door: "D",
+            void: " ",
+        },
+        addRow: "Add row",
+        removeRow: "Remove last row",
+        rowAria: "Row {row}",
+        columnAria: "Row {row}, column {column}",
+        seatCountSummary: "{count} seats",
+        capacityChip: "Capacity {count}",
+        presetHeading: "Start from a preset",
+        presetHint: "Pick a starter layout and tweak any cell.",
+        presets: {
+            standardCoach: "Standard coach (2-2, 11 rows)",
+            miniCoach: "Mini-coach (2-1, 7 rows)",
+            largeBus: "Large bus (3-2, 11 rows)",
+            doubleDecker: "Double-aisle (2-1-2, 11 rows)",
+            withMidDoor: "Coach with mid-door (2-2, door at row 7)",
+        },
+        resetSpec: "Clear layout",
+        rowLabel: "Row {row}",
+        voidDoorReminder: "Use a void cell for permanent obstacles (toilet, wheelchair spot). Use a door cell for boarding doors that interrupt seating mid-coach.",
+    },
+};
+export const allocationUiRo = {
+    pageTitle: "Alocare",
+    loading: "Se incarca alocarea...",
+    empty: "Datele de alocare nu sunt disponibile pentru aceasta plecare.",
+    back: "Inapoi",
+    addRoom: "Adauga camera",
+    addResource: "Adauga resursa",
+    generateRooms: "Genereaza camere",
+    generatingRooms: "Se genereaza...",
+    generateResources: "Genereaza resurse",
+    generatingResources: "Se genereaza...",
+    autoAllocate: "Auto-aloca",
+    autoAllocating: "Se aloca...",
+    createBooking: "Creeaza rezervare",
+    booking: "Rezervare",
+    exportPassengers: "Pasageri",
+    exportRooming: "Rooming",
+    auditLog: "Istoric",
+    auditLogDescription: "Ultimele modificari de alocare pentru aceasta plecare.",
+    auditActions: {
+        "resource.create": "Resursa creata",
+        "resource.update": "Resursa actualizata",
+        "resource.delete": "Resursa stearsa",
+        "traveler.assign": "Calator alocat",
+        "traveler.unassign": "Calator dezalocat",
+        "traveler.sharing-group.set": "Grup partaj setat",
+        "traveler.sharing-group.clear": "Grup partaj sters",
+        "sharing-group.label.update": "Eticheta grup actualizata",
+        "sharing-group.label.clear": "Eticheta grup stearsa",
+        "resources.materialize": "Resurse generate",
+        "auto-allocate": "Auto-alocare",
+    },
+    roomLabel: "Eticheta camera",
+    roomCapacity: "Capacitate",
+    createRoom: "Creeaza camera",
+    resourceLabel: "Eticheta resursa",
+    resourceCapacity: "Capacitate",
+    resourceOption: "Optiune asociata",
+    resourceOptionPlaceholder: "Alege o optiune…",
+    resourceOptionNone: "Neasociata (manual)",
+    createResource: "Creeaza resursa",
+    editResource: "Editeaza resursa",
+    saveResource: "Salveaza",
+    updateResourceFailed: "Resursa nu a putut fi actualizata.",
+    cancel: "Anuleaza",
+    unallocated: "Nealocati",
+    unallocatedDescription: "Calatori fara acest tip de resursa alocat.",
+    unallocatedEmpty: "Toti calatorii sunt alocati.",
+    assignTraveler: "Aloca",
+    assignTravelerSearch: "Cauta calator...",
+    assignTravelerEmpty: "Nu exista calatori nealocati.",
+    assignTravelerSameBooking: "Aceeasi rezervare",
+    assignTravelerOthers: "Alte rezervari",
+    resourceOtherGroup: "Altele",
+    rooms: "Camere",
+    resources: "Resurse",
+    vehicleSeats: "Locuri vehicul",
+    vehicle: "Vehicul",
+    seat: "Loc",
+    cabins: "Cabine",
+    flightSeats: "Locuri zbor",
+    travelers: "Calatori",
+    capacity: "Capacitate",
+    lead: "Lead",
+    sharingGroup: "Grup partaj",
+    accessibility: "Accesibilitate",
+    dietary: "Dieta",
+    smokingAllowed: "Fumat",
+    remove: "Scoate",
+    overCapacity: "Resursa este plina",
+    dropHere: "Trage calatorul aici",
+    slotCapacityLabel: "Locuri libere",
+    slotCapacityUnlimited: "Nelimitat",
+    resourceCapacityLabel: "Provizionate",
+    resourceCapacityFits: "incape in slot",
+    resourceCapacityExact: "egal cu slotul",
+    resourceCapacityOver: "depaseste slotul",
+    overCapacityWarning: "Capacitatea resurselor depaseste limita de pax a slotului.",
+    noRooms: "Nu exista camere adaugate pentru acest slot.",
+    noResources: "Nu exista resurse adaugate pentru acest slot.",
+    noSeats: "Nu exista locuri generate pentru acest slot.",
+    noAllocationsToManage: "Acest slot nu are alocari de gestionat.",
+    passengerListEmpty: "Nu exista pasageri rezervati pe aceasta plecare.",
+    windowSeat: "Geam",
+    aisleSeat: "Culoar",
+    middleSeat: "Mijloc",
+    validationTitle: "Alocarea necesita atentie",
+    validationClear: "Fara probleme de validare",
+    validationUnallocated: "nealocati",
+    validationOverCapacity: "depaseste capacitatea",
+    validationSplitGroup: "Grup partaj impartit",
+    allocationFailed: "Alocarea nu a putut fi actualizata.",
+    createRoomFailed: "Camera nu a putut fi creata.",
+    createResourceFailed: "Resursa nu a putut fi creata.",
+    generateRoomsFailed: "Camerele nu au putut fi generate.",
+    generateResourcesFailed: "Resursele nu au putut fi generate.",
+    autoAllocateFailed: "Calatorii nu au putut fi auto-alocati.",
+    paymentStatusLabels: {
+        paid: "Achitata",
+        partial: "Partial achitata",
+        unpaid: "Neachitata",
+    },
+    seatMapBuilder: {
+        heading: "Harta locurilor",
+        description: "Apasa o celula pentru a comuta scaun → culoar → usa → spatiu gol. Capacitatea este calculata din celulele de tip scaun.",
+        cellKindHeading: "Tipuri de celule",
+        cellKindHint: "Sfat: usile si spatiile goale nu se numara in capacitate.",
+        cellKinds: {
+            seat: "Scaun",
+            aisle: "Culoar",
+            door: "Usa",
+            void: "Spatiu gol",
+        },
+        cellKindShort: {
+            seat: "S",
+            aisle: "·",
+            door: "U",
+            void: " ",
+        },
+        addRow: "Adauga rand",
+        removeRow: "Sterge ultimul rand",
+        rowAria: "Randul {row}",
+        columnAria: "Randul {row}, coloana {column}",
+        seatCountSummary: "{count} scaune",
+        capacityChip: "Capacitate {count}",
+        presetHeading: "Porneste de la o configuratie predefinita",
+        presetHint: "Alege o configuratie de start si modifica orice celula.",
+        presets: {
+            standardCoach: "Autocar standard (2-2, 11 randuri)",
+            miniCoach: "Minibus (2-1, 7 randuri)",
+            largeBus: "Autocar mare (3-2, 11 randuri)",
+            doubleDecker: "Doua culoare (2-1-2, 11 randuri)",
+            withMidDoor: "Autocar cu usa centrala (2-2, usa la randul 7)",
+        },
+        resetSpec: "Sterge configuratia",
+        rowLabel: "Randul {row}",
+        voidDoorReminder: "Foloseste o celula de tip spatiu gol pentru obstacole permanente (toaleta, loc pentru scaun cu rotile). Foloseste o usa pentru usile de imbarcare care intrerup scaunele in mijlocul autocarului.",
+    },
+};
+const fallbackLocale = "en";
+export const allocationUiMessageDefinitions = {
+    en: allocationUiEn,
+    ro: allocationUiRo,
+};
+const allocationUiContext = createPackageMessagesContext("AllocationUiMessages");
+const defaultAllocationUiI18n = {
+    messages: allocationUiEn,
+    ...createLocaleFormatters(fallbackLocale),
+};
+export function resolveAllocationUiMessages({ locale, overrides, }) {
+    return resolvePackageMessages({
+        definitions: allocationUiMessageDefinitions,
+        fallbackLocale,
+        locale,
+        overrides,
+    });
+}
+export function getAllocationUiI18n({ locale, overrides, }) {
+    const resolvedLocale = locale ?? fallbackLocale;
+    return {
+        messages: resolveAllocationUiMessages({
+            locale: resolvedLocale,
+            overrides,
+        }),
+        ...createLocaleFormatters(resolvedLocale),
+    };
+}
+export function AllocationUiMessagesProvider({ children, locale, overrides, }) {
+    return (_jsx(allocationUiContext.ResolvedMessagesProvider, { definitions: allocationUiMessageDefinitions, fallbackLocale: fallbackLocale, locale: locale, overrides: overrides, children: children }));
+}
+export const useAllocationUiI18n = allocationUiContext.useI18n;
+export const useAllocationUiMessages = allocationUiContext.useMessages;
+export function useAllocationUiI18nOrDefault() {
+    return allocationUiContext.useOptionalI18n() ?? defaultAllocationUiI18n;
+}
+export function useAllocationUiMessagesOrDefault() {
+    return useAllocationUiI18nOrDefault().messages;
+}

package/dist/availability/allocation/index.d.ts

@@ -0,0 +1,4 @@
+export { SEAT_MAP_PRESETS, SeatMapBuilder, type SeatMapBuilderProps, } from "./components/seat-map-builder.js";
+export { SlotAllocationPage, type SlotAllocationPageExtraTab, type SlotAllocationPageProps, type SlotAllocationPageRenderContext, } from "./components/slot-allocation-page.js";
+export { type AllocationUiMessageOverrides, type AllocationUiMessages, AllocationUiMessagesProvider, allocationUiEn, allocationUiMessageDefinitions, allocationUiRo, getAllocationUiI18n, resolveAllocationUiMessages, useAllocationUiI18n, useAllocationUiI18nOrDefault, useAllocationUiMessages, useAllocationUiMessagesOrDefault, } from "./i18n/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/availability/allocation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/availability/allocation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,KAAK,mBAAmB,GACzB,MAAM,kCAAkC,CAAA;AACzC,OAAO,EACL,kBAAkB,EAClB,KAAK,0BAA0B,EAC/B,KAAK,uBAAuB,EAC5B,KAAK,+BAA+B,GACrC,MAAM,sCAAsC,CAAA;AAC7C,OAAO,EACL,KAAK,4BAA4B,EACjC,KAAK,oBAAoB,EACzB,4BAA4B,EAC5B,cAAc,EACd,8BAA8B,EAC9B,cAAc,EACd,mBAAmB,EACnB,2BAA2B,EAC3B,mBAAmB,EACnB,4BAA4B,EAC5B,uBAAuB,EACvB,gCAAgC,GACjC,MAAM,iBAAiB,CAAA"}

package/dist/availability/allocation/index.js

@@ -0,0 +1,3 @@
+export { SEAT_MAP_PRESETS, SeatMapBuilder, } from "./components/seat-map-builder.js";
+export { SlotAllocationPage, } from "./components/slot-allocation-page.js";
+export { AllocationUiMessagesProvider, allocationUiEn, allocationUiMessageDefinitions, allocationUiRo, getAllocationUiI18n, resolveAllocationUiMessages, useAllocationUiI18n, useAllocationUiI18nOrDefault, useAllocationUiMessages, useAllocationUiMessagesOrDefault, } from "./i18n/index.js";

package/dist/availability/client.d.ts

@@ -0,0 +1,14 @@
+import type { z } from "zod";
+export type VoyantFetcher = (url: string, init?: RequestInit) => Promise<Response>;
+export declare const defaultFetcher: VoyantFetcher;
+export declare class VoyantApiError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(message: string, status: number, body: unknown);
+}
+export interface FetchWithValidationOptions {
+    baseUrl: string;
+    fetcher: VoyantFetcher;
+}
+export declare function fetchWithValidation<TOut>(path: string, schema: z.ZodType<TOut>, options: FetchWithValidationOptions, init?: RequestInit): Promise<TOut>;
+//# sourceMappingURL=client.d.ts.map

package/dist/availability/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/availability/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;AAElF,eAAO,MAAM,cAAc,EAAE,aACoB,CAAA;AAEjD,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;gBAEV,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO;CAM3D;AAcD,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,aAAa,CAAA;CACvB;AAED,wBAAsB,mBAAmB,CAAC,IAAI,EAC5C,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EACvB,OAAO,EAAE,0BAA0B,EACnC,IAAI,CAAC,EAAE,WAAW,GACjB,OAAO,CAAC,IAAI,CAAC,CAiCf"}

package/dist/availability/client.js

@@ -0,0 +1,59 @@
+export const defaultFetcher = (url, init) => fetch(url, { credentials: "include", ...init });
+export class VoyantApiError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.name = "VoyantApiError";
+        this.status = status;
+        this.body = body;
+    }
+}
+function extractErrorMessage(status, statusText, body) {
+    if (typeof body === "object" && body !== null && "error" in body) {
+        const err = body.error;
+        if (typeof err === "string")
+            return err;
+        if (typeof err === "object" && err !== null && "message" in err) {
+            return String(err.message);
+        }
+    }
+    return `Voyant API error: ${status} ${statusText}`;
+}
+export async function fetchWithValidation(path, schema, options, init) {
+    const url = joinUrl(options.baseUrl, path);
+    const headers = new Headers(init?.headers);
+    if (init?.body !== undefined && !headers.has("Content-Type")) {
+        headers.set("Content-Type", "application/json");
+    }
+    const response = await options.fetcher(url, { ...init, headers });
+    if (!response.ok) {
+        const body = await safeJson(response);
+        throw new VoyantApiError(extractErrorMessage(response.status, response.statusText, body), response.status, body);
+    }
+    if (response.status === 204) {
+        return schema.parse(undefined);
+    }
+    const body = await safeJson(response);
+    const parsed = schema.safeParse(body);
+    if (!parsed.success) {
+        throw new VoyantApiError(`Voyant API response failed validation: ${parsed.error.message}`, response.status, body);
+    }
+    return parsed.data;
+}
+async function safeJson(response) {
+    const text = await response.text();
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function joinUrl(baseUrl, path) {
+    const trimmedBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    const trimmedPath = path.startsWith("/") ? path : `/${path}`;
+    return `${trimmedBase}${trimmedPath}`;
+}

package/dist/availability/components/availability-columns.d.ts

@@ -0,0 +1,42 @@
+import type { ColumnDef } from "@tanstack/react-table";
+import { type AvailabilityCloseoutRow, type AvailabilityPickupPointRow, type AvailabilityRuleRow, type AvailabilitySlotRow, type AvailabilityStartTimeRow, type ProductOption } from "../index.js";
+export interface AvailabilityColumnsMessages {
+    activeLabel: string;
+    dateLabel: string;
+    details: {
+        noValue: string;
+    };
+    durationLabel: string;
+    labelLabel: string;
+    locationLabel: string;
+    maxPaxLabel: string;
+    nameLabel: string;
+    openLabel: string;
+    editLabel: string;
+    productLabel: string;
+    productLevelLabel: string;
+    reasonLabel: string;
+    recurrenceLabel: string;
+    remainingPaxLabel: string;
+    totalPaxLabel: string;
+    endsAtLabel: string;
+    slotLabel: string;
+    startLabel: string;
+    startsAtLabel: string;
+    statusActive: string;
+    statusCancelled: string;
+    statusClosed: string;
+    statusInactive: string;
+    statusLabel: string;
+    statusOpen: string;
+    statusSoldOut: string;
+    timezoneLabel: string;
+    viewLabel: string;
+}
+export declare function getSlotStatusLabel(status: AvailabilitySlotRow["status"], messages: AvailabilityColumnsMessages): string;
+export declare const availabilityRuleColumns: (products: ProductOption[], onView: (ruleId: string) => void, messages: AvailabilityColumnsMessages) => ColumnDef<AvailabilityRuleRow>[];
+export declare const availabilityStartTimeColumns: (products: ProductOption[], onView: (startTimeId: string) => void, messages: AvailabilityColumnsMessages) => ColumnDef<AvailabilityStartTimeRow>[];
+export declare const availabilitySlotColumns: (products: ProductOption[], onView: (slotId: string) => void, messages: AvailabilityColumnsMessages, onEdit?: (slot: AvailabilitySlotRow) => void) => ColumnDef<AvailabilitySlotRow>[];
+export declare const availabilityCloseoutColumns: (products: ProductOption[], messages: AvailabilityColumnsMessages) => ColumnDef<AvailabilityCloseoutRow>[];
+export declare const availabilityPickupPointColumns: (products: ProductOption[], messages: AvailabilityColumnsMessages) => ColumnDef<AvailabilityPickupPointRow>[];
+//# sourceMappingURL=availability-columns.d.ts.map

package/dist/availability/components/availability-columns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"availability-columns.d.ts","sourceRoot":"","sources":["../../../src/availability/components/availability-columns.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAMtD,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EAC/B,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,aAAa,EAKnB,MAAM,aAAa,CAAA;AAGpB,MAAM,WAAW,2BAA2B;IAC1C,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE;QACP,OAAO,EAAE,MAAM,CAAA;KAChB,CAAA;IACD,aAAa,EAAE,MAAM,CAAA;IACrB,UAAU,EAAE,MAAM,CAAA;IAClB,aAAa,EAAE,MAAM,CAAA;IACrB,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,MAAM,CAAA;IACpB,iBAAiB,EAAE,MAAM,CAAA;IACzB,WAAW,EAAE,MAAM,CAAA;IACnB,eAAe,EAAE,MAAM,CAAA;IACvB,iBAAiB,EAAE,MAAM,CAAA;IACzB,aAAa,EAAE,MAAM,CAAA;IACrB,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,aAAa,EAAE,MAAM,CAAA;IACrB,YAAY,EAAE,MAAM,CAAA;IACpB,eAAe,EAAE,MAAM,CAAA;IACvB,YAAY,EAAE,MAAM,CAAA;IACpB,cAAc,EAAE,MAAM,CAAA;IACtB,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;IAClB,aAAa,EAAE,MAAM,CAAA;IACrB,aAAa,EAAE,MAAM,CAAA;IACrB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,mBAAmB,CAAC,QAAQ,CAAC,EACrC,QAAQ,EAAE,2BAA2B,UAYtC;AAwCD,eAAO,MAAM,uBAAuB,GAClC,UAAU,aAAa,EAAE,EACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EAChC,UAAU,2BAA2B,KACpC,SAAS,CAAC,mBAAmB,CAAC,EA2ChC,CAAA;AAED,eAAO,MAAM,4BAA4B,GACvC,UAAU,aAAa,EAAE,EACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,EACrC,UAAU,2BAA2B,KACpC,SAAS,CAAC,wBAAwB,CAAC,EAyCrC,CAAA;AAED,eAAO,MAAM,uBAAuB,GAClC,UAAU,aAAa,EAAE,EACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EAChC,UAAU,2BAA2B,EACrC,SAAS,CAAC,IAAI,EAAE,mBAAmB,KAAK,IAAI,KAC3C,SAAS,CAAC,mBAAmB,CAAC,EA2DhC,CAAA;AAED,eAAO,MAAM,2BAA2B,GACtC,UAAU,aAAa,EAAE,EACzB,UAAU,2BAA2B,KACpC,SAAS,CAAC,uBAAuB,CAAC,EAoBpC,CAAA;AAED,eAAO,MAAM,8BAA8B,GACzC,UAAU,aAAa,EAAE,EACzB,UAAU,2BAA2B,KACpC,SAAS,CAAC,0BAA0B,CAAC,EA0BvC,CAAA"}

package/dist/availability/components/availability-columns.js

@@ -0,0 +1,182 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Badge, Button } from "@voyant-travel/ui/components";
+import { DataTableColumnHeader } from "@voyant-travel/ui/components/data-table-column-header";
+import { cn } from "@voyant-travel/ui/lib/utils";
+import { ExternalLink, Pencil } from "lucide-react";
+import { useAvailabilityUiMessagesOrDefault } from "../i18n/index.js";
+import { productNameById, slotLocalEnd, slotLocalStart, slotStatusTone, } from "../index.js";
+import { slotStatusToneClass } from "./slot-status-tone.js";
+export function getSlotStatusLabel(status, messages) {
+    switch (status) {
+        case "open":
+            return messages.statusOpen;
+        case "closed":
+            return messages.statusClosed;
+        case "sold_out":
+            return messages.statusSoldOut;
+        case "cancelled":
+            return messages.statusCancelled;
+    }
+}
+function formatSlotLocalDateTime(value) {
+    return `${value.date} ${value.time}`;
+}
+function ViewButton({ label, onClick }) {
+    useAvailabilityUiMessagesOrDefault();
+    return (_jsxs(Button, { variant: "ghost", size: "sm", onClick: (event) => {
+            event.stopPropagation();
+            onClick();
+        }, children: [_jsx(ExternalLink, { className: "mr-2 h-4 w-4" }), label] }));
+}
+function EditButton({ label, onClick }) {
+    useAvailabilityUiMessagesOrDefault();
+    return (_jsxs(Button, { variant: "ghost", size: "sm", onClick: (event) => {
+            event.stopPropagation();
+            onClick();
+        }, children: [_jsx(Pencil, { className: "mr-2 h-4 w-4" }), label] }));
+}
+export const availabilityRuleColumns = (products, onView, messages) => [
+    {
+        accessorKey: "productId",
+        header: ({ column }) => _jsx(DataTableColumnHeader, { column: column, title: messages.productLabel }),
+        cell: ({ row }) => productNameById(products, row.original.productId, row.original.productName),
+    },
+    {
+        accessorKey: "timezone",
+        header: ({ column }) => (_jsx(DataTableColumnHeader, { column: column, title: messages.timezoneLabel })),
+    },
+    {
+        accessorKey: "recurrenceRule",
+        header: ({ column }) => (_jsx(DataTableColumnHeader, { column: column, title: messages.recurrenceLabel })),
+        cell: ({ row }) => (_jsx("span", { className: "max-w-[380px] truncate font-mono text-xs", children: row.original.recurrenceRule })),
+    },
+    {
+        accessorKey: "maxCapacity",
+        header: ({ column }) => _jsx(DataTableColumnHeader, { column: column, title: messages.maxPaxLabel }),
+    },
+    {
+        accessorKey: "active",
+        header: ({ column }) => _jsx(DataTableColumnHeader, { column: column, title: messages.activeLabel }),
+        cell: ({ row }) => (_jsx(Badge, { variant: row.original.active ? "default" : "secondary", children: row.original.active ? messages.statusActive : messages.statusInactive })),
+    },
+    {
+        id: "view",
+        header: messages.viewLabel,
+        cell: ({ row }) => (_jsx(ViewButton, { label: messages.openLabel, onClick: () => onView(row.original.id) })),
+    },
+];
+export const availabilityStartTimeColumns = (products, onView, messages) => [
+    {
+        accessorKey: "productId",
+        header: ({ column }) => _jsx(DataTableColumnHeader, { column: column, title: messages.productLabel }),
+        cell: ({ row }) => productNameById(products, row.original.productId, row.original.productName),
+    },
+    {
+        accessorKey: "label",
+        header: ({ column }) => _jsx(DataTableColumnHeader, { column: column, title: messages.labelLabel }),
+        cell: ({ row }) => row.original.label ?? messages.details.noValue,
+    },
+    {
+        accessorKey: "startTimeLocal",
+        header: ({ column }) => _jsx(DataTableColumnHeader, { column: column, title: messages.startLabel }),
+    },
+    {
+        accessorKey: "durationMinutes",
+        header: ({ column }) => (_jsx(DataTableColumnHeader, { column: column, title: messages.durationLabel })),
+        cell: ({ row }) => row.original.durationMinutes == null
+            ? messages.details.noValue
+            : `${row.original.durationMinutes} min`,
+    },
+    {
+        accessorKey: "active",
+        header: ({ column }) => _jsx(DataTableColumnHeader, { column: column, title: messages.statusLabel }),
+        cell: ({ row }) => (_jsx(Badge, { variant: row.original.active ? "default" : "secondary", children: row.original.active ? messages.statusActive : messages.statusInactive })),
+    },
+    {
+        id: "view",
+        header: messages.viewLabel,
+        cell: ({ row }) => (_jsx(ViewButton, { label: messages.openLabel, onClick: () => onView(row.original.id) })),
+    },
+];
+export const availabilitySlotColumns = (products, onView, messages, onEdit) => [
+    {
+        accessorKey: "productId",
+        header: ({ column }) => _jsx(DataTableColumnHeader, { column: column, title: messages.productLabel }),
+        cell: ({ row }) => productNameById(products, row.original.productId, row.original.productName),
+    },
+    {
+        accessorKey: "startsAt",
+        header: ({ column }) => (_jsx(DataTableColumnHeader, { column: column, title: messages.startsAtLabel })),
+        cell: ({ row }) => formatSlotLocalDateTime(slotLocalStart(row.original)),
+    },
+    {
+        accessorKey: "endsAt",
+        header: ({ column }) => _jsx(DataTableColumnHeader, { column: column, title: messages.endsAtLabel }),
+        cell: ({ row }) => row.original.endsAt
+            ? formatSlotLocalDateTime(slotLocalEnd(row.original) ?? slotLocalStart(row.original))
+            : messages.details.noValue,
+    },
+    {
+        accessorKey: "initialPax",
+        header: ({ column }) => (_jsx(DataTableColumnHeader, { column: column, title: messages.totalPaxLabel })),
+        cell: ({ row }) => row.original.initialPax ?? messages.details.noValue,
+    },
+    {
+        accessorKey: "remainingPax",
+        header: ({ column }) => (_jsx(DataTableColumnHeader, { column: column, title: messages.remainingPaxLabel })),
+        cell: ({ row }) => row.original.remainingPax ?? messages.details.noValue,
+    },
+    {
+        accessorKey: "status",
+        header: ({ column }) => _jsx(DataTableColumnHeader, { column: column, title: messages.statusLabel }),
+        cell: ({ row }) => (_jsx(Badge, { variant: "outline", className: cn("capitalize", slotStatusToneClass[slotStatusTone[row.original.status]]), children: getSlotStatusLabel(row.original.status, messages) })),
+    },
+    {
+        id: "actions",
+        header: () => _jsx("span", { className: "sr-only", children: messages.viewLabel }),
+        cell: ({ row }) => (_jsxs("div", { className: "flex items-center justify-end gap-1", children: [onEdit ? (_jsx(EditButton, { label: messages.editLabel, onClick: () => onEdit(row.original) })) : null, _jsx(ViewButton, { label: messages.openLabel, onClick: () => onView(row.original.id) })] })),
+    },
+];
+export const availabilityCloseoutColumns = (products, messages) => [
+    {
+        accessorKey: "productId",
+        header: ({ column }) => _jsx(DataTableColumnHeader, { column: column, title: messages.productLabel }),
+        cell: ({ row }) => productNameById(products, row.original.productId, row.original.productName),
+    },
+    {
+        accessorKey: "dateLocal",
+        header: ({ column }) => _jsx(DataTableColumnHeader, { column: column, title: messages.dateLabel }),
+    },
+    {
+        accessorKey: "slotId",
+        header: ({ column }) => _jsx(DataTableColumnHeader, { column: column, title: messages.slotLabel }),
+        cell: ({ row }) => row.original.slotId ?? messages.productLevelLabel,
+    },
+    {
+        accessorKey: "reason",
+        header: ({ column }) => _jsx(DataTableColumnHeader, { column: column, title: messages.reasonLabel }),
+        cell: ({ row }) => row.original.reason ?? messages.details.noValue,
+    },
+];
+export const availabilityPickupPointColumns = (products, messages) => [
+    {
+        accessorKey: "productId",
+        header: ({ column }) => _jsx(DataTableColumnHeader, { column: column, title: messages.productLabel }),
+        cell: ({ row }) => productNameById(products, row.original.productId, row.original.productName),
+    },
+    {
+        accessorKey: "name",
+        header: ({ column }) => _jsx(DataTableColumnHeader, { column: column, title: messages.nameLabel }),
+    },
+    {
+        accessorKey: "locationText",
+        header: ({ column }) => (_jsx(DataTableColumnHeader, { column: column, title: messages.locationLabel })),
+        cell: ({ row }) => row.original.locationText ?? messages.details.noValue,
+    },
+    {
+        accessorKey: "active",
+        header: ({ column }) => _jsx(DataTableColumnHeader, { column: column, title: messages.statusLabel }),
+        cell: ({ row }) => (_jsx(Badge, { variant: row.original.active ? "default" : "secondary", children: row.original.active ? messages.statusActive : messages.statusInactive })),
+    },
+];

package/dist/availability/components/availability-dialogs/closeout-dialog.d.ts

@@ -0,0 +1,13 @@
+import type { AvailabilityCloseoutRow, AvailabilitySlotRow, ProductOption } from "../../index.js";
+import { type AvailabilityCloseoutSubmitPayload, type AvailabilityDialogMessages, type SubmitContext } from "./shared.js";
+export declare function AvailabilityCloseoutDialog(props: {
+    messages: AvailabilityDialogMessages;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    closeout?: AvailabilityCloseoutRow;
+    products: ProductOption[];
+    slots: AvailabilitySlotRow[];
+    onSubmit: (payload: AvailabilityCloseoutSubmitPayload, context: SubmitContext) => Promise<void>;
+    onSuccess: () => void;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=closeout-dialog.d.ts.map

package/dist/availability/components/availability-dialogs/closeout-dialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"closeout-dialog.d.ts","sourceRoot":"","sources":["../../../../src/availability/components/availability-dialogs/closeout-dialog.tsx"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEjG,OAAO,EACL,KAAK,iCAAiC,EACtC,KAAK,0BAA0B,EAI/B,KAAK,aAAa,EACnB,MAAM,aAAa,CAAA;AAepB,wBAAgB,0BAA0B,CAAC,KAAK,EAAE;IAChD,QAAQ,EAAE,0BAA0B,CAAA;IACpC,IAAI,EAAE,OAAO,CAAA;IACb,YAAY,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAA;IACrC,QAAQ,CAAC,EAAE,uBAAuB,CAAA;IAClC,QAAQ,EAAE,aAAa,EAAE,CAAA;IACzB,KAAK,EAAE,mBAAmB,EAAE,CAAA;IAC5B,QAAQ,EAAE,CAAC,OAAO,EAAE,iCAAiC,EAAE,OAAO,EAAE,aAAa,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC/F,SAAS,EAAE,MAAM,IAAI,CAAA;CACtB,2CAiHA"}