@central-ticket/queue-sdk 0.0.2 → 0.0.4

package/dist/chunk-XIQ6LS62.mjs

@@ -1,312 +0,0 @@
-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
-};