@central-ticket/queue-sdk 0.0.1

package/dist/react.mjs

@@ -0,0 +1,185 @@
+import {
+  CentralQ
+} from "./chunk-A4HITWM4.mjs";
+import "./chunk-42RGFZKP.mjs";
+import "./chunk-XRJFNASX.mjs";
+
+// src/react.ts
+import { useEffect, useRef, useState, useCallback } from "react";
+function useCentralQ(options) {
+  const [token, setToken] = useState(null);
+  const [position, setPosition] = useState(null);
+  const [ahead, setAhead] = useState(null);
+  const [expired, setExpired] = useState(false);
+  const [error, setError] = useState(false);
+  const instanceRef = useRef(null);
+  const leave = useCallback(() => {
+    instanceRef.current?.leave();
+    setToken(null);
+    setPosition(null);
+    setAhead(null);
+  }, []);
+  useEffect(() => {
+    const queue = CentralQ.init(options);
+    queue.on("passed", (detail) => {
+      setToken(detail.token);
+      setPosition(null);
+      setAhead(null);
+      setExpired(false);
+      setError(false);
+    });
+    queue.on("position", (detail) => {
+      setPosition(detail.position);
+      setAhead(detail.ahead);
+    });
+    queue.on("expired", () => {
+      setToken(null);
+      setExpired(true);
+    });
+    queue.on("error", () => {
+      setError(true);
+    });
+    instanceRef.current = queue;
+    return () => {
+      queue.destroy();
+      instanceRef.current = null;
+    };
+  }, [options.apiUrl, options.apiKey, options.eventId]);
+  return {
+    token,
+    position,
+    ahead,
+    expired,
+    error,
+    leave,
+    instance: instanceRef.current
+  };
+}
+function useQueue(options) {
+  const [status, setStatus] = useState("idle");
+  const [data, setData] = useState({
+    token: null,
+    position: null,
+    ahead: null,
+    expiresAt: null
+  });
+  const [error, setError] = useState(null);
+  const instanceRef = useRef(null);
+  const reset = useCallback(() => {
+    setStatus("idle");
+    setError(null);
+    setData({ token: null, position: null, ahead: null, expiresAt: null });
+  }, []);
+  const leave = useCallback(() => {
+    instanceRef.current?.leave();
+    setData({ token: null, position: null, ahead: null, expiresAt: null });
+    setStatus("idle");
+  }, []);
+  useEffect(() => {
+    let queue = null;
+    let cancelled = false;
+    if (options.enabled === false) {
+      instanceRef.current?.destroy();
+      instanceRef.current = null;
+      reset();
+      return;
+    }
+    setStatus("joining");
+    setError(null);
+    const init = async () => {
+      try {
+        let userId = options.userId;
+        let queueInitToken = options.queueInitToken;
+        if (!userId || !queueInitToken) {
+          if (options.autoInitToken === false) {
+            throw new Error(
+              "Falta queueInitToken/userId y initEndpoint est\xE1 deshabilitado"
+            );
+          }
+          const init2 = await options.client.issueQueueInitToken(
+            options.eventId,
+            userId
+          );
+          userId = init2.userId;
+          queueInitToken = init2.queueInitToken;
+        }
+        if (cancelled) return;
+        queue = options.client.createQueue({
+          eventId: options.eventId,
+          userId,
+          queueInitToken,
+          pollInterval: options.pollInterval,
+          container: options.container
+        });
+        queue.on("passed", (detail) => {
+          setData({
+            token: detail.token,
+            position: null,
+            ahead: null,
+            expiresAt: detail.expiresAt
+          });
+          setStatus("passed");
+          setError(null);
+        });
+        queue.on("position", (detail) => {
+          setData((prev) => ({
+            ...prev,
+            token: null,
+            position: detail.position,
+            ahead: detail.ahead
+          }));
+          setStatus("waiting");
+        });
+        queue.on("expired", () => {
+          setData({
+            token: null,
+            position: null,
+            ahead: null,
+            expiresAt: null
+          });
+          setStatus("expired");
+        });
+        queue.on("error", () => {
+          setStatus("error");
+          setError(new Error("Queue connection error"));
+        });
+        instanceRef.current = queue;
+      } catch (err) {
+        if (cancelled) return;
+        setStatus("error");
+        setError(
+          err instanceof Error ? err : new Error("Queue connection error")
+        );
+      }
+    };
+    init();
+    return () => {
+      cancelled = true;
+      queue?.destroy();
+      instanceRef.current = null;
+    };
+  }, [
+    options.client,
+    options.enabled,
+    options.eventId,
+    options.userId,
+    options.queueInitToken,
+    options.autoInitToken,
+    options.pollInterval,
+    options.container,
+    reset
+  ]);
+  return {
+    status,
+    data,
+    isPending: status === "idle" || status === "joining",
+    error,
+    leave,
+    reset,
+    instance: instanceRef.current
+  };
+}
+export {
+  useCentralQ,
+  useQueue
+};

