@session-services/web-elements 0.1.20 → 0.1.22

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

@@ -0,0 +1,270 @@
+import { formatNaiveDateTime, isNaiveDateTimeFuture, isNaiveDateTimePast, } from "@session-services/utils/naive-datetime";
+import { createQuoteItemMap } from "@session-services/utils/ticket-quote";
+import { getAdmissionSelectionCapacity, isAdmissionSoldOut, } from "@session-services/utils/ticket-availability";
+const UNLIMITED_CAP = 10;
+const SCARCITY_THRESHOLD = 20;
+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, zone, sections) {
+    if (!hasAdmissionSection(admission, sections))
+        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, zone, sections));
+}
+function admissionSaleLabel(admission, zone) {
+    if (!isNaiveDateTimeFuture(admission.saleStartsAt, zone)) {
+        return null;
+    }
+    return {
+        text: `On sale ${formatNaiveDateTime(admission.saleStartsAt, "EEE, MMM d · h:mm a")}`,
+        tone: "muted",
+    };
+}
+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) => admission.visibility !== "HIDDEN" &&
+        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",
+    };
+}
+export function visibleAdmissions(event, mode) {
+    if (mode !== "door")
+        return event.admissions;
+    const zone = eventTimeZone(event);
+    return event.admissions.filter((admission) => admission.saleEndsBehavior === "DOOR" &&
+        isNaiveDateTimePast(admission.saleEndsAt, zone));
+}
+function sectionItems(sections, admissions) {
+    return sections
+        .map((section) => ({
+        type: "section",
+        section,
+        admissions: admissions
+            .filter((admission) => admission.sectionId === section.id)
+            .sort((a, b) => a.order - b.order),
+    }))
+        .filter((item) => item.admissions.length > 0);
+}
+function topLevelOrder(item) {
+    if (item.type === "section")
+        return item.section.order;
+    return item.admission.order;
+}
+export function topLevelTicketItems(sections, admissions) {
+    return [
+        ...sectionItems(sections, admissions),
+        ...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);
+}
+export function getAdmissionDisplayState(input) {
+    const zone = eventTimeZone(input.event);
+    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,
+        label: admissionSaleLabel(input.admission, zone),
+        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);
+}
+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,
+    };
+}
+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 (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,
+    }));
+}

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

