@gomusdev/web-components 1.57.0 → 2.0.0

package/dist-js/gomus-webcomponents.iife.js

@@ -17759,18 +17759,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     const parsed = ids.split(",").map((id) => id.trim()).map(Number).filter((num) => !isNaN(num) && num > 0);
     return parsed.length > 0 ? parsed : void 0;
   }
-  function parseTokens(tokens, possibleTokens) {
-    if (!tokens) {
-      return void 0;
-    }
-    const parsed = tokens.split(",").map((token) => token.trim()).map(String).filter((token) => token.length > 0);
-    parsed.forEach((token) => {
-      if (!possibleTokens.includes(token)) {
-        throw new Error("(parseTokens) Invalid token: " + token);
-      }
-    });
-    return parsed.length > 0 ? parsed : void 0;
-  }
   var root_1$f = /* @__PURE__ */ from_html(`<button> </button>`);
   var root_2$o = /* @__PURE__ */ from_html(`<form id="donationForm" action="" novalidate=""><div class="donation-custom form-group"><label for="donation-custom-amount"> </label> <input class="form-control" id="donation-custom-amount" type="number" min="1"/></div></form>`);
   var root$8 = /* @__PURE__ */ from_html(`<div class="donation-selection"><h3> </h3> <div class="donation-options"></div> <!></div>`);
@@ -19246,7 +19234,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     var attValue = node === null || node === void 0 ? void 0 : (_node$getAttribute2 = node.getAttribute) === null || _node$getAttribute2 === void 0 ? void 0 : _node$getAttribute2.call(node, "contenteditable");
     return attValue === "" || attValue === "true";
   };
-  var getCandidates = function getCandidates2(el, includeContainer, filter) {
+  var getCandidates = function getCandidates2(el, includeContainer, filter2) {
     if (_isInert(el)) {
       return [];
     }
@@ -19254,7 +19242,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     if (includeContainer && matches.call(el, candidateSelector)) {
       candidates.unshift(el);
     }
-    candidates = candidates.filter(filter);
+    candidates = candidates.filter(filter2);
     return candidates;
   };
   var _getCandidatesIteratively = function getCandidatesIteratively(elements, includeContainer, options) {
@@ -33984,24 +33972,507 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       console.error(`Error while evaluating when (${expression}) in go-if: ${error.message}`);
     }
   }
