@ticketlayer/elements 0.2.0

package/dist/types/utils/order-summary.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Shared helpers for the order-facing components (tl-order-confirmation,
+ * tl-my-orders). The sales order view carries line items, totals and tickets
+ * but no event name, occurrence date or customer email, so these derive what
+ * they can from the order and resolve the rest through the SDK.
+ */
+import type { TicketlayerSDK } from './sdk-connector';
+export interface TlOrderItem {
+    name: string;
+    description?: string | null;
+    type?: string;
+    quantity: number;
+    unitPrice: number | string;
+    subtotal: number | string;
+}
+export interface TlOrderTicketRef {
+    id: string;
+    name: string;
+    eventOccurrenceId: string | null;
+}
+export interface TlOrderData {
+    id: string;
+    orderNumber: string;
+    status: string;
+    paymentStatus?: string;
+    currency: string;
+    items: TlOrderItem[];
+    subtotal: number | string;
+    totalFees?: number | string;
+    totalTax?: number | string;
+    totalDiscounts?: number | string;
+    total: number | string;
+    tickets?: TlOrderTicketRef[];
+    createdAt?: string;
+    eventName?: string | null;
+    customerEmail?: string | null;
+    customer?: {
+        email?: string | null;
+    } | null;
+}
+export interface TlResolvedOccurrence {
+    eventId: string;
+    eventName: string;
+    startsAt: string | null;
+}
+/** Money arrives as minor-unit integers or decimal strings ("50.00"). */
+export declare function formatPrice(value: number | string | null | undefined, currency?: string): string;
+export declare function formatDateTime(iso: string): string;
+export declare function formatDate(iso: string): string;
+/** Line items that are tickets (fees, taxes and discounts have their own type). */
+export declare function ticketItems(order: TlOrderData): TlOrderItem[];
+export declare function ticketCount(order: TlOrderData): number;
+/** Event name as the order view exposes it: the first ticket line's name. */
+export declare function orderEventName(order: TlOrderData): string | null;
+export declare function orderCustomerEmail(order: TlOrderData | null, customer: unknown): string | null;
+export declare function statusLabel(status: string | undefined): string;
+export type StatusTone = 'success' | 'info' | 'warning' | 'error' | 'muted';
+export declare function statusTone(status: string | undefined): StatusTone;
+export declare function errorMessage(err: unknown, fallback: string): string;
+/** True for the "not signed in" family of API errors (401/403, NO_SESSION, NOT_AUTHENTICATED). */
+export declare function isAuthError(err: unknown): boolean;
+/**
+ * Find the event and start time for an occurrence id. The order view only
+ * carries the occurrence id, so this walks the channel's listings (cached by
+ * live-api) until one owns the occurrence. Best effort: null when not found.
+ */
+export declare function resolveOccurrence(sdk: TicketlayerSDK, occurrenceId: string, maxEvents?: number): Promise<TlResolvedOccurrence | null>;

package/dist/types/utils/sdk-connector.d.ts

