@session-services/web-elements 0.1.33 → 0.1.36

package/dist/collection/components/session-services-ticketing/session-services-ticketing.logic.js

@@ -1,385 +1,24 @@
-import { isNaiveDateTimeFuture, isNaiveDateTimePast, parseNaiveDateTime, } from "@session-services/utils/naive-datetime";
-import { getAdmissionReleaseLabel } from "@session-services/utils/admission-release";
-import { getAdmissionSelectionCapacity, isAdmissionSoldOut, } from "@session-services/utils/ticket-availability";
-import { createQuoteItemMap } from "@session-services/utils/ticket-quote";
-const UNLIMITED_CAP = 10;
-const SCARCITY_THRESHOLD = 20;
-const DEFAULT_LOCALE = "en-US";
-export function selectionKey(admissionId, sectionId) {
-    return `${admissionId}::${sectionId || "none"}`;
-}
-export function parseSelectionKey(key) {
-    const [admissionId, sectionId] = key.split("::");
-    return {
-        admissionId,
-        sectionId: sectionId === "none" ? undefined : sectionId,
-    };
-}
-export function priceTotal(price) {
-    if (!price)
-        return 0;
-    if ("total" in price && typeof price.total === "number")
-        return price.total;
-    return (price.base ?? 0) + (price.booking ?? 0);
-}
-export function discountCouponFromSearch(search) {
-    return new URLSearchParams(search).get("discount") ?? "";
-}
-export function eventTimeZone(event) {
-    return event.location?.timeZone ?? "UTC";
-}
-function eventEnded(event) {
-    return isNaiveDateTimePast(event.entryEndsAt, eventTimeZone(event));
-}
-function sectionsById(event) {
-    return new Map(event.sections.map((section) => [section.id, section]));
-}
-function hasAdmissionSection(admission, sections) {
-    if (!admission.sectionId)
-        return true;
-    return sections.has(admission.sectionId);
-}
-function admissionSection(admission, sections) {
-    if (!admission.sectionId)
-        return undefined;
-    return sections.get(admission.sectionId);
-}
-function isAdmissionOnSale(admission, zone) {
-    if (isNaiveDateTimeFuture(admission.saleStartsAt, zone))
-        return false;
-    return !isNaiveDateTimePast(admission.saleEndsAt, zone);
-}
-function hasAdmissionCapacity(admission, section) {
-    return getAdmissionSelectionCapacity({ admission, section }) > 0;
-}
-function isAdmissionPurchasable(admission, admissions, zone, sections) {
-    if (!hasAdmissionSection(admission, sections))
-        return false;
-    if (getAdmissionReleaseLabel(admission, admissions, zone))
-        return false;
-    if (!isAdmissionOnSale(admission, zone))
-        return false;
-    return hasAdmissionCapacity(admission, admissionSection(admission, sections));
-}
-function hasPurchasableAdmissions(event) {
-    const sections = sectionsById(event);
-    const zone = eventTimeZone(event);
-    return event.admissions.some((admission) => isAdmissionPurchasable(admission, event.admissions, zone, sections));
-}
-function admissionSaleLabel(admission, zone, locale) {
-    if (!isNaiveDateTimeFuture(admission.saleStartsAt, zone)) {
-        return null;
-    }
-    const date = parseNaiveDateTime(admission.saleStartsAt, "UTC");
-    const day = dateFormatter(locale, {
-        day: "numeric",
-        month: "short",
-        timeZone: "UTC",
-        weekday: "short",
-    }).format(date);
-    const time = dateFormatter(locale, {
-        hour: "numeric",
-        minute: "2-digit",
-        timeZone: "UTC",
-    }).format(date);
-    return {
-        text: `On sale ${day} · ${time}`,
-        tone: "muted",
-    };
-}
-function dateFormatter(locale, options) {
-    try {
-        return new Intl.DateTimeFormat(locale, options);
-    }
-    catch {
-        return new Intl.DateTimeFormat(DEFAULT_LOCALE, options);
-    }
-}
-function admissionStatus(input) {
-    if (input.value === "DOOR" && (input.soldOut || input.saleEnded)) {
-        return { text: "Available At Door", tone: "success" };
-    }
-    if (input.soldOut)
-        return { text: "Sold Out", tone: "destructive" };
-    if (!input.saleEnded)
-        return null;
-    return { text: "Sale Ended", tone: "destructive" };
-}
-function endedStatus(admissions, zone) {
-    const ended = admissions.filter((admission) => isNaiveDateTimePast(admission.saleEndsAt, zone));
-    if (ended.length === 0)
-        return undefined;
-    if (ended.some((admission) => admission.saleEndsBehavior === "DOOR"))
-        return "DOOR";
-    if (ended.every((admission) => admission.saleEndsBehavior === "SOLD_OUT"))
-        return "SOLD_OUT";
-    return "SALE_ENDED";
-}
-function salesStatus(event) {
-    const sections = sectionsById(event);
-    const admissions = event.admissions.filter((admission) => hasAdmissionSection(admission, sections));
-    if (admissions.length === 0)
-        return undefined;
-    if (hasPurchasableAdmissions(event))
-        return "ONLINE";
-    return endedStatus(admissions, eventTimeZone(event));
-}
-function hasDisplayableAdmissions(event) {
-    const sections = sectionsById(event);
-    return event.admissions.some((admission) => hasAdmissionSection(admission, sections));
-}
-function isDoorOnly(event) {
-    if (hasPurchasableAdmissions(event))
-        return false;
-    return salesStatus(event) === "DOOR";
-}
-export function getTicketingState(event) {
-    const ended = eventEnded(event);
-    const externalTicketUrl = event.url || undefined;
-    const doorOnly = isDoorOnly(event);
-    const showExternalTicketing = !ended && Boolean(externalTicketUrl);
-    const showTicketing = !ended && !showExternalTicketing && hasDisplayableAdmissions(event);
-    return {
-        externalTicketUrl,
-        isDoorOnly: doorOnly,
-        isEnded: ended,
-        isUnavailableForSale: !doorOnly && !hasPurchasableAdmissions(event) && showTicketing,
-        showExternalTicketing,
-        showTicketing,
-        ticketHeading: doorOnly ? "Tickets at the Door" : "Get Tickets",
-    };
-}
+import { discountCouponFromSearch, getTicketAdmissionDisplayState, getTicketAdmissionPriceDisplay, getTicketPreviewItems, getTicketSelectorState, getTopLevelTicketItems, getVisibleTicketAdmissions, parseTicketSelectionKey, quoteItemsByTicketSelection, ticketAdmissionPriceSavings, ticketEventTimeZone, ticketPriceTotal, ticketSelectionKey, } from "@session-services/utils/ticket-selector";
+export const selectionKey = ticketSelectionKey;
+export const parseSelectionKey = parseTicketSelectionKey;
+export const priceTotal = ticketPriceTotal;
+export { discountCouponFromSearch };
+export const eventTimeZone = ticketEventTimeZone;
+export const getTicketingState = getTicketSelectorState;
 export function visibleAdmissions(event, mode) {
-    if (mode !== "door")
-        return event.admissions;
-    const zone = eventTimeZone(event);
-    return event.admissions.filter((admission) => !getAdmissionReleaseLabel(admission, event.admissions, zone) &&
-        admission.saleEndsBehavior === "DOOR" &&
-        isNaiveDateTimePast(admission.saleEndsAt, zone));
-}
-function isStackableAdmission(input) {
-    if (input.mode === "door")
-        return true;
-    if (!input.event)
-        return true;
-    return !getAdmissionDisplayState({
-        admission: input.admission,
-        event: input.event,
-        section: input.section,
-    }).disabled;
-}
-function stackedAdmissionBase(input) {
-    const key = selectionKey(input.admission.id, input.section.id);
-    return getAdmissionPriceDisplay({
-        admission: input.admission,
-        initialPrice: input.initialAdmissionPrices?.[key],
-        mode: input.mode,
-        previewItem: input.previewItems.get(key),
-        quoteItem: input.quoteItems.get(key),
-    }).base;
-}
-function compareStackedAdmissions(input, section) {
-    const mode = input.mode ?? "default";
-    const previewItems = quoteItemsBySelection(input.previewQuote ?? null);
-    const quoteItems = quoteItemsBySelection(input.quote ?? null);
-    return (a, b) => {
-        const price = stackedAdmissionBase({
-            admission: a,
-            initialAdmissionPrices: input.initialAdmissionPrices,
-            mode,
-            previewItems,
-            quoteItems,
-            section,
-        }) -
-            stackedAdmissionBase({
-                admission: b,
-                initialAdmissionPrices: input.initialAdmissionPrices,
-                mode,
-                previewItems,
-                quoteItems,
-                section,
-            });
-        if (price !== 0)
-            return price;
-        const order = a.order - b.order;
-        if (order !== 0)
-            return order;
-        return a.id.localeCompare(b.id);
-    };
-}
-function cap(value) {
-    if (value == null || value === -1)
-        return Number.POSITIVE_INFINITY;
-    return Math.max(0, value);
-}
-function shouldShowNextStackedAdmission(admission) {
-    const remaining = cap(admission.available);
-    if (!Number.isFinite(remaining))
-        return false;
-    const limit = cap(admission.limit);
-    if (!Number.isFinite(limit))
-        return remaining < UNLIMITED_CAP;
-    return limit > remaining;
-}
-function displayedSectionAdmissions(section, admissions, input) {
-    const sorted = admissions
-        .filter((admission) => admission.sectionId === section.id)
-        .sort((a, b) => a.order - b.order);
-    if (section.visibility !== "STACKED" || sorted.length <= 1) {
-        return sorted;
-    }
-    const mode = input.mode ?? "default";
-    const stackable = sorted.filter((admission) => isStackableAdmission({
-        admission,
-        event: input.event,
-        mode,
-        section,
-    }));
-    const candidates = stackable.length > 0 ? stackable : sorted;
-    const [admission, next] = [...candidates].sort(compareStackedAdmissions(input, section));
-    if (!admission)
-        return [];
-    if (!next || !shouldShowNextStackedAdmission(admission)) {
-        return [admission];
-    }
-    return [admission, next];
-}
-function sectionItems(sections, admissions, input) {
-    return sections
-        .map((section) => ({
-        type: "section",
-        section,
-        admissions: displayedSectionAdmissions(section, admissions, input),
-    }))
-        .filter((item) => item.admissions.length > 0);
-}
-function topLevelOrder(item) {
-    if (item.type === "section")
-        return item.section.order;
-    return item.admission.order;
+    return getVisibleTicketAdmissions(event, mode);
 }
 export function topLevelTicketItems(sections, admissions, input = {}) {
-    return [
-        ...sectionItems(sections, admissions, input),
-        ...admissions
-            .filter((admission) => !admission.sectionId)
-            .map((admission) => ({ type: "admission", admission })),
-    ].sort((a, b) => topLevelOrder(a) - topLevelOrder(b));
-}
-function isUnlimitedAdmission(admission, section) {
-    if ((admission.available ?? 0) !== -1)
-        return false;
-    if (admission.capacity !== -1)
-        return false;
-    return !section || (section.available ?? 0) === -1;
-}
-function maxQuantity(admission, section) {
-    if (isUnlimitedAdmission(admission, section))
-        return UNLIMITED_CAP;
-    return Math.min(getAdmissionSelectionCapacity({ admission, section }), UNLIMITED_CAP);
-}
-function showScarcity(admission, soldOut, disabled) {
-    return [
-        !soldOut,
-        !disabled,
-        (admission.available ?? 0) > 0,
-        (admission.available ?? 0) < SCARCITY_THRESHOLD,
-    ].every(Boolean);
+    return getTopLevelTicketItems(sections, admissions, input);
 }
 export function getAdmissionDisplayState(input) {
-    const zone = eventTimeZone(input.event);
-    const releaseLabel = getAdmissionReleaseLabel(input.admission, input.event.admissions, zone);
-    const saleNotStarted = isNaiveDateTimeFuture(input.admission.saleStartsAt, zone);
-    const saleEnded = isNaiveDateTimePast(input.admission.saleEndsAt, zone);
-    const saleEndedSoldOut = saleEnded && input.admission.saleEndsBehavior === "SOLD_OUT";
-    const soldOut = Boolean(input.sectionSoldOut) ||
-        saleEndedSoldOut ||
-        isAdmissionSoldOut({
-            admission: input.admission,
-            section: input.section,
-        });
-    const disabled = soldOut || saleNotStarted || saleEnded;
-    const status = admissionStatus({
-        saleEnded,
-        soldOut,
-        value: input.admission.saleEndsBehavior,
-    });
-    return {
-        disabled: disabled || Boolean(releaseLabel),
-        label: releaseLabel
-            ? { ...releaseLabel, tone: "muted" }
-            : admissionSaleLabel(input.admission, zone, input.locale ?? DEFAULT_LOCALE),
-        maxQuantity: maxQuantity(input.admission, input.section),
-        postSale: saleEnded,
-        showScarcity: showScarcity(input.admission, soldOut, disabled),
-        soldOut,
-        statusLabel: status?.text ?? null,
-        statusTone: status?.tone ?? null,
-    };
-}
-function quoteItemUnits(item) {
-    return Math.max(item?.quantity ?? 1, 1);
+    return getTicketAdmissionDisplayState(input);
 }
 export function getAdmissionPriceDisplay(input) {
-    const item = input.quoteItem ?? input.previewItem;
-    if (item) {
-        const units = quoteItemUnits(item);
-        const base = Math.round(Math.max((item.price.base + item.price.discount) / units, 0));
-        const fees = Math.round(item.price.booking / units);
-        if (!item.price.discount || item.price.discount >= 0) {
-            return {
-                base,
-                discounted: false,
-                fees,
-            };
-        }
-        return {
-            base,
-            discounted: true,
-            fees,
-            gross: Math.round(item.price.base / units),
-        };
-    }
-    if (input.initialPrice && input.initialPrice.discount < 0) {
-        const fees = input.admission.price.booking ?? 0;
-        return {
-            base: Math.max(input.initialPrice.total - fees, 0),
-            discounted: true,
-            fees,
-            gross: Math.max(input.initialPrice.gross - fees, 0),
-        };
-    }
-    return {
-        base: input.admission.price.base ?? 0,
-        discounted: false,
-        fees: input.admission.price.booking ?? 0,
-    };
+    return getTicketAdmissionPriceDisplay(input);
 }
 export function quoteItemsBySelection(quote) {
-    return createQuoteItemMap(quote);
-}
-export function admissionPriceSavings(price) {
-    if (!price.discounted || price.gross === undefined)
-        return 0;
-    return Math.max(price.gross - price.base, 0);
-}
-export function previewQuoteItems(event) {
-    const ids = new Set(event.sections.map((section) => section.id));
-    const zone = eventTimeZone(event);
-    return event.admissions
-        .filter((admission) => {
-        if (getAdmissionReleaseLabel(admission, event.admissions, zone)) {
-            return false;
-        }
-        if (admission.sectionId && !ids.has(admission.sectionId))
-            return false;
-        if (isNaiveDateTimeFuture(admission.saleStartsAt, zone))
-            return false;
-        return !isNaiveDateTimePast(admission.saleEndsAt, zone);
-    })
-        .map((admission) => ({
-        admissionId: admission.id ?? "",
-        quantity: 1,
-        sectionId: admission.sectionId ?? undefined,
-    }));
+    return quoteItemsByTicketSelection(quote);
 }
