@getmicdrop/venue-calendar 4.3.1 → 4.3.3

package/dist/api/transformers/event.d.ts

@@ -0,0 +1,177 @@
+import { Event, AvailableTicket } from '../types.js';
+interface ApiEvent {
+    eventID?: number;
+    id?: number;
+    ID?: number;
+    name?: string;
+    title?: string;
+    slug?: string;
+    description?: string;
+    date?: string;
+    startDateTime?: string;
+    start_date_time?: string;
+    endDateTime?: string;
+    end_date_time?: string;
+    doorsOpenTime?: string;
+    doors_open_time?: string;
+    timezone?: string;
+    time_zone?: string;
+    venueId?: number;
+    venue_id?: number;
+    venueName?: string;
+    venue_name?: string;
+    venueAddress?: string;
+    venue_address?: string;
+    location?: string;
+    imageUrl?: string;
+    imageURL?: string;
+    image_url?: string;
+    image?: string;
+    status?: string;
+    isPublished?: boolean;
+    is_published?: boolean;
+    isCancelled?: boolean;
+    is_cancelled?: boolean;
+    availableTickets?: any[];
+    available_tickets?: any[];
+    tickets?: any[];
+    ticketsAvailable?: number;
+    tickets_available?: number;
+    ticketsSold?: number;
+    tickets_sold?: number;
+    minPrice?: number;
+    min_price?: number;
+    maxPrice?: number;
+    max_price?: number;
+    ctaText?: string;
+    cta_text?: string;
+    ctaState?: string;
+    cta_state?: string;
+    showPerformers?: boolean;
+    show_performers?: boolean;
+    eventSeriesId?: number;
+    event_series_id?: number;
+    seriesInstanceNumber?: number;
+    series_instance_number?: number;
+    timeZone?: string;
+    salesStatus?: string;
+    sales_status?: string;
+    eventSummary?: string;
+    password?: string;
+    hasPassword?: boolean;
+    disclaimer?: string;
+    ticketType?: number;
+    eventTicketingType?: number;
+    ageRestriction?: number;
+    displayAgeRestriction?: boolean;
+    displayStartTime?: boolean;
+    displayEndTime?: boolean;
+    displayDoorsTime?: boolean;
+    displayTicketsLeft?: boolean;
+    postSalesMessage?: string;
+    collectionId?: number;
+    collection_id?: number;
+    ticketsRemaining?: number;
+    ticketsTotal?: number;
+    hasHiddenTickets?: boolean;
+    stage?: {
+        name?: string;
+    } | null;
+    stageName?: string;
+    stageId?: number;
+    eventCategoryTypes?: number[] | null;
+    publicPerformers?: Array<{
+        id?: number;
+        displayName?: string;
+        image?: string;
+    }> | null;
+    collectionIds?: number[] | null;
+    venue?: Record<string, any>;
+    performers?: Record<string, any>[];
+    faqs?: Record<string, any>[];
+    showtimes?: Record<string, any>[];
+    purchasedTickets?: Record<string, any>[];
+}
+/**
+ * Get CDN image URL.
+ *
+ * Delegates the host-join to SC's canonical `resolveImageUrl` (one path-join,
+ * one host constant). `{ cdn: true }` picks the Cloudflare-fronted CDN base
+ * (`moxy.sfo3.cdn`), the correct, edge-cached host for public buyer surfaces.
+ *
+ * This replaced VC's local `micdrop-images.sfo3` bucket, which 404s for real
+ * event/venue keys (CDN census 2026-07-05, ledger vc-getcdnimageurl-wrong-
+ * bucket-404). SC additionally passes `data:`/`blob:` URLs through untouched
+ * and normalizes a missing leading slash — a strict superset of the old body.
+ */
+export declare function getCDNImageUrl(path: string | undefined): string;
+/**
+ * Extract image URL from event with fallbacks.
+ *
+ * DIVERGENCE (no-shadowed-helper rename-keep): the HOST-JOIN is now the SC
+ * canonical (via `getCDNImageUrl` above); only the FIELD PRECEDENCE stays local
+ * and deliberately differs -- this transformer reads
+ * `imageUrl -> imageURL -> image_url -> image` (incl. the camelCase `imageURL`,
+ * asserted by event.test.ts), whereas SC reads
+ * `image -> coverImage -> imageUrl -> image_url`. The VC chain is what this
+ * wire boundary trusts; changing it would repoint which field wins for the same
+ * event, so it is preserved. Declared under a non-shadowing name and
+ * re-exported below as `getEventImageUrl` so call sites keep their existing
+ * import -- satisfies `micdrop/no-shadowed-helper` without suppression.
+ */
+declare function getEventImageUrlByFieldPrecedence(apiEvent: ApiEvent): string;
+export { getEventImageUrlByFieldPrecedence as getEventImageUrl };
+/**
+ * Calculate CTA state based on ticket availability
+ */
+/**
+ * VC's 4-state CTA derivation (available/sold_out/coming_soon/ended) for parsed events.
+ * Distinct from SC's `calculateCtaState` (richer wire-level canonical) — renamed to
+ * avoid shadowing the SC export; this variant reads the parsed/raw event shape parseEvent consumes.
+ */
+type CtaState = 'available' | 'sold_out' | 'coming_soon' | 'ended';
+export declare function deriveEventCtaState(apiEvent: ApiEvent): CtaState;
+/**
+ * Parse a raw ticket payload into the normalized AvailableTicket domain shape.
+ *
+ * Wire shape is contained inside this module. Uses `||` chains matching the
+ * old transformer exactly -- 0/false values fall through to the next variant
+ * or default, byte-identical to previous behavior.
+ */
+export declare function parseTicket(raw: unknown): AvailableTicket;
+/**
+ * Parse a raw event payload into the normalized Event domain shape.
+ *
+ * Wire shape (ApiEvent) is contained inside this module and never escapes it.
+ * Uses `||` chains matching the old transformer exactly -- 0/false values fall
+ * through to the next variant, byte-identical to previous behavior. Throw
+ * behavior preserved from old mapper: null/undefined input (property access on a nullish value) or a non-array
+ * tickets field throws exactly as the old code did. Callers always pass real
+ * wire objects.
+ *
+ * COMPOSITION NOTE — passthrough seams (events convergence):
+ * The trailing block of fields below is carried VERBATIM from the wire (no
+ * fallback chains, no normalization) so that the view-shape projections —
+ * `utils/event-transform.js` (DETAIL/BROWSE) and
+ * `public-calendar-flow/transform.ts` (EventData) — can compose parseEvent
+ * for every event-level scalar instead of reading the wire themselves.
+ * `venue`/`performers`/`faqs`/`showtimes`/`purchasedTickets` stay raw objects
+ * by contract: their consumers (and #260's performer canonical) own that
+ * variance; normalizing them here would change rendered output.
+ */
+export declare function parseEvent(raw: unknown): Event;
+/**
+ * Back-compat alias -- existing call sites using transformTicket continue
+ * to work unchanged.
+ */
+export declare const transformTicket: typeof parseTicket;
+/**
+ * Back-compat alias -- existing call sites using transformEvent(apiEvent)
+ * continue to work unchanged.
+ */
+export declare const transformEvent: typeof parseEvent;
+/**
+ * Legacy transformer name for backwards compatibility.
+ */
+export declare const transformEventData: typeof parseEvent;
+export declare function parseEventList(raws: unknown[]): Event[];

