@central-ticket/queue-sdk 0.0.1 → 0.0.2

package/dist/centralq-C3ukDo0x.d.mts

@@ -0,0 +1,134 @@
+interface CentralQOptions {
+    /** URL del queue worker. */
+    apiUrl?: string;
+    /** Publishable API key (ctq_pub_xxx) */
+    apiKey: string;
+    /** ID del evento/recurso a proteger */
+    eventId: string;
+    /** ID de usuario externo. Si no se provee, se autogenera y persiste en sessionStorage */
+    userId?: string;
+    /** Init token corto emitido por backend (recomendado para producción) */
+    queueInitToken?: string;
+    /** Intervalo de polling en ms (default: 10000) */
+    pollInterval?: number;
+    /** Contenedor donde montar el overlay. Default: document.body */
+    container?: HTMLElement;
+}
+interface CentralQClientOptions {
+    /** URL del queue worker */
+    apiUrl?: string;
+    /** Publishable API key (ctq_pub_xxx) */
+    apiKey: string;
+    /** ID de usuario externo por defecto para todas las colas creadas por el client */
+    userId?: string;
+    /** Init token corto por defecto para colas creadas por el client */
+    queueInitToken?: string;
+    /** Intervalo de polling por defecto en ms */
+    pollInterval?: number;
+    /** Contenedor por defecto donde montar el overlay */
+    container?: HTMLElement;
+}
+interface CentralQCreateOptions {
+    /** ID del evento/recurso a proteger */
+    eventId: string;
+    /** Override opcional del userId por cola */
+    userId?: string;
+    /** Override opcional del queue init token por cola */
+    queueInitToken?: string;
+    /** Override opcional del poll interval por cola */
+    pollInterval?: number;
+    /** Override opcional del contenedor por cola */
+    container?: HTMLElement;
+    /** Override opcional del apiUrl por cola */
+    apiUrl?: string;
+    /** Override opcional del apiKey por cola */
+    apiKey?: string;
+}
+interface PassedDetail {
+    token: string;
+    expiresAt: number;
+    userId: string;
+    eventId: string;
+}
+interface PositionDetail {
+    position: number;
+    ahead: number;
+    userId: string;
+    eventId: string;
+}
+interface ExpiredDetail {
+    userId: string;
+    eventId: string;
+}
+interface ErrorDetail {
+    userId: string;
+    eventId: string;
+}
+type EventMap = {
+    passed: PassedDetail;
+    expired: ExpiredDetail;
+    position: PositionDetail;
+    error: ErrorDetail;
+};
+type EventName = keyof EventMap;
+type Listener<T> = (detail: T) => void;
+type QueueStatus = "idle" | "joining" | "waiting" | "passed" | "expired" | "error";
+declare class CentralQ {
+    private client;
+    private element;
+    private userId;
+    private eventId;
+    private pollInterval;
+    private container;
+    private pollingTimer?;
+    private heartbeatTimer?;
+    private expiryTimer?;
+    private destroyed;
+    private listeners;
+    private constructor();
+    /**
+     * Inicializa CentralQ y comienza el flujo de cola automáticamente.
+     * Monta el overlay de UI y empieza a hacer polling.
+     */
+    static init(options: CentralQOptions): CentralQ;
+    /** Suscribirse a un evento del ciclo de vida de la cola */
+    on<K extends EventName>(event: K, listener: Listener<EventMap[K]>): this;
+    /** Desuscribirse de un evento */
+    off<K extends EventName>(event: K, listener: Listener<EventMap[K]>): this;
+    private emit;
+    /**
+     * Libera el slot del usuario inmediatamente.
+     * Llamar cuando el usuario completa la compra.
+     */
+    leave(): void;
+    /**
+     * Destruye la instancia: para todos los timers, desmonta el overlay,
+     * y libera el slot en el servidor.
+     */
+    destroy(): void;
+    /** Retorna el userId resuelto (externo o autogenerado) */
+    getUserId(): string;
+    private resolveUserId;
+    private mount;
+    private unmount;
+    private updateUI;
+    private stopTimers;
+    private startHeartbeat;
+    private scheduleExpiry;
+    private handleExpired;
+    private checkQueue;
+}
+declare class CentralQClient {
+    private defaults;
+    constructor(defaults: CentralQClientOptions);
+    issueQueueInitToken(eventId: string, userId?: string): Promise<{
+        userId: string;
+        queueInitToken: string;
+        expiresAt: number;
+    }>;
+    private issueInitToken;
+    createQueue(options: CentralQCreateOptions): CentralQ;
+}
+declare function createCentralQClient(options: CentralQClientOptions): CentralQClient;
+
+export { CentralQ as C, type ErrorDetail as E, type PassedDetail as P, type QueueStatus as Q, CentralQClient as a, type CentralQClientOptions as b, type CentralQCreateOptions as c, type CentralQOptions as d, type ExpiredDetail as e, type PositionDetail as f, createCentralQClient as g };