@@ -0,0 +1,368 @@
+import { describe, expect, it } from "vitest";
+import { admissionPriceSavings, discountCouponFromSearch, getAdmissionDisplayState, getAdmissionPriceDisplay, getTicketingState, topLevelTicketItems, visibleAdmissions, } from "./session-services-ticketing.logic";
+const futureStart = "2030-01-01T20:00:00";
+const futureEnd = "2030-01-01T23:00:00";
+const pastStart = "2020-01-01T20:00:00";
+const pastEnd = "2020-01-01T23:00:00";
+function admission(data = {}) {
+    return {
+        id: "adm_general",
+        name: "General Admission",
+        capacity: 100,
+        available: 100,
+        sold: 0,
+        reserved: 0,
+        limit: 10,
+        order: 1,
+        entryStartsAt: futureStart,
+        entryEndsAt: futureEnd,
+        saleStartsAt: pastStart,
+        saleEndsAt: futureEnd,
+        saleEndsBehavior: "SALE_ENDED",
+        price: {
+            base: 2000,
+            booking: 200,
+            currency: "AUD",
+        },
+        visibility: "ALWAYS",
+        teamId: "team_1",
+        promoterId: "pro_1",
+        eventId: "evt_1",
+        eventSlug: "event",
+        ...data,
+    };
+}
+function section(data = {}) {
+    return {
+        id: "sec_1",
+        name: "Main Room",
+        capacity: 100,
+        available: 100,
+        sold: 0,
+        reserved: 0,
+        limit: 10,
+        order: 2,
+        teamId: "team_1",
+        promoterId: "pro_1",
+        eventId: "evt_1",
+        eventSlug: "event",
+        location: {
+            id: "loc_1",
+            name: "Club Room",
+            address: "1 Test St",
+            city: "Sydney",
+            country: "AU",
+            latitude: -33.86,
+            longitude: 151.2,
+            timeZone: "Australia/Sydney",
+            createdAt: pastStart,
+            updatedAt: pastStart,
+        },
+        ...data,
+    };
+}
+function event(data = {}) {
+    return {
+        id: "evt_1",
+        name: "Test Event",
+        slug: "event",
+        currency: "AUD",
+        entryStartsAt: futureStart,
+        entryEndsAt: futureEnd,
+        publishAt: pastStart,
+        updatedAt: pastStart,
+        status: "UPCOMING",
+        visibility: "PUBLIC",
+        approval: "APPROVED",
+        teamId: "team_1",
+        promoterId: "pro_1",
+        admissions: [admission()],
+        sections: [],
+        images: {},
+        location: {
+            id: "loc_1",
+            name: "Club",
+            address: "1 Test St",
+            city: "Sydney",
+            country: "AU",
+            latitude: -33.86,
+            longitude: 151.2,
+            timeZone: "Australia/Sydney",
+            createdAt: pastStart,
+            updatedAt: pastStart,
+        },
+        ...data,
+    };
+}
+function quoteItem(data = {}) {
+    return {
+        id: "item_1",
+        kind: "ADMISSION",
+        admissionId: "adm_general",
+        quantity: 1,
+        price: {
+            base: 2000,
+            booking: 200,
+            currency: "AUD",
+            discount: -1000,
+            gross: 2200,
+            net: 1200,
+            refunded: 0,
+            total: 1200,
+        },
+        ...data,
+    };
+}
+describe("session-services-ticketing logic", () => {
+    it("reads discount coupon codes from query strings", () => {
+        expect(discountCouponFromSearch("?discount=save20")).toBe("save20");
+        expect(discountCouponFromSearch("?utm_source=test&discount=SAVE20")).toBe("SAVE20");
+        expect(discountCouponFromSearch("?coupon=SAVE20")).toBe("");
+    });
+    it("shows external ticketing instead of internal selection when an external URL exists", () => {
+        const state = getTicketingState(event({ url: "https://tickets.example" }));
+        expect(state.showExternalTicketing).toBe(true);
+        expect(state.showTicketing).toBe(false);
+        expect(state.externalTicketUrl).toBe("https://tickets.example");
+    });
+    it("detects door-only events and filters to door admissions", () => {
+        const door = admission({
+            id: "adm_door",
+            saleEndsAt: pastEnd,
+            saleEndsBehavior: "DOOR",
+        });
+        const ended = admission({
+            id: "adm_ended",
+            saleEndsAt: pastEnd,
+            saleEndsBehavior: "SALE_ENDED",
+        });
+        const data = event({ admissions: [door, ended] });
+        expect(getTicketingState(data).isDoorOnly).toBe(true);
+        expect(visibleAdmissions(data, "door").map((item) => item.id)).toEqual([
+            "adm_door",
+        ]);
+    });
+    it("disables admissions outside their online sale window", () => {
+        const data = event({
+            admissions: [
+                admission({
+                    saleStartsAt: futureStart,
+                    saleEndsAt: "2030-01-02T20:00:00",
+                }),
+            ],
+        });
+        const state = getAdmissionDisplayState({
+            admission: data.admissions[0],
+            event: data,
+        });
+        expect(state.disabled).toBe(true);
+        expect(state.label?.text).toContain("On sale");
+    });
+    it("treats sold-out sale endings as sold out instead of a price label", () => {
+        const data = event({
+            admissions: [
+                admission({
+                    saleEndsAt: pastEnd,
+                    saleEndsBehavior: "SOLD_OUT",
+                }),
+            ],
+        });
+        const state = getAdmissionDisplayState({
+            admission: data.admissions[0],
+            event: data,
+        });
+        expect(state.disabled).toBe(true);
+        expect(state.label).toBeNull();
+        expect(state.soldOut).toBe(true);
+        expect(state.statusLabel).toBe("Sold Out");
+        expect(state.statusTone).toBe("destructive");
+    });
+    it("moves post-sale labels into admission status", () => {
+        const data = event({
+            admissions: [
+                admission({
+                    saleEndsAt: pastEnd,
+                    saleEndsBehavior: "SALE_ENDED",
+                }),
+                admission({
+                    id: "adm_door",
+                    saleEndsAt: pastEnd,
+                    saleEndsBehavior: "DOOR",
+                }),
+            ],
+        });
+        const ended = getAdmissionDisplayState({
+            admission: data.admissions[0],
+            event: data,
+        });
+        const door = getAdmissionDisplayState({
+            admission: data.admissions[1],
+            event: data,
+        });
+        expect(ended.label).toBeNull();
+        expect(ended.statusLabel).toBe("Sale Ended");
+        expect(ended.statusTone).toBe("destructive");
+        expect(door.label).toBeNull();
+        expect(door.statusLabel).toBe("Available At Door");
+        expect(door.statusTone).toBe("success");
+    });
+    it("shows sold-out door admissions as available at door while online sales continue", () => {
+        const data = event({
+            admissions: [
+                admission({
+                    id: "adm_first_release",
+                    available: 0,
+                    sold: 54,
+                    capacity: 54,
+                    order: 20,
+                    saleEndsAt: futureEnd,
+                    saleEndsBehavior: "DOOR",
+                }),
+                admission({
+                    id: "adm_final_release",
+                    available: 997,
+                    sold: 3,
+                    capacity: 1000,
+                    order: 40,
+                    saleEndsAt: futureEnd,
+                    saleEndsBehavior: "DOOR",
+                }),
+            ],
+        });
+        const first = getAdmissionDisplayState({
+            admission: data.admissions[0],
+            event: data,
+        });
+        const final = getAdmissionDisplayState({
+            admission: data.admissions[1],
+            event: data,
+        });
+        expect(first.disabled).toBe(true);
+        expect(first.soldOut).toBe(true);
+        expect(first.statusLabel).toBe("Available At Door");
+        expect(first.statusTone).toBe("success");
+        expect(final.disabled).toBe(false);
+        expect(final.statusLabel).toBeNull();
+    });
+    it("orders top-level sections and unsectioned admissions together", () => {
+        const main = section({ id: "sec_main", order: 2 });
+        const early = admission({ id: "adm_early", order: 1 });
+        const sectioned = admission({
+            id: "adm_sectioned",
+            order: 1,
+            sectionId: main.id,
+        });
+        const items = topLevelTicketItems([main], [sectioned, early]);
+        expect(items.map((item) => item.type)).toEqual(["admission", "section"]);
+    });
+    it("caps unlimited admission quantity at the selector limit", () => {
+        const data = event({
+            admissions: [admission({ available: -1, capacity: -1 })],
+        });
+        expect(getAdmissionDisplayState({
+            admission: data.admissions[0],
+            event: data,
+        }).maxQuantity).toBe(10);
+    });
+    it("uses discounted quote pricing when available", () => {
+        const price = getAdmissionPriceDisplay({
+            admission: admission(),
+            mode: "default",
+            quoteItem: quoteItem(),
+        });
+        expect(price).toEqual({
+            base: 1000,
+            discounted: true,
+            fees: 200,
+            gross: 2000,
+        });
+    });
+    it("uses quote item base pricing without discount styling", () => {
+        const price = getAdmissionPriceDisplay({
+            admission: admission(),
+            mode: "default",
+            quoteItem: quoteItem({
+                price: {
+                    base: 2000,
+                    booking: 200,
+                    currency: "AUD",
+                    discount: 0,
+                    gross: 2200,
+                    net: 2250,
+                    refunded: 0,
+                    total: 2250,
+                },
+            }),
+        });
+        expect(price).toEqual({
+            base: 2000,
+            discounted: false,
+            fees: 200,
+        });
+    });
+    it("separates admission base and booking fees for every mode", () => {
+        expect(getAdmissionPriceDisplay({
+            admission: admission(),
+            mode: "default",
+        })).toMatchObject({ base: 2000, fees: 200 });
+        expect(getAdmissionPriceDisplay({
+            admission: admission(),
+            mode: "door",
+        })).toMatchObject({ base: 2000, fees: 200 });
+    });
+    it("uses discounted initial preview pricing when available", () => {
+        const price = getAdmissionPriceDisplay({
+            admission: admission(),
+            initialPrice: {
+                discount: -1000,
+                gross: 2200,
+                total: 1200,
+            },
+            mode: "default",
+        });
+        expect(price).toEqual({
+            base: 1000,
+            discounted: true,
+            fees: 200,
+            gross: 2000,
+        });
+    });
+    it("calculates admission savings from discounted display prices", () => {
+        expect(admissionPriceSavings({
+            base: 1000,
+            discounted: true,
+            fees: 200,
+            gross: 2000,
+        })).toBe(1000);
+        expect(admissionPriceSavings({
+            base: 2200,
+            discounted: false,
+            fees: 200,
+        })).toBe(0);
+    });
+    it("divides preview quote pricing by preview quantity", () => {
+        const price = getAdmissionPriceDisplay({
+            admission: admission(),
+            mode: "default",
+            previewItem: quoteItem({
+                quantity: 2,
+                price: {
+                    base: 4000,
+                    booking: 400,
+                    currency: "AUD",
+                    discount: -2000,
+                    gross: 4400,
+                    net: 2400,
+                    refunded: 0,
+                    total: 2400,
+                },
+            }),
+        });
+        expect(price).toEqual({
+            base: 1000,
+            discounted: true,
+            fees: 200,
+            gross: 2000,
+        });
+    });
+});