@ticketlayer/elements 0.4.0 → 1.0.0

package/dist/types/components/tl-order-tickets/tl-order-tickets.d.ts

@@ -1,4 +1,4 @@
-import type { TlTicketData } from '../tl-ticket/tl-ticket';
+import { type OrderTicketsDerived, type OrderTicketsProps, type OrderTicketsState, type OrderTicketsStatus } from '@ticketlayer/elements-core';
 /**
  * tl-order-tickets - renders all the tickets for an order as scannable QR
  * cards with PDF download. Fetches the order through the SDK (order-access
@@ -6,44 +6,42 @@ import type { TlTicketData } from '../tl-ticket/tl-ticket';
  *
  * Usage: <tl-order-tickets order-id="ord_xxx"></tl-order-tickets>
  *
- * On an empty result it waits rather than concluding there is nothing.
- *
- * Tickets are issued asynchronously: the payment confirms, the order is
- * marked paid, and entitlement issuance follows a moment later. A confirmation
- * page therefore renders BEFORE the passes exist - reliably, not occasionally.
- * The component used to answer that with "No tickets for this order yet",
- * which is true and reads as "something went wrong" to someone who has just
- * been charged. Refreshing showed them, so the only thing missing was the
- * waiting.
- *
- * So: an empty order is treated as issuance in flight and polled, with the
- * gaps widening, for about a minute. Then it stops and says the tickets are
- * coming by email, because at that point something probably is wrong and a
- * page that polls forever is worse than one that admits it.
+ * On an empty result it waits rather than concluding there is nothing: tickets
+ * are issued a moment after the order is paid, so a confirmation page renders
+ * before the passes exist. The waiting, the widening schedule behind it and
+ * the point at which it gives up are all in `orderTicketsCore`
+ * (`@ticketlayer/elements-core`, AGENTS.md, TKT-11), along with every string.
+ * This harness renders and forwards, and the one thing it owns is pairing
+ * `mount()` with its teardown - which is what stops the polling when the
+ * element goes off screen.
  */
 export declare class TlOrderTickets {
     /** The order whose tickets to show. */
     orderId: string;
     /** Columns in the grid (default 2). */
     columns: number;
-    tickets: TlTicketData[];
-    loading: boolean;
-    error: string | null;
-    /** The order loaded, but has no tickets yet and we are still waiting. */
-    issuing: boolean;
+    private element;
+    private unsubscribe?;
+    private teardown?;
+    /** The core's whole view. Assigning it is what makes Stencil re-render. */
+    view: import("@ticketlayer/elements-core").ElementView<OrderTicketsProps, OrderTicketsState, OrderTicketsDerived, OrderTicketsStatus, {
+        loading: string;
+        preparing: string;
+        delayed: string;
+        notAvailable: string;
+        loadFailed: string;
+    }>;
+    /** A different order: forget this one and read again, from the top. */
+    watchOrder(): void;
+    syncProps(): void;
+    connectedCallback(): void;
     /**
-     * Gaps between polls, in milliseconds. Front-loaded because issuance
-     * usually lands in the first few seconds, then widening so a genuinely
-     * stuck order is not hammered. Sums to roughly one minute.
+     * Off screen: run the mount's teardown, which is what stops the polling.
+     * Not `destroy()`: Stencil calls this for a DOM move as well as a removal,
+     * and a destroyed core never mounts again.
      */
-    private static readonly POLL_DELAYS_MS;
-    private timer?;
-    private poll;
-    watchOrder(): void;
-    componentWillLoad(): Promise<void>;
     disconnectedCallback(): void;
-    private reset;
-    private stopPolling;
-    private load;
+    /** The core declares no events, so nothing ever reaches here. */
+    private forward;
     render(): any;
 }

package/dist/types/components/tl-promo-code/tl-promo-code.d.ts

@@ -1,9 +1,6 @@
 import { EventEmitter } from '../../stencil-public-runtime';
