@tickean/checkout-js 0.1.0

package/README.md

@@ -0,0 +1,5 @@
+# @tickean/checkout-js
+
+Framework-agnostic TypeScript client for Tickean Headless Checkout.
+
+See repository root README and `docs/readme/` for guides.

package/dist/index.d.mts

@@ -0,0 +1,168 @@
+type TickeanErrorPayload = {
+    code: string;
+    message: string;
+    details?: Record<string, unknown>;
+};
+declare class TickeanError extends Error {
+    readonly code: string;
+    readonly details?: Record<string, unknown>;
+    readonly status?: number;
+    constructor(payload: TickeanErrorPayload, status?: number);
+}
+type CreateTickeanOptions = {
+    publishableKey: string;
+    apiBaseUrl?: string;
+    /** When true, uses an in-memory mock adapter (no network). */
+    demo?: boolean;
+    fetchImpl?: typeof fetch;
+};
+type CheckoutSession = {
+    sessionId: string;
+    sessionToken: string;
+    expiresAt: string;
+    event: PublicEvent;
+    capabilities: Record<string, boolean>;
+};
+type PublicShowOption = {
+    id: string;
+    name?: string;
+    description?: string;
+    price: number;
+    currency?: string;
+    stock?: number;
+    maxPerPurchase?: number;
+    optionType?: string;
+    accessScope?: string;
+    coveredShowIds?: string[];
+    passIssuanceMode?: "PER_DAY" | "SINGLE_PASS";
+    catalogVisibility?: "PUBLIC" | "PROMO_GATED";
+    promotionNxM?: unknown;
+    quantityDiscount?: unknown;
+    status?: string;
+};
+type PublicShow = {
+    id: string;
+    title?: string;
+    date?: string;
+    endDate?: string;
+    showOptions: PublicShowOption[];
+};
+type PublicEvent = {
+    id: string;
+    slug: string;
+    title: string;
+    description?: string;
+    images?: unknown[];
+    location?: unknown;
+    availablePaymentMethods?: string[];
+    organization?: {
+        id?: string;
+        slug?: string;
+        name?: string;
+        logo?: string | null;
+    } | null;
+    shows: PublicShow[];
+};
+type CartItem = {
+    showOptionId: string;
+    amount: number;
+};
+type QuoteResult = {
+    valid: boolean;
+    totalPrice: number;
+    pricingBreakdown?: unknown;
+    discountCode?: unknown;
+    unlockedShowOptionIds?: string[];
+    unlockedShowOptions?: PublicShowOption[];
+};
+type Buyer = {
+    id: string;
+    phone: string;
+    name?: string;
+    email?: string;
+};
+type PurchaseResult = {
+    purchase: {
+        id: string;
+        status: string;
+        totalPrice: number;
+        currency: string;
+        shoppingCartReference: string;
+        paymentMethod?: string;
+    };
+    shoppingCartReference: string;
+    cartSessionToken: string;
+};
+type PaymentResult = {
+    id: string;
+    paymentStatus?: string;
+    paymentMethod?: string;
+    paymentInstructions?: unknown;
+    redirectUrl?: string;
+    initPoint?: string;
+    returnUrl?: string | null;
+    stripe?: unknown;
+    fintocWidget?: unknown;
+    dlocalGo?: unknown;
+    airwallex?: unknown;
+};
+type PaymentStatusResult = {
+    status: string;
+    purchase?: PurchaseResult["purchase"] | null;
+};
+interface CheckoutTransport {
+    request<T>(path: string, init: {
+        method?: string;
+        body?: unknown;
+        sessionToken?: string | null;
+    }): Promise<T>;
+}
+
+type TickeanClient = ReturnType<typeof createTickean>;
+declare function createTickean(options: CreateTickeanOptions): {
+    readonly session: CheckoutSession | null;
+    createSession(params: {
+        eventSlug: string;
+        returnUrl?: string;
+    }): Promise<CheckoutSession>;
+    getCatalog(): Promise<PublicEvent>;
+    quote(params: {
+        items: CartItem[];
+        discountCode?: string;
+        showId?: string;
+    }): Promise<QuoteResult>;
+    sendOtp(params: {
+        phone: string;
+        channel?: string;
+    }): Promise<unknown>;
+    verifyOtp(params: {
+        phone: string;
+        code: string;
+        name?: string;
+        email?: string;
+    }): Promise<unknown>;
+    createPurchase(params: {
+        items: CartItem[];
+        paymentMethod: string;
+        currency: string;
+        showId?: string;
+        discountCode?: string;
+        expectedTotal?: number;
+        shoppingCartReference?: string;
+        idempotencyKey?: string;
+    }): Promise<PurchaseResult>;
+    createPayment(params: {
+        orderId: string;
+        paymentMethod: string;
+        currency: string;
+        amount: number;
+    }): Promise<PaymentResult>;
+    getPaymentStatus(): Promise<PaymentStatusResult>;
+    watchPayment(options?: {
+        intervalMs?: number;
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<PaymentStatusResult>;
+};
+
+export { type Buyer, type CartItem, type CheckoutSession, type CheckoutTransport, type CreateTickeanOptions, type PaymentResult, type PaymentStatusResult, type PublicEvent, type PublicShow, type PublicShowOption, type PurchaseResult, type QuoteResult, type TickeanClient, TickeanError, type TickeanErrorPayload, createTickean };

package/dist/index.d.ts

@@ -0,0 +1,168 @@
+type TickeanErrorPayload = {
+    code: string;
+    message: string;
+    details?: Record<string, unknown>;
+};
+declare class TickeanError extends Error {
+    readonly code: string;
+    readonly details?: Record<string, unknown>;
+    readonly status?: number;
+    constructor(payload: TickeanErrorPayload, status?: number);
+}
+type CreateTickeanOptions = {
+    publishableKey: string;
+    apiBaseUrl?: string;
+    /** When true, uses an in-memory mock adapter (no network). */
+    demo?: boolean;
+    fetchImpl?: typeof fetch;
+};
+type CheckoutSession = {
+    sessionId: string;
+    sessionToken: string;
+    expiresAt: string;
+    event: PublicEvent;
+    capabilities: Record<string, boolean>;
+};
+type PublicShowOption = {
+    id: string;
+    name?: string;
+    description?: string;
+    price: number;
+    currency?: string;
+    stock?: number;
+    maxPerPurchase?: number;
+    optionType?: string;
+    accessScope?: string;
+    coveredShowIds?: string[];
+    passIssuanceMode?: "PER_DAY" | "SINGLE_PASS";
+    catalogVisibility?: "PUBLIC" | "PROMO_GATED";
+    promotionNxM?: unknown;
+    quantityDiscount?: unknown;
+    status?: string;
+};
+type PublicShow = {
+    id: string;
+    title?: string;
+    date?: string;
+    endDate?: string;
+    showOptions: PublicShowOption[];
+};
+type PublicEvent = {
+    id: string;
+    slug: string;
+    title: string;
+    description?: string;
+    images?: unknown[];
+    location?: unknown;
+    availablePaymentMethods?: string[];
+    organization?: {
+        id?: string;
+        slug?: string;
+        name?: string;
+        logo?: string | null;
+    } | null;
+    shows: PublicShow[];
+};
+type CartItem = {
+    showOptionId: string;
+    amount: number;
+};
+type QuoteResult = {
+    valid: boolean;
+    totalPrice: number;
+    pricingBreakdown?: unknown;
+    discountCode?: unknown;
+    unlockedShowOptionIds?: string[];
+    unlockedShowOptions?: PublicShowOption[];
+};
+type Buyer = {
+    id: string;
+    phone: string;
+    name?: string;
+    email?: string;
+};
+type PurchaseResult = {
+    purchase: {
+        id: string;
+        status: string;
+        totalPrice: number;
+        currency: string;
+        shoppingCartReference: string;
+        paymentMethod?: string;
+    };
+    shoppingCartReference: string;
+    cartSessionToken: string;
+};
+type PaymentResult = {
+    id: string;
+    paymentStatus?: string;
+    paymentMethod?: string;
+    paymentInstructions?: unknown;
+    redirectUrl?: string;
+    initPoint?: string;
+    returnUrl?: string | null;
+    stripe?: unknown;
+    fintocWidget?: unknown;
+    dlocalGo?: unknown;
+    airwallex?: unknown;
+};
+type PaymentStatusResult = {
+    status: string;
+    purchase?: PurchaseResult["purchase"] | null;
+};
+interface CheckoutTransport {
+    request<T>(path: string, init: {
+        method?: string;
+        body?: unknown;
+        sessionToken?: string | null;
+    }): Promise<T>;
+}
+
+type TickeanClient = ReturnType<typeof createTickean>;
+declare function createTickean(options: CreateTickeanOptions): {
+    readonly session: CheckoutSession | null;
+    createSession(params: {
+        eventSlug: string;
+        returnUrl?: string;
+    }): Promise<CheckoutSession>;
+    getCatalog(): Promise<PublicEvent>;
+    quote(params: {
+        items: CartItem[];
+        discountCode?: string;
+        showId?: string;
+    }): Promise<QuoteResult>;
+    sendOtp(params: {
+        phone: string;
+        channel?: string;
+    }): Promise<unknown>;
+    verifyOtp(params: {
+        phone: string;
+        code: string;
+        name?: string;
+        email?: string;
+    }): Promise<unknown>;
+    createPurchase(params: {
+        items: CartItem[];
+        paymentMethod: string;
+        currency: string;
+        showId?: string;
+        discountCode?: string;
+        expectedTotal?: number;
+        shoppingCartReference?: string;
+        idempotencyKey?: string;
+    }): Promise<PurchaseResult>;
+    createPayment(params: {
+        orderId: string;
+        paymentMethod: string;
+        currency: string;
+        amount: number;
+    }): Promise<PaymentResult>;
+    getPaymentStatus(): Promise<PaymentStatusResult>;
+    watchPayment(options?: {
+        intervalMs?: number;
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<PaymentStatusResult>;
+};
+
+export { type Buyer, type CartItem, type CheckoutSession, type CheckoutTransport, type CreateTickeanOptions, type PaymentResult, type PaymentStatusResult, type PublicEvent, type PublicShow, type PublicShowOption, type PurchaseResult, type QuoteResult, type TickeanClient, TickeanError, type TickeanErrorPayload, createTickean };

package/dist/index.js

@@ -0,0 +1,398 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TickeanError: () => TickeanError,
+  createTickean: () => createTickean
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/demo.ts
+var demoEvent = {
+  id: "evt_demo",
+  slug: "demo-festival",
+  title: "Demo Festival",
+  description: "Sample multi-day festival for local SDK demos.",
+  availablePaymentMethods: ["TRANSFER", "MERCADOPAGO"],
+  organization: {
+    id: "org_demo",
+    slug: "demo-org",
+    name: "Demo Organizer",
+    logo: null
+  },
+  shows: [
+    {
+      id: "show_sat",
+      title: "S\xE1bado",
+      date: new Date(Date.now() + 7 * 864e5).toISOString(),
+      showOptions: [
+        {
+          id: "opt_day",
+          name: "Entrada general",
+          price: 15e3,
+          currency: "ARS",
+          stock: 100,
+          maxPerPurchase: 6,
+          optionType: "TICKET",
+          accessScope: "SINGLE_SHOW",
+          catalogVisibility: "PUBLIC",
+          passIssuanceMode: "PER_DAY"
+        }
+      ]
+    },
+    {
+      id: "show_sun",
+      title: "Domingo",
+      date: new Date(Date.now() + 8 * 864e5).toISOString(),
+      showOptions: [
+        {
+          id: "opt_pass",
+          name: "Abono 2 d\xEDas",
+          price: 25e3,
+          currency: "ARS",
+          stock: 50,
+          maxPerPurchase: 4,
+          optionType: "TICKET",
+          accessScope: "ALL_EVENT_SHOWS",
+          coveredShowIds: ["show_sat", "show_sun"],
+          passIssuanceMode: "SINGLE_PASS",
+          catalogVisibility: "PUBLIC"
+        },
+        {
+          id: "opt_gated",
+          name: "Promo 2x1 (c\xF3digo)",
+          price: 15e3,
+          currency: "ARS",
+          stock: 30,
+          maxPerPurchase: 4,
+          optionType: "TICKET",
+          accessScope: "SINGLE_SHOW",
+          catalogVisibility: "PROMO_GATED",
+          promotionNxM: { enabled: true, buyQty: 2, payQty: 1 }
+        }
+      ]
+    }
+  ]
+};
+function createDemoTransport() {
+  let sessionToken = "demo_session_token";
+  let buyer = null;
+  let unlocked = [];
+  let purchaseId = "purchase_demo";
+  let cartRef = "cart_demo";
+  return {
+    async request(path, init) {
+      if (path === "/v1/checkout/sessions" && init.method === "POST") {
+        sessionToken = `demo_${Date.now()}`;
+        return {
+          sessionId: "sess_demo",
+          sessionToken,
+          expiresAt: new Date(Date.now() + 36e5).toISOString(),
+          event: {
+            ...demoEvent,
+            shows: demoEvent.shows.map((show) => ({
+              ...show,
+              showOptions: show.showOptions.filter(
+                (o) => o.catalogVisibility !== "PROMO_GATED"
+              )
+            }))
+          },
+          capabilities: {
+            tickets: true,
+            discounts: true,
+            transfer: true,
+            onlinePayments: true
+          }
+        };
+      }
+      if (path === "/v1/checkout/catalog") {
+        return {
+          ...demoEvent,
+          shows: demoEvent.shows.map((show) => ({
+            ...show,
+            showOptions: [
+              ...show.showOptions.filter(
+                (o) => o.catalogVisibility !== "PROMO_GATED"
+              ),
+              ...unlocked.filter(
+                (u) => show.showOptions.some((o) => o.id === u.id)
+              )
+            ]
+          }))
+        };
+      }
+      if (path === "/v1/checkout/quote" && init.method === "POST") {
+        const body = init.body;
+        if (body.discountCode?.toUpperCase() === "DEMO2X1") {
+          unlocked = demoEvent.shows.flatMap((s) => s.showOptions).filter((o) => o.catalogVisibility === "PROMO_GATED");
+        }
+        const allOptions = demoEvent.shows.flatMap((s) => s.showOptions);
+        const total = body.items.reduce((sum, item) => {
+          const opt = allOptions.find((o) => o.id === item.showOptionId);
+          return sum + Number(opt?.price || 0) * item.amount;
+        }, 0);
+        return {
+          valid: true,
+          totalPrice: total,
+          pricingBreakdown: { subtotal: total },
+          unlockedShowOptionIds: unlocked.map((o) => o.id),
+          unlockedShowOptions: unlocked
+        };
+      }
+      if (path === "/v1/checkout/otp/send") {
+        return { sent: true };
+      }
+      if (path === "/v1/checkout/otp/verify") {
+        const body = init.body;
+        buyer = {
+          id: "buyer_demo",
+          phone: body.phone,
+          name: body.name || "Demo Buyer",
+          email: body.email
+        };
+        return { verified: true, buyer };
+      }
+      if (path === "/v1/checkout/purchases") {
+        if (!buyer) {
+          throw Object.assign(new Error("OTP required"), {
+            code: "checkout_otp_required"
+          });
+        }
+        const body = init.body;
+        const allOptions = demoEvent.shows.flatMap((s) => s.showOptions);
+        const total = body.items.reduce((sum, item) => {
+          const opt = allOptions.find((o) => o.id === item.showOptionId);
+          return sum + Number(opt?.price || 0) * item.amount;
+        }, 0);
+        purchaseId = `purchase_${Date.now()}`;
+        cartRef = `cart_${Date.now()}`;
+        return {
+          purchase: {
+            id: purchaseId,
+            status: "PENDING",
+            totalPrice: total,
+            currency: body.currency,
+            shoppingCartReference: cartRef,
+            paymentMethod: body.paymentMethod
+          },
+          shoppingCartReference: cartRef,
+          cartSessionToken: "demo_cart_token"
+        };
+      }
+      if (path === "/v1/checkout/payments") {
+        return {
+          id: `pay_${Date.now()}`,
+          paymentStatus: "PENDING",
+          paymentMethod: init.body?.paymentMethod,
+          paymentInstructions: {
+            alias: "tickean.demo",
+            cvu: "0000003100010000000001",
+            amount: init.body?.amount
+          },
+          redirectUrl: void 0,
+          returnUrl: null
+        };
+      }
+      if (path === "/v1/checkout/payments/status") {
+        return {
+          status: "PENDING",
+          purchase: {
+            id: purchaseId,
+            status: "PENDING",
+            totalPrice: 0,
+            currency: "ARS",
+            shoppingCartReference: cartRef
+          }
+        };
+      }
+      throw new Error(`Demo transport: unhandled ${init.method || "GET"} ${path}`);
+    }
+  };
+}
+
+// src/types.ts
+var TickeanError = class extends Error {
+  constructor(payload, status) {
+    super(payload.message);
+    this.name = "TickeanError";
+    this.code = payload.code;
+    this.details = payload.details;
+    this.status = status;
+  }
+};
+
+// src/http.ts
+function createHttpTransport(options) {
+  const fetchImpl = options.fetchImpl || fetch;
+  return {
+    async request(path, init) {
+      const headers = {
+        "Content-Type": "application/json",
+        "X-Tickean-Key": options.publishableKey
+      };
+      if (init.sessionToken) {
+        headers["X-Tickean-Checkout-Session"] = init.sessionToken;
+      }
+      const response = await fetchImpl(
+        `${options.apiBaseUrl.replace(/\/$/, "")}${path}`,
+        {
+          method: init.method || "GET",
+          headers,
+          body: init.body ? JSON.stringify(init.body) : void 0,
+          credentials: "omit"
+        }
+      );
+      const json = await response.json().catch(() => ({}));
+      if (!response.ok) {
+        const err = json?.error || {};
+        throw new TickeanError(
+          {
+            code: err.code || "checkout_request_failed",
+            message: err.message || response.statusText || "Request failed",
+            details: err.details
+          },
+          response.status
+        );
+      }
+      return json;
+    }
+  };
+}
+
+// src/index.ts
+function createTickean(options) {
+  if (!options.publishableKey && !options.demo) {
+    throw new TickeanError({
+      code: "checkout_key_required",
+      message: "publishableKey is required unless demo mode is enabled"
+    });
+  }
+  const transport = options.demo ? createDemoTransport() : createHttpTransport({
+    publishableKey: options.publishableKey,
+    apiBaseUrl: options.apiBaseUrl || "https://api.tickean.com",
+    fetchImpl: options.fetchImpl
+  });
+  let session = null;
+  const requireSession = () => {
+    if (!session?.sessionToken) {
+      throw new TickeanError({
+        code: "checkout_session_required",
+        message: "Call createSession() before using checkout methods"
+      });
+    }
+    return session;
+  };
+  return {
+    get session() {
+      return session;
+    },
+    async createSession(params) {
+      session = await transport.request("/v1/checkout/sessions", {
+        method: "POST",
+        body: params
+      });
+      return session;
+    },
+    async getCatalog() {
+      const active = requireSession();
+      return transport.request("/v1/checkout/catalog", {
+        sessionToken: active.sessionToken
+      });
+    },
+    async quote(params) {
+      const active = requireSession();
+      return transport.request("/v1/checkout/quote", {
+        method: "POST",
+        body: params,
+        sessionToken: active.sessionToken
+      });
+    },
+    async sendOtp(params) {
+      const active = requireSession();
+      return transport.request("/v1/checkout/otp/send", {
+        method: "POST",
+        body: params,
+        sessionToken: active.sessionToken
+      });
+    },
+    async verifyOtp(params) {
+      const active = requireSession();
+      return transport.request("/v1/checkout/otp/verify", {
+        method: "POST",
+        body: params,
+        sessionToken: active.sessionToken
+      });
+    },
+    async createPurchase(params) {
+      const active = requireSession();
+      return transport.request("/v1/checkout/purchases", {
+        method: "POST",
+        body: params,
+        sessionToken: active.sessionToken
+      });
+    },
+    async createPayment(params) {
+      const active = requireSession();
+      return transport.request("/v1/checkout/payments", {
+        method: "POST",
+        body: params,
+        sessionToken: active.sessionToken
+      });
+    },
+    async getPaymentStatus() {
+      const active = requireSession();
+      return transport.request("/v1/checkout/payments/status", {
+        sessionToken: active.sessionToken
+      });
+    },
+    async watchPayment(options2) {
+      const intervalMs = options2?.intervalMs ?? 2500;
+      const timeoutMs = options2?.timeoutMs ?? 5 * 60 * 1e3;
+      const started = Date.now();
+      while (Date.now() - started < timeoutMs) {
+        if (options2?.signal?.aborted) {
+          throw new TickeanError({
+            code: "checkout_aborted",
+            message: "Payment watch aborted"
+          });
+        }
+        const status = await this.getPaymentStatus();
+        if (["COMPLETED", "CONFIRMED", "PAID"].includes(
+          String(status.status || "").toUpperCase()
+        ) || ["COMPLETED", "CONFIRMED", "PAID"].includes(
+          String(status.purchase?.status || "").toUpperCase()
+        )) {
+          return status;
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+      }
+      throw new TickeanError({
+        code: "checkout_payment_timeout",
+        message: "Timed out waiting for payment confirmation"
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TickeanError,
+  createTickean
+});

package/dist/index.mjs

@@ -0,0 +1,370 @@
+// src/demo.ts
+var demoEvent = {
+  id: "evt_demo",
+  slug: "demo-festival",
+  title: "Demo Festival",
+  description: "Sample multi-day festival for local SDK demos.",
+  availablePaymentMethods: ["TRANSFER", "MERCADOPAGO"],
+  organization: {
+    id: "org_demo",
+    slug: "demo-org",
+    name: "Demo Organizer",
+    logo: null
+  },
+  shows: [
+    {
+      id: "show_sat",
+      title: "S\xE1bado",
+      date: new Date(Date.now() + 7 * 864e5).toISOString(),
+      showOptions: [
+        {
+          id: "opt_day",
+          name: "Entrada general",
+          price: 15e3,
+          currency: "ARS",
+          stock: 100,
+          maxPerPurchase: 6,
+          optionType: "TICKET",
+          accessScope: "SINGLE_SHOW",
+          catalogVisibility: "PUBLIC",
+          passIssuanceMode: "PER_DAY"
+        }
+      ]
+    },
+    {
+      id: "show_sun",
+      title: "Domingo",
+      date: new Date(Date.now() + 8 * 864e5).toISOString(),
+      showOptions: [
+        {
+          id: "opt_pass",
+          name: "Abono 2 d\xEDas",
+          price: 25e3,
+          currency: "ARS",
+          stock: 50,
+          maxPerPurchase: 4,
+          optionType: "TICKET",
+          accessScope: "ALL_EVENT_SHOWS",
+          coveredShowIds: ["show_sat", "show_sun"],
+          passIssuanceMode: "SINGLE_PASS",
+          catalogVisibility: "PUBLIC"
+        },
+        {
+          id: "opt_gated",
+          name: "Promo 2x1 (c\xF3digo)",
+          price: 15e3,
+          currency: "ARS",
+          stock: 30,
+          maxPerPurchase: 4,
+          optionType: "TICKET",
+          accessScope: "SINGLE_SHOW",
+          catalogVisibility: "PROMO_GATED",
+          promotionNxM: { enabled: true, buyQty: 2, payQty: 1 }
+        }
+      ]
+    }
+  ]
+};
+function createDemoTransport() {
+  let sessionToken = "demo_session_token";
+  let buyer = null;
+  let unlocked = [];
+  let purchaseId = "purchase_demo";
+  let cartRef = "cart_demo";
+  return {
+    async request(path, init) {
+      if (path === "/v1/checkout/sessions" && init.method === "POST") {
+        sessionToken = `demo_${Date.now()}`;
+        return {
+          sessionId: "sess_demo",
+          sessionToken,
+          expiresAt: new Date(Date.now() + 36e5).toISOString(),
+          event: {
+            ...demoEvent,
+            shows: demoEvent.shows.map((show) => ({
+              ...show,
+              showOptions: show.showOptions.filter(
+                (o) => o.catalogVisibility !== "PROMO_GATED"
+              )
+            }))
+          },
+          capabilities: {
+            tickets: true,
+            discounts: true,
+            transfer: true,
+            onlinePayments: true
+          }
+        };
+      }
+      if (path === "/v1/checkout/catalog") {
+        return {
+          ...demoEvent,
+          shows: demoEvent.shows.map((show) => ({
+            ...show,
+            showOptions: [
+              ...show.showOptions.filter(
+                (o) => o.catalogVisibility !== "PROMO_GATED"
+              ),
+              ...unlocked.filter(
+                (u) => show.showOptions.some((o) => o.id === u.id)
+              )
+            ]
+          }))
+        };
+      }
+      if (path === "/v1/checkout/quote" && init.method === "POST") {
+        const body = init.body;
+        if (body.discountCode?.toUpperCase() === "DEMO2X1") {
+          unlocked = demoEvent.shows.flatMap((s) => s.showOptions).filter((o) => o.catalogVisibility === "PROMO_GATED");
+        }
+        const allOptions = demoEvent.shows.flatMap((s) => s.showOptions);
+        const total = body.items.reduce((sum, item) => {
+          const opt = allOptions.find((o) => o.id === item.showOptionId);
+          return sum + Number(opt?.price || 0) * item.amount;
+        }, 0);
+        return {
+          valid: true,
+          totalPrice: total,
+          pricingBreakdown: { subtotal: total },
+          unlockedShowOptionIds: unlocked.map((o) => o.id),
+          unlockedShowOptions: unlocked
+        };
+      }
+      if (path === "/v1/checkout/otp/send") {
+        return { sent: true };
+      }
+      if (path === "/v1/checkout/otp/verify") {
+        const body = init.body;
+        buyer = {
+          id: "buyer_demo",
+          phone: body.phone,
+          name: body.name || "Demo Buyer",
+          email: body.email
+        };
+        return { verified: true, buyer };
+      }
+      if (path === "/v1/checkout/purchases") {
+        if (!buyer) {
+          throw Object.assign(new Error("OTP required"), {
+            code: "checkout_otp_required"
+          });
+        }
+        const body = init.body;
+        const allOptions = demoEvent.shows.flatMap((s) => s.showOptions);
+        const total = body.items.reduce((sum, item) => {
+          const opt = allOptions.find((o) => o.id === item.showOptionId);
+          return sum + Number(opt?.price || 0) * item.amount;
+        }, 0);
+        purchaseId = `purchase_${Date.now()}`;
+        cartRef = `cart_${Date.now()}`;
+        return {
+          purchase: {
+            id: purchaseId,
+            status: "PENDING",
+            totalPrice: total,
+            currency: body.currency,
+            shoppingCartReference: cartRef,
+            paymentMethod: body.paymentMethod
+          },
+          shoppingCartReference: cartRef,
+          cartSessionToken: "demo_cart_token"
+        };
+      }
+      if (path === "/v1/checkout/payments") {
+        return {
+          id: `pay_${Date.now()}`,
+          paymentStatus: "PENDING",
+          paymentMethod: init.body?.paymentMethod,
+          paymentInstructions: {
+            alias: "tickean.demo",
+            cvu: "0000003100010000000001",
+            amount: init.body?.amount
+          },
+          redirectUrl: void 0,
+          returnUrl: null
+        };
+      }
+      if (path === "/v1/checkout/payments/status") {
+        return {
+          status: "PENDING",
+          purchase: {
+            id: purchaseId,
+            status: "PENDING",
+            totalPrice: 0,
+            currency: "ARS",
+            shoppingCartReference: cartRef
+          }
+        };
+      }
+      throw new Error(`Demo transport: unhandled ${init.method || "GET"} ${path}`);
+    }
+  };
+}
+
+// src/types.ts
+var TickeanError = class extends Error {
+  constructor(payload, status) {
+    super(payload.message);
+    this.name = "TickeanError";
+    this.code = payload.code;
+    this.details = payload.details;
+    this.status = status;
+  }
+};
+
+// src/http.ts
+function createHttpTransport(options) {
+  const fetchImpl = options.fetchImpl || fetch;
+  return {
+    async request(path, init) {
+      const headers = {
+        "Content-Type": "application/json",
+        "X-Tickean-Key": options.publishableKey
+      };
+      if (init.sessionToken) {
+        headers["X-Tickean-Checkout-Session"] = init.sessionToken;
+      }
+      const response = await fetchImpl(
+        `${options.apiBaseUrl.replace(/\/$/, "")}${path}`,
+        {
+          method: init.method || "GET",
+          headers,
+          body: init.body ? JSON.stringify(init.body) : void 0,
+          credentials: "omit"
+        }
+      );
+      const json = await response.json().catch(() => ({}));
+      if (!response.ok) {
+        const err = json?.error || {};
+        throw new TickeanError(
+          {
+            code: err.code || "checkout_request_failed",
+            message: err.message || response.statusText || "Request failed",
+            details: err.details
+          },
+          response.status
+        );
+      }
+      return json;
+    }
+  };
+}
+
+// src/index.ts
+function createTickean(options) {
+  if (!options.publishableKey && !options.demo) {
+    throw new TickeanError({
+      code: "checkout_key_required",
+      message: "publishableKey is required unless demo mode is enabled"
+    });
+  }
+  const transport = options.demo ? createDemoTransport() : createHttpTransport({
+    publishableKey: options.publishableKey,
+    apiBaseUrl: options.apiBaseUrl || "https://api.tickean.com",
+    fetchImpl: options.fetchImpl
+  });
+  let session = null;
+  const requireSession = () => {
+    if (!session?.sessionToken) {
+      throw new TickeanError({
+        code: "checkout_session_required",
+        message: "Call createSession() before using checkout methods"
+      });
+    }
+    return session;
+  };
+  return {
+    get session() {
+      return session;
+    },
+    async createSession(params) {
+      session = await transport.request("/v1/checkout/sessions", {
+        method: "POST",
+        body: params
+      });
+      return session;
+    },
+    async getCatalog() {
+      const active = requireSession();
+      return transport.request("/v1/checkout/catalog", {
+        sessionToken: active.sessionToken
+      });
+    },
+    async quote(params) {
+      const active = requireSession();
+      return transport.request("/v1/checkout/quote", {
+        method: "POST",
+        body: params,
+        sessionToken: active.sessionToken
+      });
+    },
+    async sendOtp(params) {
+      const active = requireSession();
+      return transport.request("/v1/checkout/otp/send", {
+        method: "POST",
+        body: params,
+        sessionToken: active.sessionToken
+      });
+    },
+    async verifyOtp(params) {
+      const active = requireSession();
+      return transport.request("/v1/checkout/otp/verify", {
+        method: "POST",
+        body: params,
+        sessionToken: active.sessionToken
+      });
+    },
+    async createPurchase(params) {
+      const active = requireSession();
+      return transport.request("/v1/checkout/purchases", {
+        method: "POST",
+        body: params,
+        sessionToken: active.sessionToken
+      });
+    },
+    async createPayment(params) {
+      const active = requireSession();
+      return transport.request("/v1/checkout/payments", {
+        method: "POST",
+        body: params,
+        sessionToken: active.sessionToken
+      });
+    },
+    async getPaymentStatus() {
+      const active = requireSession();
+      return transport.request("/v1/checkout/payments/status", {
+        sessionToken: active.sessionToken
+      });
+    },
+    async watchPayment(options2) {
+      const intervalMs = options2?.intervalMs ?? 2500;
+      const timeoutMs = options2?.timeoutMs ?? 5 * 60 * 1e3;
+      const started = Date.now();
+      while (Date.now() - started < timeoutMs) {
+        if (options2?.signal?.aborted) {
+          throw new TickeanError({
+            code: "checkout_aborted",
+            message: "Payment watch aborted"
+          });
+        }
+        const status = await this.getPaymentStatus();
+        if (["COMPLETED", "CONFIRMED", "PAID"].includes(
+          String(status.status || "").toUpperCase()
+        ) || ["COMPLETED", "CONFIRMED", "PAID"].includes(
+          String(status.purchase?.status || "").toUpperCase()
+        )) {
+          return status;
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+      }
+      throw new TickeanError({
+        code: "checkout_payment_timeout",
+        message: "Timed out waiting for payment confirmation"
+      });
+    }
+  };
+}
+export {
+  TickeanError,
+  createTickean
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@tickean/checkout-js",
+  "version": "0.1.0",
+  "description": "Tickean Headless Checkout TypeScript client",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "test": "vitest run",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch"
+  },
+  "devDependencies": {
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.2",
+    "vitest": "^3.0.5"
+  }
+}