package/dist/centralq-C3ukDo0x.d.ts

@@ -0,0 +1,134 @@
+interface CentralQOptions {
+    /** URL del queue worker. */
+    apiUrl?: string;
+    /** Publishable API key (ctq_pub_xxx) */
+    apiKey: string;
+    /** ID del evento/recurso a proteger */
+    eventId: string;
+    /** ID de usuario externo. Si no se provee, se autogenera y persiste en sessionStorage */
+    userId?: string;
+    /** Init token corto emitido por backend (recomendado para producción) */
+    queueInitToken?: string;
+    /** Intervalo de polling en ms (default: 10000) */
+    pollInterval?: number;
+    /** Contenedor donde montar el overlay. Default: document.body */
+    container?: HTMLElement;
+}
+interface CentralQClientOptions {
+    /** URL del queue worker */
+    apiUrl?: string;
+    /** Publishable API key (ctq_pub_xxx) */
+    apiKey: string;
+    /** ID de usuario externo por defecto para todas las colas creadas por el client */
+    userId?: string;
+    /** Init token corto por defecto para colas creadas por el client */
+    queueInitToken?: string;
+    /** Intervalo de polling por defecto en ms */
+    pollInterval?: number;
+    /** Contenedor por defecto donde montar el overlay */
+    container?: HTMLElement;
+}
+interface CentralQCreateOptions {
+    /** ID del evento/recurso a proteger */
+    eventId: string;
+    /** Override opcional del userId por cola */
+    userId?: string;
+    /** Override opcional del queue init token por cola */
+    queueInitToken?: string;
+    /** Override opcional del poll interval por cola */
+    pollInterval?: number;
+    /** Override opcional del contenedor por cola */
+    container?: HTMLElement;
+    /** Override opcional del apiUrl por cola */
+    apiUrl?: string;
+    /** Override opcional del apiKey por cola */
+    apiKey?: string;
+}
+interface PassedDetail {
+    token: string;
+    expiresAt: number;
+    userId: string;
+    eventId: string;
+}
+interface PositionDetail {
+    position: number;
+    ahead: number;
+    userId: string;
+    eventId: string;
+}
+interface ExpiredDetail {
+    userId: string;
+    eventId: string;
+}
+interface ErrorDetail {
+    userId: string;
+    eventId: string;
+}
+type EventMap = {
+    passed: PassedDetail;
+    expired: ExpiredDetail;
+    position: PositionDetail;
+    error: ErrorDetail;
+};
+type EventName = keyof EventMap;
+type Listener<T> = (detail: T) => void;
+type QueueStatus = "idle" | "joining" | "waiting" | "passed" | "expired" | "error";
+declare class CentralQ {
+    private client;
+    private element;
+    private userId;
+    private eventId;
+    private pollInterval;
+    private container;
+    private pollingTimer?;
+    private heartbeatTimer?;
+    private expiryTimer?;
+    private destroyed;
+    private listeners;
+    private constructor();
+    /**
+     * Inicializa CentralQ y comienza el flujo de cola automáticamente.
+     * Monta el overlay de UI y empieza a hacer polling.
+     */
+    static init(options: CentralQOptions): CentralQ;
+    /** Suscribirse a un evento del ciclo de vida de la cola */
+    on<K extends EventName>(event: K, listener: Listener<EventMap[K]>): this;
+    /** Desuscribirse de un evento */
+    off<K extends EventName>(event: K, listener: Listener<EventMap[K]>): this;
+    private emit;
+    /**
+     * Libera el slot del usuario inmediatamente.
+     * Llamar cuando el usuario completa la compra.
+     */
+    leave(): void;
+    /**
+     * Destruye la instancia: para todos los timers, desmonta el overlay,
+     * y libera el slot en el servidor.
+     */
+    destroy(): void;
+    /** Retorna el userId resuelto (externo o autogenerado) */
+    getUserId(): string;
+    private resolveUserId;
+    private mount;
+    private unmount;
+    private updateUI;
+    private stopTimers;
+    private startHeartbeat;
+    private scheduleExpiry;
+    private handleExpired;
+    private checkQueue;
+}
+declare class CentralQClient {
+    private defaults;
+    constructor(defaults: CentralQClientOptions);
+    issueQueueInitToken(eventId: string, userId?: string): Promise<{
+        userId: string;
+        queueInitToken: string;
+        expiresAt: number;
+    }>;
+    private issueInitToken;
+    createQueue(options: CentralQCreateOptions): CentralQ;
+}
+declare function createCentralQClient(options: CentralQClientOptions): CentralQClient;
+
+export { CentralQ as C, type ErrorDetail as E, type PassedDetail as P, type QueueStatus as Q, CentralQClient as a, type CentralQClientOptions as b, type CentralQCreateOptions as c, type CentralQOptions as d, type ExpiredDetail as e, type PositionDetail as f, createCentralQClient as g };