package/dist/server.d.mts

@@ -0,0 +1,21 @@
+interface ValidateQueueTokenServerOptions {
+    apiUrl?: string;
+    secretKey: string;
+    eventId: string;
+    token: string;
+}
+type QueueTokenValidationResult = {
+    valid: true;
+    userId: string;
+    eventId: string;
+    expiresAt: string;
+} | {
+    valid: false;
+    reason: string;
+};
+declare function validateQueueTokenServer(options: ValidateQueueTokenServerOptions): Promise<{
+    status: number;
+    data: QueueTokenValidationResult;
+}>;
+
+export { type QueueTokenValidationResult, type ValidateQueueTokenServerOptions, validateQueueTokenServer };

package/dist/server.d.ts

@@ -0,0 +1,21 @@
+interface ValidateQueueTokenServerOptions {
+    apiUrl?: string;
+    secretKey: string;
+    eventId: string;
+    token: string;
+}
+type QueueTokenValidationResult = {
+    valid: true;
+    userId: string;
+    eventId: string;
+    expiresAt: string;
+} | {
+    valid: false;
+    reason: string;
+};
+declare function validateQueueTokenServer(options: ValidateQueueTokenServerOptions): Promise<{
+    status: number;
+    data: QueueTokenValidationResult;
+}>;
+
+export { type QueueTokenValidationResult, type ValidateQueueTokenServerOptions, validateQueueTokenServer };

package/dist/server.js

@@ -0,0 +1,56 @@
+"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/server.ts
+var server_exports = {};
+__export(server_exports, {
+  validateQueueTokenServer: () => validateQueueTokenServer
+});
+module.exports = __toCommonJS(server_exports);
+
+// src/queue-client.ts
+var CENTRALQ_DEFAULT_API_URL = "http://localhost:3001";
+
+// 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/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 };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validateQueueTokenServer
+});

package/dist/server.mjs

@@ -0,0 +1,8 @@
+import {
+  validateQueueTokenServer
+} from "./chunk-JR7BCYB5.mjs";
+import "./chunk-42RGFZKP.mjs";
+import "./chunk-XRJFNASX.mjs";
+export {
+  validateQueueTokenServer
+};

package/dist/svelte.d.mts

@@ -0,0 +1,79 @@
+import { Readable } from 'svelte/store';
+import { Q as QueueStatus, C as CentralQ, c as CentralQCreateOptions, a as CentralQClient, d as CentralQOptions } from './centralq-I9tdL_Xr.mjs';
+
+interface CentralQStores {
+    /** Store con el token JWT si el usuario fue admitido */
+    token: Readable<string | null>;
+    /** Store con la posición en la cola (1-based) */
+    position: Readable<number | null>;
+    /** Store con las personas delante en la cola */
+    ahead: Readable<number | null>;
+    /** Store indicando si la sesión expiró */
+    expired: Readable<boolean>;
+    /** Store indicando si hay un error de conexión */
+    error: Readable<boolean>;
+    /** Libera el slot (llamar después de comprar) */
+    leave: () => void;
+}
+interface QueueData {
+    token: string | null;
+    position: number | null;
+    ahead: number | null;
+    expiresAt: number | null;
+}
+interface UseQueueOptions extends Omit<CentralQCreateOptions, "apiUrl" | "apiKey"> {
+    /** Cliente global creado con createCentralQClient */
+    client: CentralQClient;
+    /** Habilita o pausa la suscripción de la cola */
+    enabled?: boolean;
+    /** Deshabilita bootstrap automático de init token */
+    autoInitToken?: boolean;
+}
+type UseQueueOptionsInput = UseQueueOptions | (() => UseQueueOptions);
+interface QueueStores {
+    status: Readable<QueueStatus>;
+    token: Readable<string | null>;
+    position: Readable<number | null>;
+    ahead: Readable<number | null>;
+    expiresAt: Readable<number | null>;
+    data: Readable<QueueData>;
+    isPending: Readable<boolean>;
+    error: Readable<Error | null>;
+    leave: () => void;
+    reset: () => void;
+    instance: Readable<CentralQ | null>;
+}
+/**
+ * Svelte adapter que encapsula toda la lógica de CentralQ
+ * usando Svelte stores.
+ *
+ * **Debe llamarse en el top-level del `<script>` del componente**
+ * (igual que onMount — internamente usa onMount para diferir
+ * la inicialización al browser y evitar problemas de SSR).
+ *
+ * ```svelte
+ * <script lang="ts">
+ *   import { createCentralQ } from '@central-ticket/queue-sdk/svelte';
+ *
+ *   const { token, position, expired, leave } = createCentralQ({
+ *     apiUrl: 'http://localhost:3001',
+ *     apiKey: 'ctq_pub_xxx',
+ *     eventId: 'coldplay-2026',
+ *   });
+ * </script>
+ *
+ * {#if $token}
+ *   <button onclick={() => { buy(); leave(); }}>Comprar</button>
+ * {:else if $expired}
+ *   <p>Sesión expirada</p>
+ * {:else if $position}
+ *   <p>Posición #{$position}</p>
+ * {:else}
+ *   <p>Conectando...</p>
+ * {/if}
+ * ```
+ */
+declare function createCentralQ(options: CentralQOptions): CentralQStores;
+declare function useQueue(optionsInput: UseQueueOptionsInput): QueueStores;
+
+export { type CentralQStores, type QueueData, type QueueStores, type UseQueueOptions, type UseQueueOptionsInput, createCentralQ, useQueue };

