@central-ticket/queue-sdk 0.0.1 → 0.0.2

package/dist/chunk-P73Q2ZIO.mjs

@@ -0,0 +1,167 @@
+// src/queue-client.ts
+var CENTRALQ_DEFAULT_API_URL = "http://localhost:3001";
+function normalizeApiUrl(apiUrl) {
+  const trimmed = apiUrl.replace(/\/+$/, "");
+  return trimmed.endsWith("/api") ? trimmed.slice(0, -4) : trimmed;
+}
+var QueueHttpClient = class {
+  constructor(apiUrl = CENTRALQ_DEFAULT_API_URL, apiKey, queueInitToken) {
+    this.apiUrl = apiUrl;
+    this.apiKey = apiKey;
+    this.queueInitToken = queueInitToken;
+    this.apiUrl = normalizeApiUrl(this.apiUrl);
+  }
+  get headers() {
+    const h = { "Content-Type": "application/json" };
+    if (this.apiKey) h["x-api-key"] = this.apiKey;
+    if (this.queueInitToken) h["x-queue-init-token"] = this.queueInitToken;
+    return h;
+  }
+  /**
+   * Intenta unir a un usuario a la cola de un evento.
+   * Llama a POST /api/queue/:eventId/join en el worker.
+   */
+  async joinQueue(eventId, userId) {
+    const res = await fetch(
+      `${this.apiUrl}/api/queue/${encodeURIComponent(eventId)}/join`,
+      {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify({ userId })
+      }
+    );
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      throw new Error(
+        body.message ?? `Error ${res.status} al conectar con el sistema de colas`
+      );
+    }
+    return res.json();
+  }
+  /**
+   * Envía un heartbeat para mantener vivo el slot (waiting o active).
+   * El SDK lo llama cada 10s automáticamente.
+   */
+  async sendHeartbeat(eventId, userId) {
+    await fetch(
+      `${this.apiUrl}/api/queue/${encodeURIComponent(eventId)}/heartbeat`,
+      {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify({ userId })
+      }
+    );
+  }
+  /**
+   * Libera el slot del usuario inmediatamente.
+   * Llamar al completar la compra o al salir voluntariamente.
+   */
+  async leaveQueue(eventId, userId) {
+    await fetch(
+      `${this.apiUrl}/api/queue/${encodeURIComponent(eventId)}/leave`,
+      {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify({ userId })
+      }
+    );
+  }
+  async issueQueueInitToken(eventId, userId, admissionProof) {
+    const res = await fetch(
+      `${this.apiUrl}/api/queue/init/${encodeURIComponent(eventId)}`,
+      {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify({ userId, admissionProof })
+      }
+    );
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      throw new Error(
+        body.message ?? `Error ${res.status} al inicializar sesi\xF3n de cola`
+      );
+    }
+    const token = body.queueInitToken ?? body.initToken;
+    if (!body.userId || !token || !body.expiresAt) {
+      throw new Error("Respuesta inv\xE1lida al inicializar sesi\xF3n de cola");
+    }
+    return {
+      userId: body.userId,
+      queueInitToken: token,
+      expiresAt: body.expiresAt
+    };
+  }
+  async getProtection(eventId) {
+    const res = await fetch(
+      `${this.apiUrl}/api/queue/${encodeURIComponent(eventId)}/protection`,
+      { headers: this.headers }
+    );
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      throw new Error(
+        body.message ?? `Error ${res.status} al consultar protecci\xF3n`
+      );
+    }
+    return {
+      eventId: body.eventId ?? eventId,
+      configured: body.configured === true,
+      protected: body.protected === true,
+      isActive: body.isActive === true,
+      admissionMode: body.admissionMode ?? "PUBLIC",
+      challengeRequired: body.challengeRequired === true
+    };
+  }
+  async getAdmissionChallenge(eventId) {
+    const res = await fetch(
+      `${this.apiUrl}/api/queue/${encodeURIComponent(eventId)}/admission`,
+      { headers: this.headers }
+    );
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      throw new Error(
+        body.message ?? `Error ${res.status} al preparar la admisi\xF3n`
+      );
+    }
+    if (body.required !== true) return { required: false };
+    if (!("publicKey" in body) || !body.publicKey) {
+      throw new Error("Respuesta inv\xE1lida al preparar la admisi\xF3n");
+    }
+    return {
+      required: true,
+      publicKey: body.publicKey,
+      appearance: "interaction-only"
+    };
+  }
+  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 {
+  CENTRALQ_DEFAULT_API_URL,
+  QueueHttpClient
+};

package/dist/chunk-XIQ6LS62.mjs

@@ -0,0 +1,312 @@
+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 reject(new Error("No se pudo inicializar la admisi\xF3n administrada"));
+    };
+    script.onerror = () => 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 = "none";
+  document.body.appendChild(container);
+  return new Promise((resolve, reject) => {
+    let widgetId = "";
+    const cleanup = () => {
+      if (widgetId) driver.remove(widgetId);
+      container.remove();
+    };
+    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);
+  });
+}
+
+// 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/index.d.mts

@@ -1,4 +1,4 @@
-export { C as CentralQ, a as CentralQClient, b as CentralQClientOptions, c as CentralQCreateOptions, d as CentralQOptions, E as ErrorDetail, e as ExpiredDetail, P as PassedDetail, f as PositionDetail, Q as QueueStatus, g as createCentralQClient } from './centralq-I9tdL_Xr.mjs';
+export { C as CentralQ, a as CentralQClient, b as CentralQClientOptions, c as CentralQCreateOptions, d as CentralQOptions, E as ErrorDetail, e as ExpiredDetail, P as PassedDetail, f as PositionDetail, Q as QueueStatus, g as createCentralQClient } from './centralq-C3ukDo0x.mjs';
 export { QueueTokenValidationResult, ValidateQueueTokenServerOptions, validateQueueTokenServer } from './server.mjs';
 import * as lit from 'lit';
 import { LitElement } from 'lit';