package/dist/{chunk-A4HITWM4.mjs → chunk-4MXU7S6A.mjs}

@@ -1,7 +1,7 @@
 import {
   CENTRALQ_DEFAULT_API_URL,
   QueueHttpClient
-} from "./chunk-42RGFZKP.mjs";
+} from "./chunk-A37B25XO.mjs";
 
 // src/centralq.ts
 var CentralQ = class _CentralQ {

package/dist/{chunk-42RGFZKP.mjs → chunk-A37B25XO.mjs}

@@ -91,6 +91,33 @@ var QueueHttpClient = class {
       expiresAt: body.expiresAt
     };
   }
+  async verifyToken(eventId, token) {
+    const res = await fetch(
+      `${this.apiUrl}/api/queue/verify/${encodeURIComponent(eventId)}`,
+      {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify({ token })
+      }
+    );
+    const body = await res.json().catch(() => ({
+      valid: false,
+      reason: "Respuesta inv\xE1lida"
+    }));
+    if (body.valid === true && body.userId && body.eventId && body.expiresAt) {
+      return body;
+    }
+    if (body.valid === false) {
+      return { valid: false, reason: body.reason ?? "Token inv\xE1lido" };
+    }
+    if (!res.ok) {
+      return {
+        valid: false,
+        reason: body.message ?? `Error ${res.status} al validar token de cola`
+      };
+    }
+    return { valid: false, reason: "Respuesta inv\xE1lida" };
+  }
 };
 
 export {

package/dist/chunk-BVCZFNM3.mjs

@@ -0,0 +1,329 @@
+import {
+  CENTRALQ_DEFAULT_API_URL,
+  QueueHttpClient
+} from "./chunk-P73Q2ZIO.mjs";
+
+// src/admission.ts
+var turnstileScript = null;
+function loadManagedAdmissionDriver() {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return Promise.reject(
+      new Error("La admisi\xF3n administrada requiere un navegador")
+    );
+  }
+  if (window.turnstile) return Promise.resolve(window.turnstile);
+  if (turnstileScript) return turnstileScript;
+  turnstileScript = new Promise((resolve, reject) => {
+    const script = document.createElement("script");
+    script.src = "https://challenges.cloudflare.com/turnstile/v0/api.js?render=explicit";
+    script.async = true;
+    script.defer = true;
+    script.onload = () => {
+      if (window.turnstile) resolve(window.turnstile);
+      else {
+        turnstileScript = null;
+        reject(new Error("No se pudo inicializar la admisi\xF3n administrada"));
+      }
+    };
+    script.onerror = () => {
+      turnstileScript = null;
+      reject(new Error("No se pudo cargar la admisi\xF3n administrada"));
+    };
+    document.head.appendChild(script);
+  });
+  return turnstileScript;
+}
+async function acquireManagedAdmissionProof(publicKey) {
+  const driver = await loadManagedAdmissionDriver();
+  const container = document.createElement("div");
+  container.style.position = "fixed";
+  container.style.inset = "0";
+  container.style.zIndex = "2147483647";
+  container.style.display = "grid";
+  container.style.placeItems = "center";
+  container.style.pointerEvents = "auto";
+  document.body.appendChild(container);
+  return new Promise((resolve, reject) => {
+    let widgetId = "";
+    let timeout;
+    const cleanup = () => {
+      clearTimeout(timeout);
+      if (widgetId) driver.remove(widgetId);
+      container.remove();
+    };
+    timeout = setTimeout(() => {
+      cleanup();
+      reject(new Error("La validaci\xF3n de admisi\xF3n agot\xF3 el tiempo de espera"));
+    }, 15e3);
+    try {
+      widgetId = driver.render(container, {
+        sitekey: publicKey,
+        appearance: "interaction-only",
+        execution: "execute",
+        action: "centralq_admission",
+        callback: (token) => {
+          cleanup();
+          resolve(token);
+        },
+        "error-callback": () => {
+          cleanup();
+          reject(new Error("La validaci\xF3n de admisi\xF3n fall\xF3"));
+        },
+        "expired-callback": () => {
+          cleanup();
+          reject(new Error("La validaci\xF3n de admisi\xF3n expir\xF3"));
+        }
+      });
+      driver.execute(widgetId);
+    } catch {
+      cleanup();
+      reject(new Error("No se pudo ejecutar la admisi\xF3n administrada"));
+    }
+  });
+}
+
+// src/centralq.ts
+var CentralQ = class _CentralQ {
+  constructor(options) {
+    this.element = null;
+    this.destroyed = false;
+    // biome-ignore lint: allow explicit any for generic event map
+    this.listeners = /* @__PURE__ */ new Map();
+    this.client = new QueueHttpClient(
+      options.apiUrl,
+      options.apiKey,
+      options.queueInitToken
+    );
+    this.eventId = options.eventId;
+    this.pollInterval = options.pollInterval ?? 1e4;
+    this.container = options.container ?? document.body;
+    this.userId = this.resolveUserId(options.userId);
+  }
+  /**
+   * Inicializa CentralQ y comienza el flujo de cola automáticamente.
+   * Monta el overlay de UI y empieza a hacer polling.
+   */
+  static init(options) {
+    const instance = new _CentralQ(options);
+    instance.mount();
+    instance.checkQueue();
+    return instance;
+  }
+  // Event API
+  /** Suscribirse a un evento del ciclo de vida de la cola */
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(listener);
+    return this;
+  }
+  /** Desuscribirse de un evento */
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+    return this;
+  }
+  emit(event, detail) {
+    this.listeners.get(event)?.forEach((fn) => fn(detail));
+  }
+  // Métodos públicos
+  /**
+   * Libera el slot del usuario inmediatamente.
+   * Llamar cuando el usuario completa la compra.
+   */
+  leave() {
+    this.stopTimers();
+    this.updateUI("ACTIVE");
+    this.client.leaveQueue(this.eventId, this.userId).catch(() => {
+    });
+  }
+  /**
+   * Destruye la instancia: para todos los timers, desmonta el overlay,
+   * y libera el slot en el servidor.
+   */
+  destroy() {
+    this.destroyed = true;
+    this.stopTimers();
+    this.client.leaveQueue(this.eventId, this.userId).catch(() => {
+    });
+    this.unmount();
+    this.listeners.clear();
+  }
+  /** Retorna el userId resuelto (externo o autogenerado) */
+  getUserId() {
+    return this.userId;
+  }
+  // userId: genera y persiste automáticamente
+  resolveUserId(externalId) {
+    if (externalId) return externalId;
+    const key = `ctq_anon_${this.eventId}`;
+    try {
+      const stored = sessionStorage.getItem(key);
+      if (stored) return stored;
+    } catch {
+    }
+    const generated = `anon_${crypto.randomUUID()}`;
+    try {
+      sessionStorage.setItem(key, generated);
+    } catch {
+    }
+    return generated;
+  }
+  // UI: montar/desmontar el Web Component
+  mount() {
+    import("./queue-element-DXBW64U2.mjs");
+    this.element = document.createElement("central-q");
+    this.element.onRetry = () => {
+      this.updateUI("LOADING");
+      this.checkQueue();
+    };
+    this.container.appendChild(this.element);
+  }
+  unmount() {
+    if (this.element) {
+      this.element.remove();
+      this.element = null;
+    }
+  }
+  updateUI(status, data) {
+    if (!this.element) return;
+    this.element.status = status;
+    if (data?.position !== void 0) this.element.position = data.position;
+    if (data?.ahead !== void 0) this.element.ahead = data.ahead;
+  }
+  // Timers
+  stopTimers() {
+    if (this.pollingTimer) {
+      clearInterval(this.pollingTimer);
+      this.pollingTimer = void 0;
+    }
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = void 0;
+    }
+    if (this.expiryTimer) {
+      clearTimeout(this.expiryTimer);
+      this.expiryTimer = void 0;
+    }
+  }
+  startHeartbeat() {
+    if (this.heartbeatTimer) return;
+    this.heartbeatTimer = setInterval(() => {
+      this.client.sendHeartbeat(this.eventId, this.userId).catch(() => {
+      });
+    }, this.pollInterval);
+  }
+  scheduleExpiry(expiresAt) {
+    if (this.expiryTimer) clearTimeout(this.expiryTimer);
+    const msLeft = expiresAt * 1e3 - Date.now();
+    if (msLeft <= 0) {
+      this.handleExpired();
+      return;
+    }
+    this.expiryTimer = setTimeout(() => this.handleExpired(), msLeft);
+  }
+  handleExpired() {
+    this.stopTimers();
+    this.updateUI("EXPIRED");
+    this.emit("expired", {
+      userId: this.userId,
+      eventId: this.eventId
+    });
+  }
+  // Core: polling + join
+  async checkQueue() {
+    if (this.destroyed) return;
+    try {
+      const res = await this.client.joinQueue(this.eventId, this.userId);
+      if (res.status === "ACTIVE") {
+        if (this.pollingTimer) {
+          clearInterval(this.pollingTimer);
+          this.pollingTimer = void 0;
+        }
+        this.startHeartbeat();
+        this.scheduleExpiry(res.expiresAt);
+        this.updateUI("ACTIVE");
+        this.emit("passed", {
+          token: res.token,
+          expiresAt: res.expiresAt,
+          userId: this.userId,
+          eventId: this.eventId
+        });
+      } else if (res.status === "WAITING") {
+        this.updateUI("WAITING", {
+          position: res.position,
+          ahead: res.ahead
+        });
+        this.emit("position", {
+          position: res.position,
+          ahead: res.ahead,
+          userId: this.userId,
+          eventId: this.eventId
+        });
+        if (!this.pollingTimer) {
+          this.pollingTimer = setInterval(
+            () => this.checkQueue(),
+            this.pollInterval
+          );
+        }
+      }
+    } catch {
+      this.updateUI("ERROR");
+      this.stopTimers();
+      this.emit("error", {
+        userId: this.userId,
+        eventId: this.eventId
+      });
+    }
+  }
+};
+var CentralQClient = class {
+  constructor(defaults) {
+    this.defaults = defaults;
+  }
+  issueQueueInitToken(eventId, userId) {
+    const client = new QueueHttpClient(
+      this.defaults.apiUrl,
+      this.defaults.apiKey
+    );
+    return this.issueInitToken(client, eventId, userId);
+  }
+  async issueInitToken(client, eventId, userId) {
+    if (typeof window === "undefined") {
+      return client.issueQueueInitToken(eventId, userId);
+    }
+    const protection = await client.getProtection(eventId);
+    if (!protection.challengeRequired) {
+      return client.issueQueueInitToken(eventId, userId);
+    }
+    const challenge = await client.getAdmissionChallenge(eventId);
+    if (!challenge.required) {
+      throw new Error("El evento requiere admisi\xF3n administrada");
+    }
+    const proof = await acquireManagedAdmissionProof(challenge.publicKey);
+    return client.issueQueueInitToken(eventId, userId, proof);
+  }
+  createQueue(options) {
+    return CentralQ.init({
+      apiUrl: options.apiUrl ?? this.defaults.apiUrl,
+      apiKey: options.apiKey ?? this.defaults.apiKey,
+      eventId: options.eventId,
+      userId: options.userId ?? this.defaults.userId,
+      queueInitToken: options.queueInitToken ?? this.defaults.queueInitToken,
+      pollInterval: options.pollInterval ?? this.defaults.pollInterval,
+      container: options.container ?? this.defaults.container
+    });
+  }
+};
+function createCentralQClient(options) {
+  return new CentralQClient({
+    ...options,
+    apiUrl: options.apiUrl ?? CENTRALQ_DEFAULT_API_URL
+  });
+}
+
+export {
+  CentralQ,
+  CentralQClient,
+  createCentralQClient
+};