package/dist/api/transformers/faq.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Venue FAQ: one text field -> the Q/A rows the accordion renders.
+ *
+ * The venue's `faq` is a single free-text field an operator fills from a
+ * textarea ("Common questions and answers for customers"). FaqAccordion renders
+ * {question, answer} pairs. This is the bridge, and it is shared so the event
+ * page and the series page read that one field the same way.
+ *
+ * The shape is INFERRED rather than demanded: the field is a plain textarea and
+ * no operator is told a format, so the parser has to make sense of whatever is
+ * in there.
+ *
+ * The rules, in the order they are tried:
+ *
+ *   1. Already structured — an array of {question, answer}, from any caller that
+ *      holds pre-split pairs, passes through.
+ *   2. Explicit Q:/A: markers, the convention people reach for unprompted.
+ *   3. A line ending in "?" starts a question; the lines under it are its
+ *      answer. This is what venue FAQs actually look like.
+ *   4. None of the above — no question mark anywhere, no markers — is a single
+ *      block of prose, and it stays one row rather than being chopped at
+ *      arbitrary line breaks.
+ *
+ * A line's OPENING WORDS are deliberately not evidence, even though the ticket
+ * PDF's formatter treats "what"/"how"/"can i" that way: on a PDF a mis-split is
+ * a cosmetic line break, but here it collapses the rest of a sentence into a
+ * closed accordion row and hides it. Ending punctuation and explicit markers are
+ * evidence; sentence openings are a guess.
+ */
+export interface ParsedFAQItem {
+    question: string;
+    answer: string;
+}
+/**
+ * Normalizes whatever the API answered for a venue's FAQ into accordion rows.
+ * Accepts the structured array, the text column, or nothing; always returns an
+ * array (empty when there is nothing to show), so callers can render
+ * unconditionally.
+ */
+export declare function parseVenueFaq(raw: unknown): ParsedFAQItem[];