+export const admissionPriceSavings = ticketAdmissionPriceSavings;
+export const previewQuoteItems = getTicketPreviewItems;

package/dist/collection/components/session-services-ticketing/session-services-ticketing.logic.test.js

@@ -504,7 +504,7 @@ describe("session-services-ticketing logic", () => {
             gross: 2000,
         });
     });
-    it("uses quote item base pricing without discount styling", () => {
+    it("uses the customer-inclusive quote price without discount styling", () => {
         const price = getAdmissionPriceDisplay({
             admission: admission(),
             mode: "default",
@@ -514,15 +514,16 @@ describe("session-services-ticketing logic", () => {
                     booking: 200,
                     currency: "AUD",
                     discount: 0,
-                    gross: 2200,
-                    net: 2250,
+                    gross: 2250,
+                    net: 2050,
                     refunded: 0,
+                    tax: 50,
                     total: 2250,
                 },
             }),
         });
         expect(price).toEqual({
-            base: 2000,
+            base: 2050,
             discounted: false,
             fees: 200,
         });

package/dist/collection/components/session-services-ticketing/session-services-ticketing.test.js

@@ -854,6 +854,29 @@ describe("session-services-ticketing component", () => {
             idempotencyKey,
         }));
     });
+    it("delegates only creation to a host backend and retains the attempt key on retry", async () => {
+        const item = widget();
+        item.selectedItems = new Map([[selectionKey("adm_general", null), 1]]);
+        item.client.order.quote = vi.fn().mockResolvedValue({ quote: quote() });
+        item.client.order.create = vi.fn();
+        const createOrder = vi
+            .fn()
+            .mockRejectedValue(new Error("Retry same purchase"));
+        item.createOrder = createOrder;
+        await item.updateQuote();
+        await item.initiateCheckout();
+        await item.initiateCheckout();
+        expect(item.client.order.quote).toHaveBeenCalled();
+        expect(item.client.order.create).not.toHaveBeenCalled();
+        expect(createOrder).toHaveBeenCalledTimes(2);
+        expect(createOrder.mock.calls[0]?.[0].idempotencyKey).toBe(createOrder.mock.calls[1]?.[0].idempotencyKey);
+        expect(createOrder.mock.calls[0]?.[0]).toMatchObject({
+            idempotencyKey: expect.any(String),
+        });
+        expect(createOrder.mock.calls[0]?.[1]).toMatchObject({
+            signal: expect.any(AbortSignal),
+        });
+    });
     it("blocks quantity changes while order creation is pending", async () => {
         const item = widget();
         const pending = deferred();