package/dist/{chunk-JR7BCYB5.mjs → chunk-GWPLLJTU.mjs}

@@ -1,6 +1,6 @@
 import {
   CENTRALQ_DEFAULT_API_URL
-} from "./chunk-42RGFZKP.mjs";
+} from "./chunk-A37B25XO.mjs";
 
 // src/server.ts
 function normalizeApiUrl(apiUrl) {
@@ -9,7 +9,7 @@ function normalizeApiUrl(apiUrl) {
 async function validateQueueTokenServer(options) {
   const apiUrl = options.apiUrl ?? CENTRALQ_DEFAULT_API_URL;
   const response = await fetch(
-    `${normalizeApiUrl(apiUrl)}/api/verify/${encodeURIComponent(options.eventId)}`,
+    `${normalizeApiUrl(apiUrl)}/api/queue/verify/${encodeURIComponent(options.eventId)}`,
     {
       method: "POST",
       headers: {

package/dist/chunk-JJ33EJ65.mjs

@@ -0,0 +1,31 @@
+import {
+  CENTRALQ_DEFAULT_API_URL
+} from "./chunk-P73Q2ZIO.mjs";
+
+// src/server.ts
+function normalizeApiUrl(apiUrl) {
+  return apiUrl.replace(/\/+$/, "");
+}
+async function validateQueueTokenServer(options) {
+  const apiUrl = options.apiUrl ?? CENTRALQ_DEFAULT_API_URL;
+  const response = await fetch(
+    `${normalizeApiUrl(apiUrl)}/api/queue/verify/${encodeURIComponent(options.eventId)}`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": options.secretKey
+      },
+      body: JSON.stringify({ token: options.token })
+    }
+  );
+  const data = await response.json().catch(() => ({
+    valid: false,
+    reason: "Respuesta inv\xE1lida"
+  }));
+  return { status: response.status, data };
+}
+
+export {
+  validateQueueTokenServer
+};