@session-services/web-elements 0.1.21 → 0.1.23

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

@@ -158,6 +158,92 @@ describe("session-services-ticketing logic", () => {
         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 });
@@ -185,12 +271,13 @@ describe("session-services-ticketing logic", () => {
             quoteItem: quoteItem(),
         });
         expect(price).toEqual({
+            base: 1000,
             discounted: true,
-            gross: 2200,
-            total: 1200,
+            fees: 200,
+            gross: 2000,
         });
     });
-    it("uses quote item total pricing without discount styling", () => {
+    it("uses quote item base pricing without discount styling", () => {
         const price = getAdmissionPriceDisplay({
             admission: admission(),
             mode: "default",
@@ -208,19 +295,20 @@ describe("session-services-ticketing logic", () => {
             }),
         });
         expect(price).toEqual({
+            base: 2000,
             discounted: false,
-            total: 2250,
+            fees: 200,
         });
     });
-    it("includes booking fees in admission prices for every mode", () => {
+    it("separates admission base and booking fees for every mode", () => {
         expect(getAdmissionPriceDisplay({
             admission: admission(),
             mode: "default",
-        }).total).toBe(2200);
+        })).toMatchObject({ base: 2000, fees: 200 });
         expect(getAdmissionPriceDisplay({
             admission: admission(),
             mode: "door",
-        }).total).toBe(2200);
+        })).toMatchObject({ base: 2000, fees: 200 });
     });
     it("uses discounted initial preview pricing when available", () => {
         const price = getAdmissionPriceDisplay({
@@ -233,20 +321,23 @@ describe("session-services-ticketing logic", () => {
             mode: "default",
         });
         expect(price).toEqual({
+            base: 1000,
             discounted: true,
-            gross: 2200,
-            total: 1200,
+            fees: 200,
+            gross: 2000,
         });
     });
     it("calculates admission savings from discounted display prices", () => {
         expect(admissionPriceSavings({
+            base: 1000,
             discounted: true,
-            gross: 2200,
-            total: 1200,
+            fees: 200,
+            gross: 2000,
         })).toBe(1000);
         expect(admissionPriceSavings({
+            base: 2200,
             discounted: false,
-            total: 2200,
+            fees: 200,
         })).toBe(0);
     });
     it("divides preview quote pricing by preview quantity", () => {
@@ -268,9 +359,10 @@ describe("session-services-ticketing logic", () => {
             }),
         });
         expect(price).toEqual({
+            base: 1000,
             discounted: true,
-            gross: 2200,
-            total: 1200,
+            fees: 200,
+            gross: 2000,
         });
     });
 });

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

@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from "vitest";
 import { SessionsTicketing } from "./session-services-ticketing";
-import { selectionKey, } from "./session-services-ticketing.logic";
+import { getTicketingState, selectionKey, } from "./session-services-ticketing.logic";
 vi.mock("@stencil/core", () => ({
     Component: () => () => undefined,
     Element: () => () => undefined,
@@ -9,7 +9,7 @@ vi.mock("@stencil/core", () => ({
     Prop: () => () => undefined,
     State: () => () => undefined,
     Watch: () => () => undefined,
-    h: () => undefined,
+    h: (tag, props, ...children) => ({ tag, props: props ?? {}, children }),
 }));
 const futureStart = "2030-01-01T20:00:00";
 const futureEnd = "2030-01-01T23:00:00";
@@ -115,6 +115,25 @@ function deferred() {
     });
     return { promise, resolve };
 }
+function isRenderNode(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    return "tag" in value && "props" in value && "children" in value;
+}
+function rendered(value, predicate) {
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => rendered(item, predicate));
+    }
+    if (!isRenderNode(value))
+        return [];
+    const matches = predicate(value) ? [value] : [];
+    return matches.concat(value.children.flatMap((item) => rendered(item, predicate)));
+}
+function hasClass(node, name) {
+    return String(node.props.class ?? "")
+        .split(/\s+/)
+        .includes(name);
+}
 function widget() {
     const item = new SessionsTicketing();
     item.eventId = "evt_1";
@@ -131,6 +150,7 @@ function widget() {
     item.quoteLoading = false;
     item.previewLoading = false;
     item.passcodeDenied = false;
+    item.stickyCheckout = false;
     item.error = null;
     item.activePasscode = "";
     item.cartUpdate = { emit: vi.fn() };
@@ -246,6 +266,30 @@ describe("session-services-ticketing component", () => {
         });
         expect(item.getCheckoutButtonText()).toBe("Continue");
     });
+    it("renders external ticketing in the sticky checkout bar", () => {
+        const item = widget();
+        item.event = event({ url: "https://tickets.example" });
+        item.stickyCheckout = true;
+        const state = getTicketingState(item.event);
+        const links = rendered(item.renderStickyExternalTicketing(state), (node) => node.tag === "a");
+        expect(links).toHaveLength(1);
+        expect(links[0].props.href).toBe("https://tickets.example");
+        expect(hasClass(links[0], "external-ticket-button")).toBe(true);
+        expect(hasClass(links[0], "sticky-checkout-btn")).toBe(true);
+    });
+    it("keeps external ticketing under the sticky checkout host state", () => {
+        const item = widget();
+        item.event = event({ url: "https://tickets.example" });
+        item.stickyCheckout = true;
+        const view = item.renderReadyState();
+        const hosts = rendered(view, (node) => node.tag === "mock-host");
+        const links = rendered(view, (node) => node.tag === "a");
+        expect(getTicketingState(item.event).showExternalTicketing).toBe(true);
+        expect(hosts[0].props["data-sticky-checkout"]).toBe("true");
+        expect(links).toHaveLength(2);
+        expect(links.some((link) => hasClass(link, "inline-external-ticket-button"))).toBe(true);
+        expect(links.some((link) => hasClass(link, "sticky-checkout-btn"))).toBe(true);
+    });
     it("classifies only passcode access failures as passcode errors", async () => {
         const item = widget();
         item.client.event.get = vi