@@ -20,6 +20,31 @@ interface QueueInitResponse {
     queueInitToken: string;
     expiresAt: number;
 }
+type AdmissionMode = "PUBLIC" | "MANAGED" | "TRUSTED";
+interface QueueProtectionResponse {
+    eventId: string;
+    configured: boolean;
+    protected: boolean;
+    isActive: boolean;
+    admissionMode: AdmissionMode;
+    challengeRequired: boolean;
+}
+type AdmissionChallengeResponse = {
+    required: false;
+} | {
+    required: true;
+    publicKey: string;
+    appearance: "interaction-only";
+};
+type QueueVerifyResponse = {
+    valid: true;
+    userId: string;
+    eventId: string;
+    expiresAt: string;
+} | {
+    valid: false;
+    reason: string;
+};
 declare const CENTRALQ_DEFAULT_API_URL = "http://localhost:3001";
 /** @internal — HTTP client usado internamente por CentralQ */
 declare class QueueHttpClient {
@@ -43,7 +68,10 @@ declare class QueueHttpClient {
      * Llamar al completar la compra o al salir voluntariamente.
      */
     leaveQueue(eventId: string, userId: string): Promise<void>;
-    issueQueueInitToken(eventId: string, userId?: string): Promise<QueueInitResponse>;
+    issueQueueInitToken(eventId: string, userId?: string, admissionProof?: string): Promise<QueueInitResponse>;
+    getProtection(eventId: string): Promise<QueueProtectionResponse>;
+    getAdmissionChallenge(eventId: string): Promise<AdmissionChallengeResponse>;
+    verifyToken(eventId: string, token: string): Promise<QueueVerifyResponse>;
 }
 
 /**
@@ -61,4 +89,4 @@ declare class CentralQElement extends LitElement {
     render(): lit.TemplateResult<1>;
 }
 
-export { CENTRALQ_DEFAULT_API_URL, CentralQElement, QueueHttpClient, type QueueJoinResponse };
+export { type AdmissionChallengeResponse, type AdmissionMode, CENTRALQ_DEFAULT_API_URL, CentralQElement, QueueHttpClient, type QueueJoinResponse, type QueueProtectionResponse, type QueueVerifyResponse };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { C as CentralQ, a as CentralQClient, b as CentralQClientOptions, c as CentralQCreateOptions, d as CentralQOptions, E as ErrorDetail, e as ExpiredDetail, P as PassedDetail, f as PositionDetail, Q as QueueStatus, g as createCentralQClient } from './centralq-I9tdL_Xr.js';
+export { C as CentralQ, a as CentralQClient, b as CentralQClientOptions, c as CentralQCreateOptions, d as CentralQOptions, E as ErrorDetail, e as ExpiredDetail, P as PassedDetail, f as PositionDetail, Q as QueueStatus, g as createCentralQClient } from './centralq-C3ukDo0x.js';
 export { QueueTokenValidationResult, ValidateQueueTokenServerOptions, validateQueueTokenServer } from './server.js';
 import * as lit from 'lit';
 import { LitElement } from 'lit';
@@ -20,6 +20,31 @@ interface QueueInitResponse {
     queueInitToken: string;
     expiresAt: number;
 }
+type AdmissionMode = "PUBLIC" | "MANAGED" | "TRUSTED";
+interface QueueProtectionResponse {
+    eventId: string;
+    configured: boolean;
+    protected: boolean;
+    isActive: boolean;
+    admissionMode: AdmissionMode;
+    challengeRequired: boolean;
+}
+type AdmissionChallengeResponse = {
+    required: false;
+} | {
+    required: true;
+    publicKey: string;
+    appearance: "interaction-only";
+};
+type QueueVerifyResponse = {
+    valid: true;
+    userId: string;
+    eventId: string;
+    expiresAt: string;
+} | {
+    valid: false;
+    reason: string;
+};
 declare const CENTRALQ_DEFAULT_API_URL = "http://localhost:3001";
 /** @internal — HTTP client usado internamente por CentralQ */
 declare class QueueHttpClient {
@@ -43,7 +68,10 @@ declare class QueueHttpClient {
      * Llamar al completar la compra o al salir voluntariamente.
      */
     leaveQueue(eventId: string, userId: string): Promise<void>;
-    issueQueueInitToken(eventId: string, userId?: string): Promise<QueueInitResponse>;
+    issueQueueInitToken(eventId: string, userId?: string, admissionProof?: string): Promise<QueueInitResponse>;
+    getProtection(eventId: string): Promise<QueueProtectionResponse>;
+    getAdmissionChallenge(eventId: string): Promise<AdmissionChallengeResponse>;
+    verifyToken(eventId: string, token: string): Promise<QueueVerifyResponse>;
 }
 
 /**
@@ -61,4 +89,4 @@ declare class CentralQElement extends LitElement {
     render(): lit.TemplateResult<1>;
 }
 
-export { CENTRALQ_DEFAULT_API_URL, CentralQElement, QueueHttpClient, type QueueJoinResponse };
+export { type AdmissionChallengeResponse, type AdmissionMode, CENTRALQ_DEFAULT_API_URL, CentralQElement, QueueHttpClient, type QueueJoinResponse, type QueueProtectionResponse, type QueueVerifyResponse };