-  const validTicketSelectionFilters = [
-    "timeslot",
-    "day",
-    "annual",
-    "event:scaled-price",
-    "event:ticket",
-    "events:scaled-price"
+  const FILTER_NAMES = [
+    "ticket:timeslot",
+    "ticket:day",
+    "ticket:annual",
+    "event:admission",
+    "event:admission:day",
+    "event:admission:timeslot",
+    "event:price",
+    "events:admission",
+    "events:admission:day",
+    "events:admission:timeslot",
+    "events:price"
   ];
+  const filter$a = {
+    name: "ticket:timeslot",
+    calendarEndpoint: "tickets",
+    apiToken: "time_slot",
+    requires: [
+      { kind: "tsd", field: "selectedDate" },
+      { kind: "tsd", field: "selectedTimeslot" }
+    ],
+    isCalendarVisible: () => true,
+    isTimeslotsVisible: (tsd) => Boolean(tsd.selectedDate),
+    isTicketsVisible: (tsd) => Boolean(tsd.selectedDate && tsd.selectedTimeslot),
+    async loadTimeslots(tsd) {
+      if (!tsd?.selectedDate) return;
+      const { quotas } = await shop.asyncFetch(
+        () => shop.ticketsAndQuotas({
+          by_bookable: true,
+          valid_at: tsd.selectedDate.toString(),
+          // @ts-ignore
+          by_ticket_type: "time_slot",
+          "by_museum_ids[]": tsd.museumIds,
+          "by_exhibition_ids[]": tsd.exhibitionIds,
+          "by_ticket_ids[]": tsd.ticketIds,
+          "by_ticket_group_ids[]": tsd.ticketGroupIds
+        })
+      );
+      shop.capacityManager.addQuotas(quotas);
+    },
+    async loadProducts(segment) {
+      const tsd = segment.ticketSelectionDetails;
+      if (!tsd?.selectedDate || !tsd.selectedTimeslot) return;
+      const { tickets, quotas } = await shop.asyncFetch(
+        () => shop.ticketsAndQuotas({
+          by_bookable: true,
+          valid_at: tsd.selectedDate.toString(),
+          // @ts-ignore
+          by_ticket_type: "time_slot",
+          "by_museum_ids[]": segment.museumIds ?? tsd.museumIds,
+          "by_exhibition_ids[]": tsd.exhibitionIds,
+          "by_ticket_ids[]": tsd.ticketIds,
+          "by_ticket_group_ids[]": segment.ticketGroupIds ?? tsd.ticketGroupIds
+        })
+      );
+      shop.capacityManager.addQuotas(quotas);
+      const available = filterAvailabletickets(tickets, tsd.selectedTime);
+      const uiTickets = initUITimeslotTickets(available, tsd.selectedTime);
+      for (const ticket of uiTickets) segment.preCart.addItem(createCartItem(ticket, { time: tsd.selectedTime }));
+    }
+  };
+  const filter$9 = {
+    name: "ticket:day",
+    calendarEndpoint: "tickets",
+    apiToken: "normal",
+    requires: [{ kind: "tsd", field: "selectedDate" }],
+    isCalendarVisible: () => true,
+    isTimeslotsVisible: () => false,
+    isTicketsVisible: (tsd) => Boolean(tsd.selectedDate),
+    async loadTimeslots() {
+    },
+    async loadProducts(segment) {
+      const tsd = segment.ticketSelectionDetails;
+      if (!tsd?.selectedDate) return;
+      const { tickets, quotas } = await shop.asyncFetch(
+        () => shop.ticketsAndQuotas({
+          by_bookable: true,
+          valid_at: tsd.selectedDate.toString(),
+          // @ts-ignore
+          "by_ticket_types[]": ["normal"],
+          "by_museum_ids[]": segment.museumIds ?? tsd.museumIds,
+          "by_exhibition_ids[]": tsd.exhibitionIds,
+          "by_ticket_ids[]": tsd.ticketIds,
+          "by_ticket_group_ids[]": segment.ticketGroupIds ?? tsd.ticketGroupIds
+        })
+      );
+      shop.capacityManager.addQuotas(quotas);
+      const firstQuota = Object.values(quotas)[0];
+      const timeslot = firstQuota ? Object.keys(firstQuota.capacities)[0] : void 0;
+      const available = filterAvailabletickets(tickets, timeslot);
+      const uiTickets = initUITimeslotTickets(available, timeslot);
+      for (const ticket of uiTickets) segment.preCart.addItem(createCartItem(ticket, { time: timeslot }));
+    }
+  };
+  const filter$8 = {
+    name: "ticket:annual",
+    calendarEndpoint: null,
+    apiToken: "annual",
+    requires: [],
+    isCalendarVisible: () => false,
+    isTimeslotsVisible: () => false,
+    isTicketsVisible: () => true,
+    async loadTimeslots() {
+    },
+    async loadProducts(segment) {
+      const tsd = segment.ticketSelectionDetails;
+      if (!tsd) return;
+      const tickets = await shop.asyncFetch(
+        () => shop.tickets({
+          by_bookable: true,
+          // @ts-ignore
+          "by_ticket_types[]": ["annual"],
+          "by_ticket_ids[]": tsd.ticketIds,
+          "by_ticket_group_ids[]": segment.ticketGroupIds ?? tsd.ticketGroupIds
+        })
+      );
+      for (const t of Object.values(tickets)) {
+        segment.preCart.addItem(createCartItem(createUITicket(t)));
+      }
+    }
+  };
+  const filter$7 = {
+    name: "event:admission",
+    calendarEndpoint: "events",
+    requires: [
+      { kind: "tsd", field: "eventIds" },
+      { kind: "tsd", field: "selectedDate" }
+    ],
+    isCalendarVisible: () => true,
+    isTimeslotsVisible: (tsd) => Boolean(tsd.selectedDate),
+    isTicketsVisible: (tsd) => Boolean(tsd.selectedDate && tsd.selectedTimeslot),
+    async loadTimeslots(tsd) {
+      if (!tsd?.eventIds?.length || !tsd.selectedDate) return;
+      const event2 = await shop.asyncFetch(() => shop.getEvent(tsd.eventIds[0]));
+      if (!event2.tickets?.length) return;
+      const { quotas } = await shop.asyncFetch(
+        () => shop.ticketsAndQuotas({
+          "by_ticket_ids[]": event2.tickets,
+          by_bookable: true,
+          valid_at: tsd.selectedDate.toString()
+        })
+      );
+      shop.capacityManager.addQuotas(quotas);
+    },
+    async loadProducts(segment) {
+      const tsd = segment.ticketSelectionDetails;
+      if (!tsd?.eventIds?.length || !tsd.selectedDate) return;
+      const event2 = await shop.asyncFetch(() => shop.getEvent(tsd.eventIds[0]));
+      if (!event2.tickets?.length) return;
+      const { tickets, quotas } = await shop.asyncFetch(
+        () => shop.ticketsAndQuotas({
+          by_bookable: true,
+          valid_at: tsd.selectedDate.toString(),
+          date_id: segment.dateId
+        })
+      );
+      shop.capacityManager.addQuotas(quotas);
+      const available = filterAvailabletickets(tickets, tsd.selectedTime);
+      const uiTickets = initUITimeslotTickets(available, tsd.selectedTime);
+      for (const ticket of uiTickets) segment.preCart.addItem(createCartItem(ticket, { time: tsd.selectedTime }));
+    }
+  };
+  const filter$6 = {
+    name: "event:admission:day",
+    calendarEndpoint: "events",
+    requires: [
+      { kind: "tsd", field: "eventIds" },
+      { kind: "tsd", field: "selectedDate" }
+    ],
+    isCalendarVisible: () => true,
+    isTimeslotsVisible: () => false,
+    isTicketsVisible: (tsd) => Boolean(tsd.selectedDate),
+    async loadTimeslots() {
+    },
+    async loadProducts(segment) {
+      const tsd = segment.ticketSelectionDetails;
+      if (!tsd?.eventIds?.length || !tsd.selectedDate) return;
+      const event2 = await shop.asyncFetch(() => shop.getEvent(tsd.eventIds[0]));
+      if (!event2.tickets?.length) return;
+      const { tickets, quotas } = await shop.asyncFetch(
+        () => shop.ticketsAndQuotas({
+          "by_ticket_ids[]": event2.tickets,
+          // @ts-ignore — backend has_scope :by_ticket_types accepts ('normal' | 'time_slot' | 'annual')[]
+          "by_ticket_types[]": ["normal"],
+          by_bookable: true,
+          valid_at: tsd.selectedDate.toString()
+        })
+      );
+      shop.capacityManager.addQuotas(quotas);
+      const firstQuota = Object.values(quotas)[0];
+      const time2 = firstQuota ? Object.keys(firstQuota.capacities)[0] : void 0;
+      const available = filterAvailabletickets(tickets, time2);
+      const uiTickets = initUITimeslotTickets(available, time2);
+      for (const t of uiTickets) segment.preCart.addItem(createCartItem(t, { time: time2 }));
+    }
+  };
+  const filter$5 = {
+    name: "event:admission:timeslot",
+    calendarEndpoint: "events",
+    requires: [
+      { kind: "tsd", field: "eventIds" },
+      { kind: "tsd", field: "selectedDate" },
+      { kind: "tsd", field: "selectedTimeslot" }
+    ],
+    isCalendarVisible: () => true,
+    isTimeslotsVisible: (tsd) => Boolean(tsd.selectedDate),
+    isTicketsVisible: (tsd) => Boolean(tsd.selectedDate && tsd.selectedTimeslot),
+    async loadTimeslots(tsd) {
+      if (!tsd?.eventIds?.length || !tsd.selectedDate) return;
+      const event2 = await shop.asyncFetch(() => shop.getEvent(tsd.eventIds[0]));
+      if (!event2.tickets?.length) return;
+      const { quotas } = await shop.asyncFetch(
+        () => shop.ticketsAndQuotas({
+          "by_ticket_ids[]": event2.tickets,
+          // @ts-ignore — backend has_scope :by_ticket_type accepts 'time_slot' | 'normal' | 'annual'
+          by_ticket_type: "time_slot",
+          by_bookable: true,
+          valid_at: tsd.selectedDate.toString()
+        })
+      );
+      shop.capacityManager.addQuotas(quotas);
+    },
+    async loadProducts(segment) {
+      const tsd = segment.ticketSelectionDetails;
+      if (!tsd?.eventIds?.length || !tsd.selectedDate || !tsd.selectedTimeslot) return;
+      const event2 = await shop.asyncFetch(() => shop.getEvent(tsd.eventIds[0]));
+      if (!event2.tickets?.length) return;
+      const { tickets, quotas } = await shop.asyncFetch(
+        () => shop.ticketsAndQuotas({
+          "by_ticket_ids[]": event2.tickets,
+          // @ts-ignore
+          by_ticket_type: "time_slot",
+          by_bookable: true,
+          valid_at: tsd.selectedDate.toString()
+        })
+      );
+      shop.capacityManager.addQuotas(quotas);
+      const available = filterAvailabletickets(tickets, tsd.selectedTime);
+      const uiTickets = initUITimeslotTickets(available, tsd.selectedTime);
+      for (const t of uiTickets) segment.preCart.addItem(createCartItem(t, { time: tsd.selectedTime }));
+    }
+  };
+  const filter$4 = {
+    name: "event:price",
+    calendarEndpoint: "events",
+    requires: [
+      { kind: "tsd", field: "eventIds" },
+      { kind: "segment", field: "dateId" }
+    ],
+    isCalendarVisible: () => false,
+    isTimeslotsVisible: () => false,
+    isTicketsVisible: (tsd) => Boolean(tsd.eventIds?.length),
+    loadTimeslots: async () => {
+    },
+    async loadProducts(segment) {
+      const tsd = segment.ticketSelectionDetails;
+      if (!tsd?.eventIds?.length || segment.dateId === void 0) return;
+      const date2 = await shop.asyncFetch(() => shop.getEventDetailsOnDate(tsd.eventIds[0], segment.dateId));
+      if (!date2.prices?.length) return;
+      for (const price of date2.prices) {
+        const ticket = createUIEventTicket(price, date2.id, { event_title: date2.event_title });
+        segment.preCart.addItem(createCartItem(ticket, { time: date2.start_time }));
+      }
+      if (date2.seats) shop.capacityManager.addSeats(date2.id, date2.seats);
+    }
+  };
+  const TWO_HOURS_MS = 2 * 60 * 60 * 1e3;
+  function filterDatesInWindow(dates, selectedDate, selectedTime) {
+    const selectedMs = Date.parse(selectedTime);
+    return dates.filter((d) => {
+      const datePart = d.start_time.slice(0, 10);
+      const startMs = Date.parse(d.start_time);
+      return datePart === selectedDate && startMs >= selectedMs && startMs <= selectedMs + TWO_HOURS_MS && (d.seats?.available ?? 0) > 0;
+    });
+  }
+  async function loadEventsTimeslots(tsd) {
+    if (!tsd?.selectedDate) return;
+    const { quotas } = await shop.asyncFetch(
+      () => shop.ticketsAndQuotas({
+        by_bookable: true,
+        valid_at: tsd.selectedDate.toString(),
+        // @ts-ignore
+        "by_ticket_types[]": ["time_slot"],
+        "by_museum_ids[]": tsd.museumIds,
+        "by_exhibition_ids[]": tsd.exhibitionIds,
+        "by_ticket_ids[]": tsd.ticketIds,
+        "by_ticket_group_ids[]": tsd.ticketGroupIds
+      })
+    );
+    shop.capacityManager.addQuotas(quotas);
+  }
+  const filter$3 = {
+    name: "events:admission",
+    calendarEndpoint: "events",
+    requires: [
+      { kind: "tsd", field: "selectedDate" },
+      { kind: "tsd", field: "selectedTimeslot" }
+    ],
+    isCalendarVisible: () => true,
+    isTimeslotsVisible: () => true,
+    isTicketsVisible: () => true,
+    loadTimeslots: (tsd) => loadEventsTimeslots(tsd),
+    async loadProducts(segment) {
+      const tsd = segment.ticketSelectionDetails;
+      if (!tsd?.selectedDate || !tsd.selectedTime) return;
+      const all = await shop.asyncFetch(
+        () => shop.getDates({
+          by_bookable: true,
+          // @ts-ignore — bracketed array params are accepted by API
+          "by_museum_ids[]": segment.museumIds ?? tsd.museumIds,
+          "by_exhibition_ids[]": tsd.exhibitionIds,
+          "by_event_ids[]": tsd.eventIds,
+          "by_language_ids[]": segment.languageIds,
+          "by_catch_word_ids[]": segment.catchWordIds,
+          start_at: tsd.selectedDate.toString(),
+          per_page: segment.limit || 30
+        })
+      );
+      const dates = filterDatesInWindow(all, tsd.selectedDate.toString(), tsd.selectedTime);
+      for (const date2 of dates) {
+        if (!date2.event_id || !date2.start_time) continue;
+        const event2 = await shop.asyncFetch(() => shop.getEvent(date2.event_id));
+        if (!event2?.tickets?.length) continue;
+        const { tickets, quotas } = await shop.asyncFetch(
+          () => shop.ticketsAndQuotas({
+            "by_ticket_ids[]": event2.tickets,
+            by_bookable: true,
+            valid_at: date2.start_time.slice(0, 10)
+          })
+        );
+        shop.capacityManager.addQuotas(quotas);
+        const available = filterAvailabletickets(tickets, date2.start_time);
+        const uiTickets = initUITimeslotTickets(available, date2.start_time);
+        for (const ticket of uiTickets) segment.preCart.addItem(createCartItem(ticket, { time: date2.start_time }));
+      }
+    }
+  };
+  const filter$2 = {
+    name: "events:admission:day",
+    calendarEndpoint: "events",
+    requires: [
+      { kind: "tsd", field: "selectedDate" },
+      { kind: "tsd", field: "selectedTimeslot" }
+    ],
+    isCalendarVisible: () => true,
+    isTimeslotsVisible: () => true,
+    isTicketsVisible: () => true,
+    loadTimeslots: (tsd) => loadEventsTimeslots(tsd),
+    async loadProducts(segment) {
+      const tsd = segment.ticketSelectionDetails;
+      if (!tsd?.selectedDate || !tsd.selectedTime) return;
+      const all = await shop.asyncFetch(
+        () => shop.getDates({
+          by_bookable: true,
+          // @ts-ignore — bracketed array params are accepted by API
+          "by_museum_ids[]": segment.museumIds ?? tsd.museumIds,
+          "by_exhibition_ids[]": tsd.exhibitionIds,
+          "by_event_ids[]": tsd.eventIds,
+          "by_language_ids[]": segment.languageIds,
+          "by_catch_word_ids[]": segment.catchWordIds,
+          start_at: tsd.selectedDate.toString(),
+          per_page: segment.limit || 30
+        })
+      );
+      const dates = filterDatesInWindow(all, tsd.selectedDate.toString(), tsd.selectedTime);
+      for (const date2 of dates) {
+        if (!date2.event_id || !date2.start_time) continue;
+        const event2 = await shop.asyncFetch(() => shop.getEvent(date2.event_id));
+        if (!event2?.tickets?.length) continue;
+        const { tickets, quotas } = await shop.asyncFetch(
+          () => shop.ticketsAndQuotas({
+            "by_ticket_ids[]": event2.tickets,
+            // @ts-ignore
+            "by_ticket_types[]": ["normal"],
+            by_bookable: true,
+            valid_at: date2.start_time.slice(0, 10)
+          })
+        );
+        shop.capacityManager.addQuotas(quotas);
+        const firstQuota = Object.values(quotas)[0];
+        const time2 = firstQuota ? Object.keys(firstQuota.capacities)[0] : date2.start_time;
+        const available = filterAvailabletickets(tickets, time2);
+        const uiTickets = initUITimeslotTickets(available, time2);
+        for (const t of uiTickets) segment.preCart.addItem(createCartItem(t, { time: time2 }));
+      }
+    }
+  };
+  const filter$1 = {
+    name: "events:admission:timeslot",
+    calendarEndpoint: "events",
+    requires: [
+      { kind: "tsd", field: "selectedDate" },
+      { kind: "tsd", field: "selectedTimeslot" }
+    ],
+    isCalendarVisible: () => true,
+    isTimeslotsVisible: () => true,
+    isTicketsVisible: () => true,
+    loadTimeslots: (tsd) => loadEventsTimeslots(tsd),
+    async loadProducts(segment) {
+      const tsd = segment.ticketSelectionDetails;
+      if (!tsd?.selectedDate || !tsd.selectedTime) return;
+      const all = await shop.asyncFetch(
+        () => shop.getDates({
+          by_bookable: true,
+          // @ts-ignore — bracketed array params are accepted by API
+          "by_museum_ids[]": segment.museumIds ?? tsd.museumIds,
+          "by_exhibition_ids[]": tsd.exhibitionIds,
+          "by_event_ids[]": tsd.eventIds,
+          "by_language_ids[]": segment.languageIds,
+          "by_catch_word_ids[]": segment.catchWordIds,
+          start_at: tsd.selectedDate.toString(),
+          per_page: segment.limit || 30
+        })
+      );
+      const dates = filterDatesInWindow(all, tsd.selectedDate.toString(), tsd.selectedTime);
+      for (const date2 of dates) {
+        if (!date2.event_id || !date2.start_time) continue;
+        const event2 = await shop.asyncFetch(() => shop.getEvent(date2.event_id));
+        if (!event2?.tickets?.length) continue;
+        const { tickets, quotas } = await shop.asyncFetch(
+          () => shop.ticketsAndQuotas({
+            "by_ticket_ids[]": event2.tickets,
+            // @ts-ignore
+            by_ticket_type: "time_slot",
+            by_bookable: true,
+            valid_at: date2.start_time.slice(0, 10)
+          })
+        );
+        shop.capacityManager.addQuotas(quotas);
+        const available = filterAvailabletickets(tickets, date2.start_time);
+        const uiTickets = initUITimeslotTickets(available, date2.start_time);
+        for (const t of uiTickets) segment.preCart.addItem(createCartItem(t, { time: date2.start_time }));
+      }
+    }
+  };
+  const filter = {
+    name: "events:price",
+    calendarEndpoint: "events",
+    requires: [
+      { kind: "tsd", field: "selectedDate" },
+      { kind: "tsd", field: "selectedTimeslot" }
+    ],
+    isCalendarVisible: () => true,
+    isTimeslotsVisible: () => true,
+    isTicketsVisible: () => true,
+    loadTimeslots: (tsd) => loadEventsTimeslots(tsd),
+    async loadProducts(segment) {
+      const tsd = segment.ticketSelectionDetails;
+      if (!tsd?.selectedDate || !tsd.selectedTime) return;
+      const all = await shop.asyncFetch(
+        () => shop.getDates({
+          by_bookable: true,
+          // @ts-ignore — bracketed array params are accepted by API
+          "by_museum_ids[]": segment.museumIds ?? tsd.museumIds,
+          "by_exhibition_ids[]": tsd.exhibitionIds,
+          "by_event_ids[]": tsd.eventIds,
+          "by_language_ids[]": segment.languageIds,
+          "by_catch_word_ids[]": segment.catchWordIds,
+          start_at: tsd.selectedDate.toString(),
+          per_page: segment.limit || 30
+        })
+      );
+      const dates = filterDatesInWindow(all, tsd.selectedDate.toString(), tsd.selectedTime);
+      const query = segment.query;
+      for (const date2 of dates) {
+        if (!date2.prices?.length) continue;
+        const prices = query ? date2.prices.filter((p2) => p2.title?.includes(query)) : date2.prices;
+        for (const price of prices) {
+          const ticket = createUIEventTicket(price, date2.id, { event_title: date2.event_title });
+          segment.preCart.addItem(createCartItem(ticket, { time: date2.start_time }));
+        }
+        if (date2.seats) shop.capacityManager.addSeats(date2.id, date2.seats);
+      }
+    }
+  };
+  const REGISTRY = {
+    "ticket:timeslot": filter$a,
+    "ticket:day": filter$9,
+    "ticket:annual": filter$8,
+    "event:admission": filter$7,
+    "event:admission:day": filter$6,
+    "event:admission:timeslot": filter$5,
+    "event:price": filter$4,
+    "events:admission": filter$3,
+    "events:admission:day": filter$2,
+    "events:admission:timeslot": filter$1,
+    "events:price": filter
+  };
+  function getFilter(name) {
+    const filter2 = REGISTRY[name];
+    if (!filter2) {
+      console.warn(
+        `[ticket-selection] Unknown filter "${name}". Valid filters: ${FILTER_NAMES.join(", ")}`
+      );
+    }
+    return filter2;
+  }
+  const validFilterNames = FILTER_NAMES;
   let lastUId = 0;
   class TicketSelectionDetails {
     uid = lastUId++;
-    #mode = /* @__PURE__ */ state();
-    get mode() {
-      return get$2(this.#mode);
-    }
-    set mode(value) {
-      set(this.#mode, value, true);
-    }
     #filters = /* @__PURE__ */ state();
     get filters() {
       return get$2(this.#filters);
@@ -34089,48 +34560,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     addTicketSegment(ticketGroup) {
       this.ticketSegments.push(ticketGroup);
     }
+    get isCalendarVisible() {
+      return Boolean(this.filters?.some((f) => getFilter(f).isCalendarVisible(this)));
+    }
     get isTimeslotsVisible() {
-      if (this.filters?.includes("events:scaled-price")) return true;
-      if (this.mode === "event") return false;
-      return Boolean(this.filters?.includes("timeslot") && this.selectedDate);
+      return Boolean(this.filters?.some((f) => getFilter(f).isTimeslotsVisible(this)));
     }
     get isTicketsVisible() {
-      const byFilter = (filter) => {
-        switch (filter) {
-          case "day":
-            return Boolean(this.selectedDate);
-          case "annual":
-            return true;
-          case "event:scaled-price":
-            return Boolean(this.selectedDate);
-          case "events:scaled-price":
-            return true;
-          case "event:ticket":
-            return Boolean(this.selectedDate);
-          case "timeslot":
-            switch (this.mode) {
-              case "event":
-                return Boolean(this.selectedDate);
-              case "ticket":
-                return Boolean(this.selectedDate && this.selectedTimeslot);
-              case "tour":
-                return true;
-              case void 0:
-                return false;
-              default:
-                const exhaustedChecking2 = this.mode;
-                throw new Error(`(isTicketsVisible) Unhandled case: ${exhaustedChecking2}`);
-            }
-          default:
-            const exhaustedChecking = filter;
-            throw new Error(`(isTicketsVisible) Unhandled case: ${exhaustedChecking}`);
-        }
-      };
-      return this.filters?.some(byFilter);
-    }
-    get isCalendarVisible() {
-      if (this.filters?.includes("events:scaled-price")) return true;
-      return Boolean(this.filters?.includes("timeslot") || this.filters?.includes("day"));
+      return Boolean(this.filters?.some((f) => getFilter(f).isTicketsVisible(this)));
     }
   }
   const KEY$2 = "go-ticket-selection";
@@ -34997,11 +35434,29 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   customElements.define("go-profile-overview", create_custom_element(Overview, {}, [], []));
   function TicketSelection($$anchor, $$props) {
     push($$props, true);
-    let mode = prop($$props, "mode", 7), filters = prop($$props, "filters", 7), eventIds = prop($$props, "eventIds", 7), museumIds = prop($$props, "museumIds", 7), exhibitionIds = prop($$props, "exhibitionIds", 7), selectedDate = prop($$props, "selectedDate", 7), selectedTimeslot = prop($$props, "selectedTimeslot", 7), ticketIds = prop($$props, "ticketIds", 7), ticketGroupIds = prop($$props, "ticketGroupIds", 7);
+    function parseFilters(value) {
+      if (!value) return void 0;
+      const out = [];
+      for (const raw of value.split(",")) {
+        const t = raw.trim();
+        if (!t) continue;
+        if (validFilterNames.includes(t)) {
+          out.push(t);
+        } else {
+          console.warn(`[go-ticket-selection] Unknown filter "${t}". Valid filters: ${validFilterNames.join(", ")}`);
+        }
+      }
+      return out.length ? out : void 0;
+    }
+    let filters = prop($$props, "filters", 7), eventIds = prop($$props, "eventIds", 7), museumIds = prop($$props, "museumIds", 7), exhibitionIds = prop($$props, "exhibitionIds", 7), selectedDate = prop($$props, "selectedDate", 7), selectedTimeslot = prop($$props, "selectedTimeslot", 7), ticketIds = prop($$props, "ticketIds", 7), ticketGroupIds = prop($$props, "ticketGroupIds", 7);
     const details = new TicketSelectionDetails();
     user_effect(() => {
-      details.mode = mode();
-      details.filters = parseTokens(filters(), validTicketSelectionFilters);
+      if ($$props.$$host.hasAttribute("mode")) {
+        console.warn('[go-ticket-selection] `mode` attribute is deprecated and ignored. Use `filters` instead, e.g. filters="ticket:timeslot".');
+      }
+    });
+    user_effect(() => {
+      details.filters = parseFilters(filters());
       details.eventIds = parseIds(eventIds());
       details.museumIds = parseIds(museumIds());
       details.exhibitionIds = parseIds(exhibitionIds());
@@ -35020,13 +35475,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     setTicketSelectionDetails($$props.$$host, details);
     var $$exports = {
       details,
-      get mode() {
-        return mode();
-      },
-      set mode($$value) {
-        mode($$value);
-        flushSync();
-      },
       get filters() {
         return filters();
       },
@@ -35089,7 +35537,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   customElements.define("go-ticket-selection", create_custom_element(
     TicketSelection,
     {
-      mode: { attribute: "mode", reflect: true, type: "String" },
       filters: { attribute: "filters", reflect: true, type: "String" },
       eventIds: { attribute: "event-ids", reflect: true, type: "String" },
       ticketIds: { attribute: "ticket-ids", reflect: true, type: "String" },
@@ -35144,232 +35591,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     pop();
   }
   customElements.define("go-tickets-sum", create_custom_element(TicketsSum, {}, [], []));
-  async function loadAnnualTickets(segment) {
-    const tsd = segment.ticketSelectionDetails;
-    if (!tsd || !tsd.filters?.includes("annual")) {
-      segment.clear();
-      return;
-    }
-    const tickets = await shop.asyncFetch(() => shop.tickets({
-      by_bookable: true,
-      // @ts-ignore
-      "by_ticket_types[]": ["annual"],
-      "by_ticket_ids[]": tsd.ticketIds,
-      "by_ticket_group_ids[]": segment.ticketGroupIds ?? tsd.ticketGroupIds
-    }));
-    const uiTickets = Object.values(tickets).map((t) => createUITicket(t));
-    segment.preCart = createCart(uiTickets);
-  }
-  async function loadDayTickets(segment) {
-    const tsd = segment.ticketSelectionDetails;
-    if (!tsd) {
-      console.warn("(loadDayTickets) tsd is undefined");
-      segment.clear();
-      return;
-    }
-    if (!tsd.selectedDate) {
-      console.warn("(loadDayTickets) selected-date is not given to the go-ticket-selection");
-      segment.clear();
-      return;
-    }
-    const { tickets, quotas } = await shop.asyncFetch(() => shop.ticketsAndQuotas({
-      by_bookable: true,
-      valid_at: tsd.selectedDate?.toString(),
-      // @ts-ignore
-      "by_ticket_types[]": ["normal"],
-      "by_museum_ids[]": segment.museumIds ?? tsd.museumIds,
-      "by_exhibition_ids[]": tsd.exhibitionIds,
-      "by_ticket_ids[]": tsd.ticketIds,
-      "by_ticket_group_ids[]": segment.ticketGroupIds ?? tsd.ticketGroupIds
-    }));
-    let timeslot;
-    if (quotas && Object.values(quotas).length > 0 && Object.keys(Object.values(quotas)[0].capacities).length > 0) {
-      timeslot = Object.keys(Object.values(quotas)[0].capacities)[0];
-    }
-    shop.capacityManager.addQuotas(quotas);
-    const available = filterAvailabletickets(tickets, timeslot);
-    const uiTickets = initUITimeslotTickets(available, timeslot);
-    segment.preCart = createCart();
-    for (const ticket of uiTickets) {
-      segment.preCart.addItem(createCartItem(ticket, { time: timeslot }));
-    }
-  }
-  async function load_Event_ScaledPricesTickets(segment) {
-    const tsd = segment.ticketSelectionDetails;
-    if (!tsd) {
-      console.warn("(loadEventScaledPricesTickets) tsd is undefined");
-      segment.clear();
-      return;
-    }
-    if (!tsd.eventIds?.length) {
-      console.warn("(loadEventScaledPricesTickets) eventIds is undefined");
-      segment.clear();
-      return;
-    }
-    if (!segment.filters?.includes("event:scaled-price")) {
-      console.warn("(loadEventScaledPricesTickets) filters should include event:scaled-price");
-      segment.clear();
-      return;
-    }
-    if (segment.dateId === void 0) {
-      console.warn("(loadEventScaledPricesTickets) date-id is not given to the go-ticket-segment");
-      segment.clear();
-      return;
-    }
-    if (tsd.eventIds.length > 1) throw new Error("(loadEventScaledPricesTickets) currently we support only one eventId in go-ticket-selection");
-    const eid = tsd.eventIds[0];
-    const eventDate = await shop.asyncFetch(() => shop.getEventDetailsOnDate(eid, segment.dateId));
-    if (eventDate.prices) {
-      segment.preCart = createCart();
-      for (const price of eventDate.prices) {
-        const ticket = createUIEventTicket(price, segment.dateId, { event_title: eventDate.event_title });
-        segment.preCart.addItem(createCartItem(ticket, { time: eventDate.start_time }));
-      }
-    } else console.warn("(loadEventScaledPricesTickets) event.prices is undefined");
-    if (eventDate.seats) shop.capacityManager.addSeats(segment.dateId, eventDate.seats);
-    else console.warn("(loadEventScaledPricesTickets) event.seats is undefined");
-  }
-  async function loadEventTickets(segment) {
-    const tsd = segment.ticketSelectionDetails;
-    if (!tsd) {
-      console.warn("(loadEventTickets) tsd is undefined");
-      segment.clear();
-      return;
-    }
-    if (!tsd.eventIds?.length) {
-      console.warn("(loadEventTickets) eventIds is undefined");
-      segment.clear();
-      return;
-    }
-    if (!segment.filters?.includes("event:ticket")) {
-      console.warn("(loadEventTickets) filters should include event:tickets");
-      segment.clear();
-      return;
-    }
-    if (!tsd.selectedDate) {
-      console.warn("(loadEventTickets) selected-date is not given to the go-ticket-selection");
-      segment.clear();
-      return;
-    }
-    if (tsd.eventIds.length > 1) throw new Error("(loadEventTickets) currently we support only one eventId in go-ticket-selection");
-    const eid = tsd.eventIds[0];
-    const event2 = await shop.asyncFetch(() => shop.getEvent(eid));
-    const ticketIds = event2.tickets;
-    if (ticketIds.length === 0) {
-      segment.clear();
-      return;
-    }
-    const { tickets, quotas } = await shop.asyncFetch(() => shop.ticketsAndQuotas({
-      "by_ticket_ids[]": ticketIds,
-      by_bookable: true,
-      valid_at: tsd.selectedDate?.toString(),
-      date_id: segment.dateId
-    }));
-    shop.capacityManager.addQuotas(quotas);
-    const available = filterAvailabletickets(tickets, tsd.selectedTime);
-    const uiTickets = initUITimeslotTickets(available, tsd.selectedTime);
-    segment.preCart = createCart();
-    for (const ticket of uiTickets) {
-      segment.preCart.addItem(createCartItem(ticket, { time: tsd.selectedTime }));
-    }
-  }
-  const TWO_HOURS_IN_MILLISECONDS = 2 * 60 * 60 * 1e3;
-  async function load_Events_ScaledPricesTickets(segment) {
-    const tsd = segment.ticketSelectionDetails;
-    if (!tsd) {
-      console.warn("(load_Events_ScaledPricesTickets) tsd is undefined");
-      segment.clear();
-      return;
-    }
-    if (!segment.filters?.includes("events:scaled-price")) {
-      console.warn("(load_Events_ScaledPricesTickets) filters should include events:scaled-price");
-      segment.clear();
-      return;
-    }
-    if (!tsd.selectedDate) {
-      console.warn("(load_Events_ScaledPricesTickets) go-ticket-selection does not have a selected date");
-      segment.clear();
-      return;
-    }
-    if (!tsd.selectedTime) {
-      console.warn("(load_Events_ScaledPricesTickets) go-ticket-selection does not have a selected time");
-      segment.clear();
-      return;
-    }
-    let dates = await shop.asyncFetch(() => shop.getDates({
-      // q?: string
-      by_bookable: true,
-      "by_museum_ids[]": segment.museumIds ?? tsd.museumIds,
-      "by_exhibition_ids[]": tsd.exhibitionIds,
-      "by_event_ids[]": tsd.eventIds,
-      "by_language_ids[]": segment.languageIds,
-      "by_catch_word_ids[]": segment.catchWordIds,
-      // by_category_ids?: number[]
-      start_at: tsd.selectedDate?.toString(),
-      //YYYY-MM-DD format
-      // end_at?: string // YYYY-MM-DD format
-      per_page: segment.limit || 30
-      // page?: number
-    }));
-    segment.preCart = createCart();
-    dates = dates.filter((d) => {
-      const datePart = d.start_time.slice(0, 10);
-      const sameDay = tsd.selectedDate?.toString() == datePart;
-      const selectedMs = Date.parse(tsd.selectedTime);
-      const startMs = Date.parse(d.start_time);
-      const after = startMs >= selectedMs && startMs <= selectedMs + TWO_HOURS_IN_MILLISECONDS;
-      const availableSeats = (d.seats?.available ?? 0) > 0;
-      return sameDay && after && availableSeats;
-    });
-    for (const date2 of dates) {
-      if (date2.prices) {
-        let prices = date2.prices;
-        if (segment.query) prices = prices.filter((p2) => p2.title.includes(segment.query));
-        for (const price of prices) {
-          const ticket = createUIEventTicket(price, date2.id, { event_title: date2.event_title });
-          segment.preCart.addItem(createCartItem(ticket, { time: date2.start_time }));
-        }
-      } else console.warn("(load_Events_ScaledPricesTickets) event.prices is undefined");
-      if (date2.seats) {
-        shop.capacityManager.addSeats(date2.id, date2.seats);
-      } else console.warn("(load_Events_ScaledPricesTickets) event.seats is undefined");
-    }
-  }
-  async function loadTimeslotTickets(segment) {
-    const tsd = segment.ticketSelectionDetails;
-    if (!tsd) {
-      console.warn("(loadTimeslotTickets) tsd is undefined");
-      segment.clear();
-      return;
-    }
-    if (!tsd.selectedDate) {
-      console.warn("(loadTimeslotTickets) selectedDate is not given to the go-ticket-selection");
-      segment.clear();
-      return;
-    }
-    if (!tsd.selectedTimeslot) {
-      console.warn("(loadTimeslotTickets) selectedTimeslot is not given to the go-ticket-selection");
-      segment.clear();
-      return;
-    }
-    const { tickets, quotas } = await shop.asyncFetch(() => shop.ticketsAndQuotas({
-      by_bookable: true,
-      valid_at: tsd.selectedDate?.toString(),
-      // @ts-ignore
-      by_ticket_type: "time_slot",
-      "by_museum_ids[]": segment.museumIds ?? tsd.museumIds,
-      "by_exhibition_ids[]": tsd.exhibitionIds,
-      "by_ticket_ids[]": tsd.ticketIds,
-      "by_ticket_group_ids[]": segment.ticketGroupIds ?? tsd.ticketGroupIds
-    }));
-    shop.capacityManager.addQuotas(quotas);
-    const available = filterAvailabletickets(tickets, tsd.selectedTime);
-    const uiTickets = initUITimeslotTickets(available, tsd.selectedTime);
-    segment.preCart = createCart();
-    for (const ticket of uiTickets) {
-      segment.preCart.addItem(createCartItem(ticket, { time: tsd.selectedTime }));
-    }
-  }
   class SegmentDetails {
     #ticketSelectionDetails;
     get ticketSelectionDetails() {
@@ -35385,7 +35606,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     set preCart(value) {
       set(this.#preCart, value, true);
     }
-    #filters = /* @__PURE__ */ state("timeslot");
+    #filters = /* @__PURE__ */ state();
     get filters() {
       return get$2(this.#filters);
     }
@@ -35441,28 +35662,27 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     set museumIds(value) {
       set(this.#museumIds, value, true);
     }
-    constructor(type, tsdWrapper) {
-      this.filters = type;
+    constructor(filters, tsdWrapper) {
+      this.filters = filters === void 0 ? void 0 : Array.isArray(filters) ? filters : [filters];
       this.#ticketSelectionDetails = /* @__PURE__ */ user_derived(() => tsdWrapper.value);
     }
+    get effectiveFilters() {
+      if (this.filters?.length) return this.filters;
+      return this.ticketSelectionDetails?.filters ?? [];
+    }
     clear() {
       this.preCart = createCart([]);
     }
     toString() {
-      return JSON.stringify({ filters: this.filters, preCart: this.preCart.toString() });
-    }
-    loadTickets() {
-      const method = {
-        timeslot: loadTimeslotTickets,
-        annual: loadAnnualTickets,
-        day: loadDayTickets,
-        custom: () => {
-        },
-        "event:scaled-price": load_Event_ScaledPricesTickets,
-        "events:scaled-price": load_Events_ScaledPricesTickets,
-        "event:ticket": loadEventTickets
-      }[this.filters];
-      method(this);
+      return JSON.stringify({
+        filters: this.effectiveFilters,
+        preCart: this.preCart.toString()
+      });
+    }
+    async loadTickets() {
+      this.preCart = createCart();
+      const filters = this.effectiveFilters.filter((f) => f !== "custom");
+      await Promise.all(filters.map((f) => getFilter(f).loadProducts(this)));
     }
   }
   const KEY = "go-ticket-segment";
@@ -35471,13 +35691,17 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   function TicketSegment($$anchor, $$props) {
     push($$props, true);
     const filters = prop($$props, "filters", 7), dateId = prop($$props, "dateId", 7), query = prop($$props, "query", 7), limit = prop($$props, "limit", 7), ticketGroupIds = prop($$props, "ticketGroupIds", 7), languageIds = prop($$props, "languageIds", 7), catchWordIds = prop($$props, "catchWordIds", 7), museumIds = prop($$props, "museumIds", 7);
-    if (!filters()) throw new Error("filters is required");
+    function parseFilters(value) {
+      if (!value) return void 0;
+      const out = value.split(",").map((s) => s.trim()).filter(Boolean);
+      return out.length ? out : void 0;
+    }
     const tsdWrapper = getTicketSelectionDetails($$props.$$host);
     const tsd = tsdWrapper.value;
-    const details = new SegmentDetails(filters(), tsdWrapper);
+    const details = new SegmentDetails(parseFilters(filters()), tsdWrapper);
     setSegmentDetails($$props.$$host, details);
     user_effect(() => {
-      details.filters = filters();
+      details.filters = parseFilters(filters());
       details.dateId = dateId();
       details.query = query();
       details.limit = limit();
@@ -35489,13 +35713,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     user_effect(() => {
       details.dateId;
       details.filters;
-      details.dateId;
       details.ticketGroupIds;
       details.museumIds;
       details.languageIds;
       details.catchWordIds;
       details.query;
       details.limit;
+      tsd?.filters;
       tsd?.selectedTimeslot;
       tsd?.selectedTime;
       tsd?.selectedDate;
@@ -35807,6 +36031,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     set tsd(value) {
       set(this.#tsd, value);
     }
+    #timeslots = /* @__PURE__ */ state(proxy([]));
+    get timeslots() {
+      return get$2(this.#timeslots);
+    }
+    set timeslots(value) {
+      set(this.#timeslots, value, true);
+    }
     constructor(tsdWrapper) {
       if (!tsdWrapper) return;
       this.#tsd = /* @__PURE__ */ user_derived(() => tsdWrapper.value);
@@ -35815,33 +36046,18 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     get boockedOutCount() {
       return this.timeslots.filter((t) => t.capacity == 0).length;
     }
-    get timeslots() {
-      const tsd = this.tsd;
-      if (!tsd) return [];
-      const date2 = tsd.selectedDate;
-      if (!date2) return [];
-      const result = snapshot(shop.ticketsAndQuotas({
-        by_bookable: true,
-        valid_at: date2.toString(),
-        // @ts-ignore
-        "by_ticket_types[]": ["time_slot"],
-        "by_museum_ids[]": tsd.museumIds,
-        "by_exhibition_ids[]": tsd.exhibitionIds,
-        "by_ticket_ids[]": tsd.ticketIds,
-        "by_ticket_group_ids[]": tsd.ticketGroupIds
+    recalculateCapacities() {
+      const date2 = this.tsd?.selectedDate;
+      if (!date2) {
+        this.timeslots = [];
+        return;
+      }
+      this.timeslots = shop.capacityManager.quotaManager.timeslotsOn(date2).map((x) => ({
+        ...x,
+        startAt: x.timeSlot,
+        timeFormatted: x.timeSlot.substring(11, 16),
+        available: x.capacity > 0
       }));
-      if (!result) return [];
-      let ret = [];
-      untrack(() => {
-        shop.capacityManager.addQuotas(result.quotas);
-        ret = shop.capacityManager.quotaManager.timeslotsOn(tsd.selectedDate).map((x) => ({
-          ...x,
-          startAt: x.timeSlot,
-          timeFormatted: x.timeSlot.substring(11, 16),
-          available: x.capacity > 0
-        }));
-      });
-      return ret;
     }
   };
   var root_2$1 = /* @__PURE__ */ from_html(`<li><label> <input type="radio" name="timeslot"/></label></li>`);
@@ -35851,6 +36067,18 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     const binding_group = [];
     const _tsd = getTicketSelectionDetails($$props.$$host);
     const details = new Details$1(_tsd);
+    user_effect(() => {
+      const tsd = details.tsd;
+      if (!tsd) return;
+      const filters = tsd.filters;
+      const date2 = tsd.selectedDate;
+      untrack(async () => {
+        if (filters?.length && date2) {
+          await Promise.all(filters.map((f) => getFilter(f).loadTimeslots(tsd)));
+        }
+        details.recalculateCapacities();
+      });
+    });
     const dispatchTimeslotSelect = (target, selected) => {
       if (!target || !("dispatchEvent" in target)) return;
       target.dispatchEvent(new CustomEvent("go-timeslot-select", { detail: { selected }, bubbles: true, composed: true }));
@@ -35918,7 +36146,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         append($$anchor2, ul);
       };
       if_block(node, ($$render) => {
-        if (details.tsd && details.tsd.filters?.includes("timeslot")) $$render(consequent);
+        if (details.tsd?.isTimeslotsVisible) $$render(consequent);
       });
     }
     append($$anchor, fragment);
@@ -35948,55 +36176,37 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     set selected(value) {
       set(this.#selected, value, true);
     }
+    get endpoint() {
+      const endpoints = this.details?.filters?.map((f) => getFilter(f).calendarEndpoint).filter(Boolean) ?? [];
+      return endpoints[0] ?? null;
+    }
     get dates() {
-      if (!this.details) {
-        return void 0;
-      }
-      switch (this.details.mode) {
-        case "ticket":
+      if (!this.details) return void 0;
+      switch (this.endpoint) {
+        case "tickets":
           return this.ticketsDates();
-        case "event":
+        case "events":
           return this.eventsDates();
-        case "tour":
-          throw new Error("(Calendar) Tour mode not supported");
-        case void 0:
-          console.error("(Calendar) Mode is undefined");
-          return void 0;
         default:
-          const exhaustedChecking = this.details.mode;
-          throw new Error(`(Calendar) Unhandled case: ${exhaustedChecking}`);
+          return void 0;
       }
     }
     isDateDisabled(date2) {
       if (this.dates) {
         return date2.compare($ad063034c8620db8$export$d0bdf45af03a6ea3($ad063034c8620db8$export$aa8b41735afcabd2())) < 0 || this.dates[date2.toString()] == "unavailable";
-      } else {
-        return date2.compare($ad063034c8620db8$export$d0bdf45af03a6ea3($ad063034c8620db8$export$aa8b41735afcabd2())) < 0;
       }
+      return date2.compare($ad063034c8620db8$export$d0bdf45af03a6ea3($ad063034c8620db8$export$aa8b41735afcabd2())) < 0;
     }
     isDateUnavailable(date2) {
-      if (this.dates) {
-        return this.dates[date2.toString()] == "fully_booked";
-      }
-      return false;
+      return this.dates?.[date2.toString()] == "fully_booked";
     }
-    // @ts-ignore
     get apiFilters() {
-      return this.details?.filters?.map((f) => ({
-        day: "normal",
-        timeslot: "time_slot",
-        annual: "annual",
-        "event:scaled-price": "scaled_price",
-        "events:scaled-price": "not implemented",
-        "event:ticket": "not implemented"
-      })[f]);
+      return this.details?.filters?.map((f) => getFilter(f).apiToken).filter(Boolean);
     }
     params(startAt) {
       if (!this.details) return {};
       const params = {
         by_bookable: true,
-        // This should give a type error, but it doesn't because we are using by_ticket_types[] which the type doesn't know
-        // we filter out undefined values
         //@ts-ignore
         "by_ticket_types[]": this.apiFilters,
         "by_ticket_ids[]": this.details.ticketIds,
@@ -36005,7 +36215,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         "by_exhibition_ids[]": this.details.exhibitionIds,
         "by_event_ids[]": this.details.eventIds,
         depth: "availability_status",
-        // these logic are there to minimize fetches
         start_at: startAt.toString(),
         end_at: startAt.add({ months: 1 }).toString()
       };
@@ -36022,13 +36231,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     eventsDates() {
       const method = shop.calendar.bind(shop);
-      const ret = this.fetchPeriod().reduce((prev, startAt) => assign(prev, method(this.params(startAt))), {});
-      return ret;
+      return this.fetchPeriod().reduce((prev, startAt) => assign(prev, method(this.params(startAt))), {});
     }
     ticketsDates() {
       const method = shop.ticketsCalendar.bind(shop);
-      const ret = this.fetchPeriod().reduce((prev, startAt) => assign(prev, method(this.params(startAt))), {});
-      return ret;
+      return this.fetchPeriod().reduce((prev, startAt) => assign(prev, method(this.params(startAt))), {});
     }
   }
   var root_3 = /* @__PURE__ */ from_html(`<!> <!> <!>`, 1);
@@ -36276,10 +36483,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     const ticketSelectionDetails = /* @__PURE__ */ user_derived(() => _ticketSelectionDetails.value);
     user_effect(() => {
       ticketsCalendar.details = get$2(ticketSelectionDetails);
-      if (get$2(ticketSelectionDetails)) {
-        get$2(ticketSelectionDetails).mode;
-        get$2(ticketSelectionDetails).selectedDate = void 0;
-      }
     });
     $$props.$$host.addEventListener("go-date-select", (e) => {
       if (get$2(ticketSelectionDetails)) {