@@ -0,0 +1,113 @@
+/**
+ * SDK Connector
+ *
+ * Utility to connect external SDK instances to Elements components.
+ */
+export interface ModalOptions {
+    occurrenceId?: string;
+    onComplete?: (order: OrderResult) => void;
+    onError?: (error: Error) => void;
+    onClose?: () => void;
+}
+export interface OrderResult {
+    orderId: string;
+    orderNumber: string;
+}
+interface EventContext {
+    openModal(options?: ModalOptions): void;
+}
+interface CheckoutWithModal {
+    openModal(options?: ModalOptions): void;
+    closeModal(): void;
+}
+interface CartManager {
+    get(): Promise<unknown>;
+    on(event: string, callback: (data: unknown) => void): () => void;
+    off(event: string, callback: (data: unknown) => void): void;
+    addItem(ticketTypeId: string, quantity: number, occurrenceId: string): Promise<unknown>;
+    addItems(items: Array<{
+        ticketTypeId: string;
+        quantity: number;
+        occurrenceId: string;
+    }>): Promise<unknown>;
+    removeItem(itemId: string): Promise<unknown>;
+    addSeat(seatId: string, ticketTypeId: string, occurrenceId: string): Promise<unknown>;
+    removeSeat(seatId: string, occurrenceId: string): Promise<unknown>;
+}
+export interface SDKCustomer {
+    id: string;
+    email: string;
+    firstName?: string | null;
+    lastName?: string | null;
+}
+export interface AuthManager {
+    readonly customer: unknown | null;
+    readonly authenticated: boolean;
+    requestMagicLink(contact: {
+        email?: string;
+        phone?: string;
+    }): Promise<unknown>;
+    exchange(code: string): Promise<unknown>;
+    logout(): Promise<void>;
+}
+export interface PresaleRedemption {
+    benefit: string;
+    alreadyHeld: boolean;
+}
+export interface PresaleManager {
+    redeem(code: string): Promise<PresaleRedemption>;
+}
+export interface TicketlayerSDK {
+    getEventsManager(): {
+        list(options?: {
+            limit?: number;
+            category?: string;
+        }): Promise<{
+            items: unknown[];
+        }>;
+        get(id: string): Promise<unknown>;
+        getTicketTypes(eventId: string, occurrenceId: string): Promise<unknown[]>;
+    };
+    on(event: string, callback: (data: unknown) => void): () => void;
+    off(event: string, callback: (data: unknown) => void): void;
+    /** Get an event context for fluent API (e.g., sdk.event('evt_xxx').openModal()) */
+    event(eventId: string): EventContext;
+    /** Checkout accessor with modal support */
+    checkout: CheckoutWithModal;
+    /** Cart manager accessor */
+    getCartManager(): CartManager;
+    /** Orders accessor (my-orders, single order with tickets, ticket PDF). */
+    getOrdersManager?(): {
+        mine(): Promise<unknown>;
+        get(orderId: string): Promise<unknown>;
+        ticketPdf(orderId: string, passId: string): Promise<Blob>;
+    };
+    /** Magic-link auth accessor (tl-login, tl-my-orders). Optional on older SDKs. */
+    getAuthManager?(): AuthManager;
+    /** Presale / promo code accessor (tl-promo-code). Optional on older SDKs. */
+    getPresaleManager?(): PresaleManager;
+    /** Close any open modal */
+    closeModal(): void;
+}
+/**
+ * Manually install an SDK/connector instance (escape hatch). The normal path is
+ * for the host to call createLiveClient(), which auto-publishes on the registry.
+ */
+export declare function setSDK(sdk: TicketlayerSDK): void;
+/**
+ * Get the SDK instance synchronously. Throws if not yet available - prefer
+ * whenSDK() in lifecycle methods so mounting before Live is ready isn't an error.
+ */
+export declare function getSDK(): TicketlayerSDK;
+/** True if a client is currently registered. */
+export declare function hasSDK(): boolean;
+/**
+ * Resolve when the SDK is available - immediately if Live is already up, else
+ * on the `ticketlayer:ready` event. Replaces busy-wait polling in components.
+ */
+export declare function whenSDK(timeoutMs?: number): Promise<TicketlayerSDK>;
+/**
+ * Subscribe to SDK events (waits for the SDK, returns an unsubscribe function).
+ */
+export declare function onSDKEvent(event: string, callback: (data: unknown) => void): () => void;
+export {};

package/dist/types/utils/testing/mock-sdk.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Mock SDK for spec tests. Installs a connector-shaped object on the manual
+ * slot the sdk-connector reads, with an in-memory bus so tests can push
+ * SDK events (cart:updated, auth:changed, checkout:completed) at components.
+ */
+import { type TicketlayerSDK } from '../sdk-connector';
+export interface MockSDK extends TicketlayerSDK {
+    emit(event: string, payload?: unknown): void;
+    authState: {
+        customer: unknown | null;
+        authenticated: boolean;
+    };
+}
+export interface MockSDKOptions {
+    events?: Partial<ReturnType<TicketlayerSDK['getEventsManager']>>;
+    cart?: Partial<ReturnType<TicketlayerSDK['getCartManager']>>;
+    orders?: Partial<NonNullable<ReturnType<NonNullable<TicketlayerSDK['getOrdersManager']>>>>;
+    auth?: Partial<NonNullable<ReturnType<NonNullable<TicketlayerSDK['getAuthManager']>>>>;
+    presale?: Partial<NonNullable<ReturnType<NonNullable<TicketlayerSDK['getPresaleManager']>>>>;
+    authState?: {
+        customer: unknown | null;
+        authenticated: boolean;
+    };
+    /** Leave the auth accessor off to simulate an older SDK. */
+    withoutAuth?: boolean;
+    /** Leave the presale accessor off to simulate an older SDK. */
+    withoutPresale?: boolean;
+}
+export declare function createMockSDK(opts?: MockSDKOptions): MockSDK;
+/** Install a mock on the connector's manual slot; returns it for assertions. */
+export declare function installMockSDK(opts?: MockSDKOptions): MockSDK;
+export declare function clearMockSDK(): void;
+/** Let pending promise chains settle before re-rendering. */
+export declare function flush(page: {
+    waitForChanges(): Promise<void>;
+}, rounds?: number): Promise<void>;