@gomusdev/web-components 4.13.1 → 4.14.0

package/dist-js/src/components/ticketSelection/filters/_helpers.d.ts

@@ -2,6 +2,18 @@ import { SegmentDetails } from '../../../../components/ticketSelection/subcompon
 import { TicketSelectionDetails } from '../../../../components/ticketSelection/TicketSelectionDetails.svelte.ts';
 import { UITicket } from '../../../../lib/models/ticket/UITicket.svelte.ts';
 import { DateDetails, Quotas } from '@gomus/types';
+/**
+ * The common tail of every ticket filter's `addToCart`: given the ticket
+ * its loader resolved, build the cart line, reject if the ticket is unavailable
+ * (sold out / unknown → the loader yielded nothing) or the quantity exceeds the
+ * remaining capacity, add the line, and return its uuid. Subtype-agnostic — the
+ * per-filter loader is the only thing that differs.
+ */
+export declare function addResolvedTicketToCart(ticket: UITicket | undefined, { id, quantity, time }: {
+    id: number;
+    quantity: number;
+    time?: string;
+}): string;
 /**
  * When a segment opts into content attributes (with-content), batch-fetch
  * tickets/content for the given tickets and merge each entry's `content` onto

package/dist-js/src/components/ticketSelection/filters/registry.d.ts

@@ -1,4 +1,4 @@
 import { FilterModule, FilterName } from './types.ts';
 export declare function getFilter(name: FilterName): FilterModule;
 export declare function allFilters(): FilterModule[];
-export declare const validFilterNames: readonly ["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", "coupon"];
+export declare const validFilterNames: readonly ["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", "coupon", "tour"];

package/dist-js/src/components/ticketSelection/filters/spec/tour.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist-js/src/components/ticketSelection/filters/tour.d.ts

@@ -0,0 +1,3 @@
+import { FilterModule } from './types.ts';
+declare const filter: FilterModule;
+export default filter;

package/dist-js/src/components/ticketSelection/filters/types.d.ts

@@ -1,6 +1,6 @@
 import { TicketSelectionDetails } from '../../../../components/ticketSelection/TicketSelectionDetails.svelte.ts';
 import { SegmentDetails } from '../../../../components/ticketSelection/subcomponents/tickets/subcomponents/segment/SegmentDetails.svelte.ts';
-export declare const FILTER_NAMES: readonly ["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", "coupon"];
+export declare const FILTER_NAMES: readonly ["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", "coupon", "tour"];
 export type FilterName = (typeof FILTER_NAMES)[number];
 export type Required = {
     kind: 'tsd';
@@ -10,6 +10,13 @@ export type Required = {
     field: keyof SegmentDetails;
 };
 export type CalendarEndpoint = 'tickets' | 'events' | null;
+/**
+ * Args a filter's `addToCart` receives — the public `go.cart.addItem` options
+ * minus `filter`. Deliberately loose: each product kind carries different fields
+ * (a ticket has id/quantity/date|time; a tour has participants/languageId/…), so
+ * the receiving filter reads and validates the fields it needs.
+ */
+export type AddToCartOptions = Record<string, unknown>;
 export interface FilterModule {
     name: FilterName;
     isCalendarVisible(tsd: TicketSelectionDetails): boolean;
@@ -17,6 +24,16 @@ export interface FilterModule {
     isTicketsVisible(tsd: TicketSelectionDetails): boolean;
     loadProducts(segment: SegmentDetails): Promise<void>;
     loadTimeslots(tsd: TicketSelectionDetails): Promise<void>;
+    /**
+     * Add ONE product straight to the cart — the headless entry behind the public
+     * `go.cart.addItem({ filter, … })` API. The filter owns its kind end-to-end:
+     * validate the args it needs, resolve the product (fetch by id / build from
+     * the given attributes), capacity-gate where it applies, add the line, and
+     * return its uuid. Throws on invalid args or an unavailable product. Optional
+     * because not every filter is addable (coupon / the event listings aren't yet);
+     * `go.cart.addItem` rejects a `filter` that doesn't implement it.
+     */
+    addToCart?(options: AddToCartOptions): Promise<string>;
     calendarEndpoint: CalendarEndpoint;
     apiToken?: string;
     requires: ReadonlyArray<Required>;

package/dist-js/src/factories/TourFactories.d.ts

@@ -7,7 +7,7 @@ type TourOrderItem = Extract<OrderItem, {
     type: 'Tour';
 }>;
 export declare const TourFactories: {
-    /** The camelCase options an integrator passes to go.cart.addTour. */
+    /** The camelCase attributes an integrator passes under go.cart.addItem({ filter: 'tour', … }). */
     addTourOptions(overrides?: Partial<AddTourOptionsShape>): AddTourOptionsShape;
     /** A UITour product with a fixed instanceKey for stable uuids/snapshots. */
     tour(overrides?: Partial<TourAttributes>, instanceKey?: string): {

package/dist-js/src/go/cart.d.ts

@@ -1,19 +1,21 @@
-import { TourAttributes } from '../../lib/models/tour/UITour.svelte.ts';
+import { FilterName } from '../../components/ticketSelection/filters/types.ts';
 /**
- * Options for go.cart.addTour (WI #128). camelCase like #129's addTicket;
- * the snake_case wire translation happens inside createUITour.
- */
-export type AddTourOptions = TourAttributes & {
-    /** ISO date-time of the tour start — becomes tour_cart_item.start_time. */
-    time: string;
-};
-/**
- * Adds a group-tour booking to the cart and resolves with the cart line's
- * uuid. Every call appends a NEW line — identical bookings coexist; use the
- * returned uuid to deduplicate or remove.
+ * Options for `go.cart.addItem` — the one generic "add a product to the cart"
+ * call. `filter` names the registry filter that knows how to resolve and add
+ * that product kind; the remaining fields are that filter's own args, which it
+ * validates. Filter names are part of the public API:
+ *
+ *   go.cart.addItem({ filter: 'ticket:day',      id, quantity, date })
+ *   go.cart.addItem({ filter: 'ticket:timeslot', id, quantity, time })
+ *   go.cart.addItem({ filter: 'ticket:annual',   id, quantity })
+ *   go.cart.addItem({ filter: 'tour', id, time, participants, languageId, totalPriceCents, title, … })
  *
- * Tours are not priced by the shop API: `totalPriceCents` is the
- * integrator-supplied booking total (incl. mandatory surcharges) and is
- * verified by the backend only at checkout.
+ * New product kinds are added by giving their filter an `addToCart` — no change
+ * here (WI #129; replaces the per-product addTicket/addTour).
  */
-export declare function addTour(options: AddTourOptions): Promise<string>;
+export type AddItemOptions = {
+    filter: FilterName;
+} & Record<string, unknown>;
+/** Resolves with the new cart line's uuid. Throws if the filter can't add to
+ * the cart, or on the filter's own validation / availability errors. */
+export declare function addItem({ filter, ...options }: AddItemOptions): Promise<string>;

package/dist-js/src/go/go.d.ts

@@ -1,9 +1,9 @@
 import { CustomerAddressesResult, CustomerMembershipsResult, OrdersResult, ValidateTokenResult } from '../../lib/stores/shop.svelte.ts';
 import { OrdersParams } from '@gomus/types';
-import { AddTourOptions } from '../../go/cart.ts';
+import { AddItemOptions } from '../../go/cart.ts';
 export type { CustomerAddressesResult, CustomerMembershipsResult, OrdersResult, ValidateTokenResult, } from '../../lib/stores/shop.svelte.ts';
 export type Command = {
-    method: 'load' | 'config' | 'init' | 'cart.addTour' | (string & {});
+    method: 'load' | 'config' | 'init' | 'cart.addItem' | (string & {});
     options: Record<string, unknown>;
 };
 export declare function initGo(window: {
@@ -24,7 +24,7 @@ export declare const go: {
         getCustomerMemberships: () => Promise<CustomerMembershipsResult>;
     };
     cart: {
-        addTour: (options: AddTourOptions) => Promise<string>;
+        addItem: (options: AddItemOptions) => Promise<string>;
     };
 };
 export type Go = typeof go;

package/dist-js/src/lib/models/tour/UITour.svelte.d.ts

@@ -1,5 +1,5 @@
 /**
- * Group-tour product added programmatically via go.cart.addTour (WI #128).
+ * Group-tour product added programmatically via go.cart.addItem({ filter: 'tour', … }) (WI #128).
  *
  * Tours are not priced by the shop API: POST /api/v4/cart echoes tour lines
  * verbatim, so `totalPriceCents` is the integrator-supplied booking total
@@ -48,7 +48,7 @@ export declare function isUITour(x: {
 } | null | undefined): x is UITour;
 interface Options {
     /**
-     * Uniqueness key for the cart-line uuid. Every addTour call appends a NEW
+     * Uniqueness key for the cart-line uuid. Every tour add appends a NEW
      * cart line (no merge — locked contract), so each UITour needs its own key;
      * it is persisted with the product so rehydrated lines keep their identity.
      * Overridable for deterministic factories/specs.

package/package.json

@@ -4,7 +4,7 @@
     "name": "Giantmonkey GmbH"
   },
   "license": "MIT",
-  "version": "4.13.1",
+  "version": "4.14.0",
   "type": "module",
   "main": "./dist-js/gomus-webcomponents.iife.js",
   "module": "./dist-js/gomus-webcomponents.iife.js",