package/dist/api/transformers/giftCard.d.ts

@@ -0,0 +1,11 @@
+import { ApplyGiftCardResult } from '../gift-cards.js';
+/**
+ * Parse a successful apply-gift-card backend payload into ApplyGiftCardResult,
+ * or a `{ valid: false }` refusal when the payload does not state the amounts.
+ *
+ * Maps the real backend contract to what the Checkout component expects:
+ *   - appliedAmount (cents) -> giftCardAmount (dollars)
+ *   - remainingTotal (dollars) -> stripeAmount (dollars, residual to charge)
+ *   - fullyCoveredByCard -> paymentType 'gift_card_only' | 'split' + requiresStripe
+ */
+export declare function parseGiftCardApplication(raw: unknown): ApplyGiftCardResult;

package/dist/api/transformers/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Transformers Index
+ *
+ * Re-exports all transformer functions for convenient importing.
+ *
+ * Canonical parse<Entity> functions (preferred for new code):
+ *   parseEvent, parseVenue, parseOrder, parsePurchasedTicket, parseTicket,
+ *   parseSeries, parseCollection
+ *
+ * Back-compat aliases (old names, call the same function):
+ *   transformEvent, transformEventData, transformVenue, transformOrder,
+ *   transformTicket, transformSeriesPageData, transformCollectionData
+ */
+export { parseOrder, parsePurchasedTicket, transformOrder, // back-compat alias
+transformTicket, // back-compat alias
+transformOrderForDisplay, } from './order.js';
+export { parseEvent, parseEventList, parseTicket, transformEvent, // back-compat alias
+transformEventData, // legacy alias
+transformTicket as transformAvailableTicket, // back-compat alias
+getCDNImageUrl, getEventImageUrl, deriveEventCtaState, deriveEventCtaState as calculateCtaState, } from './event.js';
+export { parseVenue, transformVenue, // back-compat alias
+extractVenueFees, extractVenueCheckoutSettings, formatVenueAddress, } from './venue.js';
+export { parseSeries, transformSeriesPageData, } from './series.js';
+export { parseCollection, transformCollectionData, } from './collection.js';
+export { parseCart, parseCartReservation } from './cart.js';
+export { parseGiftCardApplication } from './giftCard.js';
+export { parseEventPerformers } from './performer.js';

package/dist/api/transformers/order.d.ts

@@ -0,0 +1,44 @@
+import { Order, PurchasedTicket } from '../types.js';
+/**
+ * Parse a raw purchased-ticket payload into the normalized PurchasedTicket domain shape.
+ *
+ * Wire shape (ApiTicket) is contained inside this module. Uses `||` chains matching
+ * the old transformer exactly -- byte-identical to previous behavior. Throw behavior
+ * preserved from old mapper: null/undefined input (property access on a nullish value) throws as the old code did.
+ */
+export declare function parsePurchasedTicket(raw: unknown): PurchasedTicket;
+/**
+ * Parse a raw order payload into the normalized Order domain shape.
+ *
+ * Wire shape (ApiOrder) is contained inside this module and never escapes it.
+ * Uses `||` chains matching the old transformer exactly (all money fields use `||`,
+ * not `??` -- 0-valued amounts fall through to next variant, same as old) --
+ * byte-identical to previous behavior. Throw behavior preserved from old mapper:
+ * null/undefined input (property access on a nullish value) or a non-array tickets field throws as the old code did.
+ */
+export declare function parseOrder(raw: unknown): Order;
+/**
+ * Back-compat alias -- existing call sites using transformTicket continue
+ * to work unchanged.
+ */
+export declare const transformTicket: typeof parsePurchasedTicket;
+/**
+ * Back-compat alias -- existing call sites using transformOrder(apiOrder)
+ * continue to work unchanged.
+ */
+export declare const transformOrder: typeof parseOrder;
+/**
+ * Transform order for display on success page.
+ *
+ * Returns a simplified object with display-ready values.
+ */
+export declare function transformOrderForDisplay(raw: unknown): {
+    orderId: string;
+    displayOrderId: string;
+    email: string;
+    customerName: string;
+    total: number;
+    formattedTotal: string;
+    ticketCount: number;
+    status: string;
+};