-import { type PresaleRedemption } from '../../utils/sdk-connector';
-export interface TlPromoApplied extends PresaleRedemption {
-    code: string;
-    cart: unknown | null;
-}
+import { type PromoCodeDerived, type PromoCodeProps, type PromoCodeState, type PromoCodeStatus, type TlPromoApplied as CoreTlPromoApplied } from '@ticketlayer/elements-core';
+export type TlPromoApplied = CoreTlPromoApplied;
 /**
  * tl-promo-code - an input plus Apply button that redeems a presale or promo
  * code for the current cart (POST /sales/presale-codes/redeem through the
@@ -13,6 +10,9 @@ export interface TlPromoApplied extends PresaleRedemption {
  * The API has no un-redeem, so the applied state offers only "use a different
  * code", which clears the input for another redemption.
  *
+ * The web harness for `promoCodeCore`: the redemption, the two error messages
+ * and every string are the core's (AGENTS.md, TKT-11).
+ *
  * Usage: <tl-promo-code></tl-promo-code>
  *
  * @event tlPromoApplied - a code was redeemed ({ code, benefit, alreadyHeld, cart })
@@ -23,17 +23,35 @@ export declare class TlPromoCode {
     placeholder: string;
     /** Apply button label. */
     buttonLabel: string;
-    code: string;
-    applying: boolean;
-    applied: TlPromoApplied | null;
-    error: string | null;
     tlPromoApplied: EventEmitter<TlPromoApplied>;
     tlError: EventEmitter<{
         message: string;
     }>;
+    private element;
+    private unsubscribe?;
+    private teardown?;
+    /** The core's whole view. Assigning it is what makes Stencil re-render. */
+    view: import("@ticketlayer/elements-core").ElementView<PromoCodeProps, PromoCodeState, PromoCodeDerived, PromoCodeStatus, {
+        applying: string;
+        codePrefix: string;
+        appliedSuffix: string;
+        alreadyHeldSuffix: string;
+        useDifferent: string;
+        enterCode: string;
+        notAvailable: string;
+        signIn: string;
+        rejected: string;
+    }>;
+    syncProps(): void;
+    /**
+     * This core has nothing to do on mount, and the harness calls `mount()`
+     * anyway: a harness never asks what a core's lifecycle means (TKT-197).
+     */
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private forward;
     private handleInput;
     private handleSubmit;
-    private apply;
     private reset;
     render(): any;
 }

package/dist/types/components/tl-ticket/tl-ticket.d.ts

@@ -1,14 +1,5 @@
-export interface TlTicketData {
-    id: string;
-    barcode: string;
-    type: string;
-    status: string;
-    holderName: string | null;
-    name: string;
-    admissionStatus: string;
-    eventOccurrenceId: string | null;
-    seatLabel: string | null;
-}
+import type { TlTicketData as CoreTlTicketData } from '@ticketlayer/elements-core';
+export type TlTicketData = CoreTlTicketData;
 /**
  * tl-ticket - a single event ticket: a scannable QR (the redemption token),
  * ticket name / seat / holder, and a PDF download. Greys out + stamps

package/dist/types/components/tl-ticket-selector/tl-ticket-selector.d.ts

@@ -50,6 +50,7 @@ export declare class TlTicketSelector {
     }>;
     private element;
     private unsubscribe?;
+    private teardown?;
     /** The core's whole view. Assigning it is what makes Stencil re-render. */
     view: import("@ticketlayer/elements-core").ElementView<TicketSelectorProps, TicketSelectorState, TicketSelectorDerived, TicketSelectorStatus, {
         selectTickets: string;
@@ -73,14 +74,31 @@ export declare class TlTicketSelector {
      */
     get feeQuote(): TlFeeQuote | null;
     set feeQuote(quote: TlFeeQuote | null);
+    /**
+     * A new event or occurrence is a new subject: the element is torn down and
+     * mounted again, so whatever the core set up for the old one is undone
+     * before anything is set up for the new one.
+     */
     watchPropsChange(): void;
     syncProps(): void;
-    componentWillLoad(): Promise<void>;
-    disconnectedCallback(): void;
     /**
-     * Wait for SDK to be ready, then load ticket types
+     * On screen: render what the core says and put the core to work. What "to
+     * work" means is the core's own business - for this element, waiting for the
+     * client and reading the ticket types.
+     *
+     * `connectedCallback` and not `componentWillLoad` because this runs again
+     * when the element is moved in the DOM, and that is exactly when a mount and
+     * its teardown have to pair up.
      */
-    private waitForSDKAndLoad;
+    connectedCallback(): void;
+    /**
+     * Off screen: run the mount's teardown, and nothing more. `destroy()` is
+     * terminal and Stencil calls this for a move as well as a removal, so
+     * destroying here would leave a re-inserted element frozen. The instance
+     * holds no listener and no subscription once these two have run.
+     */
+    disconnectedCallback(): void;
+    private remount;
     private forward;
     private renderSkeleton;
     private renderError;