package/dist/svelte.d.ts

@@ -0,0 +1,79 @@
+import { Readable } from 'svelte/store';
+import { Q as QueueStatus, C as CentralQ, c as CentralQCreateOptions, a as CentralQClient, d as CentralQOptions } from './centralq-I9tdL_Xr.js';
+
+interface CentralQStores {
+    /** Store con el token JWT si el usuario fue admitido */
+    token: Readable<string | null>;
+    /** Store con la posición en la cola (1-based) */
+    position: Readable<number | null>;
+    /** Store con las personas delante en la cola */
+    ahead: Readable<number | null>;
+    /** Store indicando si la sesión expiró */
+    expired: Readable<boolean>;
+    /** Store indicando si hay un error de conexión */
+    error: Readable<boolean>;
+    /** Libera el slot (llamar después de comprar) */
+    leave: () => void;
+}
+interface QueueData {
+    token: string | null;
+    position: number | null;
+    ahead: number | null;
+    expiresAt: number | null;
+}
+interface UseQueueOptions extends Omit<CentralQCreateOptions, "apiUrl" | "apiKey"> {
+    /** Cliente global creado con createCentralQClient */
+    client: CentralQClient;
+    /** Habilita o pausa la suscripción de la cola */
+    enabled?: boolean;
+    /** Deshabilita bootstrap automático de init token */
+    autoInitToken?: boolean;
+}
+type UseQueueOptionsInput = UseQueueOptions | (() => UseQueueOptions);
+interface QueueStores {
+    status: Readable<QueueStatus>;
+    token: Readable<string | null>;
+    position: Readable<number | null>;
+    ahead: Readable<number | null>;
+    expiresAt: Readable<number | null>;
+    data: Readable<QueueData>;
+    isPending: Readable<boolean>;
+    error: Readable<Error | null>;
+    leave: () => void;
+    reset: () => void;
+    instance: Readable<CentralQ | null>;
+}
+/**
+ * Svelte adapter que encapsula toda la lógica de CentralQ
+ * usando Svelte stores.
+ *
+ * **Debe llamarse en el top-level del `<script>` del componente**
+ * (igual que onMount — internamente usa onMount para diferir
+ * la inicialización al browser y evitar problemas de SSR).
+ *
+ * ```svelte
+ * <script lang="ts">
+ *   import { createCentralQ } from '@central-ticket/queue-sdk/svelte';
+ *
+ *   const { token, position, expired, leave } = createCentralQ({
+ *     apiUrl: 'http://localhost:3001',
+ *     apiKey: 'ctq_pub_xxx',
+ *     eventId: 'coldplay-2026',
+ *   });
+ * </script>
+ *
+ * {#if $token}
+ *   <button onclick={() => { buy(); leave(); }}>Comprar</button>
+ * {:else if $expired}
+ *   <p>Sesión expirada</p>
+ * {:else if $position}
+ *   <p>Posición #{$position}</p>
+ * {:else}
+ *   <p>Conectando...</p>
+ * {/if}
+ * ```
+ */
+declare function createCentralQ(options: CentralQOptions): CentralQStores;
+declare function useQueue(optionsInput: UseQueueOptionsInput): QueueStores;
+
+export { type CentralQStores, type QueueData, type QueueStores, type UseQueueOptions, type UseQueueOptionsInput, createCentralQ, useQueue };