package/dist/api/transformers/performer.d.ts

@@ -0,0 +1,8 @@
+import { EventPerformersResponse } from '../types.js';
+/**
+ * Parse a raw performers payload into the normalized EventPerformersResponse.
+ *
+ * `performers` is coerced to an array (Array.isArray gate), `showPerformers`
+ * to a strict boolean (`=== true`) -- matching fetchEventPerformers exactly.
+ */
+export declare function parseEventPerformers(raw: unknown): EventPerformersResponse;

package/dist/api/transformers/series.d.ts

@@ -0,0 +1,12 @@
+import { SeriesPageData } from '../types.js';
+import { EventData } from '../../public-calendar-flow/types';
+/**
+ * Transform SeriesPageData (from the series API) into our clean EventData interface.
+ * Sets eventSeriesId so EventExperience renders in full-width series mode.
+ */
+export declare function parseSeries(series: SeriesPageData): EventData;
+/**
+ * Back-compat alias — the public-calendar-flow shaper name. Existing call
+ * sites importing transformSeriesPageData continue to work unchanged.
+ */
+export declare const transformSeriesPageData: typeof parseSeries;

package/dist/api/transformers/venue.d.ts

@@ -0,0 +1,65 @@
+import { Venue } from '../types.js';
+/**
+ * Parse a raw venue payload into the normalized Venue domain shape.
+ *
+ * Wire shape (ApiVenue) is contained inside this module and never escapes it.
+ * Uses `||` / `??` chains matching the old transformer exactly -- byte-identical
+ * to previous behavior. Throw behavior preserved from old mapper: null/undefined
+ * input throws exactly as the old code did. Callers always pass real wire objects.
+ */
+declare function vcParseVenue(raw: unknown): Venue;
+/**
+ * Public re-export under the canonical name + back-compat alias. Existing call
+ * sites using either parseVenue(apiVenue) or transformVenue(apiVenue) continue
+ * to work unchanged; re-exports don't redeclare the identifier so the
+ * no-shadowed-helper rule is satisfied without a suppression.
+ */
+export { vcParseVenue as parseVenue };
+export declare const transformVenue: typeof vcParseVenue;
+/**
+ * Extract fee configuration from a raw venue payload.
+ *
+ * Uses `??` (not `||`) so 0-valued fees are preserved correctly.
+ */
+declare function vcExtractVenueFees(raw: unknown): {
+    serviceFeePercentage: number;
+    serviceFeeCents: number;
+    taxPercentage: number;
+};
+/**
+ * Get formatted venue address.
+ *
+ * Compare-first vs SC canonical formatVenueAddress(venue: Pick<ParsedVenue,
+ * 'address'|'city'|'state'|...>): GENUINELY DIVERGED — VC takes its own `Venue`
+ * domain type (the resolved shape `vcParseVenue` emits), not SC's `ParsedVenue`
+ * pick. Kept local under a non-shadowing name and re-exported below; no
+ * eslint-disable.
+ */
+declare function vcFormatVenueAddress(venue: Venue): string;
+/**
+ * The venue's checkout settings, as the checkout form needs them.
+ *
+ * These four keys describe what the checkout asks a buyer for, so the ONLY
+ * consumer is CheckoutForm — every EventData shaper pulls them off whatever
+ * venue block its payload carries and hands them down. Kept here, beside
+ * extractVenueFees, because they are venue config read out of a raw venue
+ * object, and because three shapers (event, series, collection) would otherwise
+ * each grow their own copy of the fallbacks.
+ *
+ * Normalization is the server's (models.PublicCheckoutSettings): `required`
+ * never arrives without `ask`, and the prompt is emitted only when the operator
+ * has both ticked the box and written a question. This re-applies both rules
+ * anyway — the widget is pinned by version and runs against whatever API the
+ * host site's embed reaches, so it must not depend on the payload being current.
+ *
+ * A MISSING key defaults to "ask for a phone, don't require it, ask nothing
+ * else": the least surprising checkout, and the one a payload that predates
+ * these keys should still produce.
+ */
+declare function vcExtractVenueCheckoutSettings(raw: unknown): {
+    askForPhoneAtCheckout: boolean;
+    requiredPhoneAtCheckout: boolean;
+    hasCustomCheckout: boolean;
+    questionPrompt: string | undefined;
+};
+export { vcExtractVenueFees as extractVenueFees, vcExtractVenueCheckoutSettings as extractVenueCheckoutSettings, vcFormatVenueAddress as formatVenueAddress, };