@central-ticket/queue-sdk 0.0.1

package/dist/svelte.mjs

@@ -0,0 +1,189 @@
+import {
+  CentralQ
+} from "./chunk-A4HITWM4.mjs";
+import "./chunk-42RGFZKP.mjs";
+import "./chunk-XRJFNASX.mjs";
+
+// src/svelte.ts
+import { writable, readonly, get, derived } from "svelte/store";
+import { onMount } from "svelte";
+function createCentralQ(options) {
+  const _token = writable(null);
+  const _position = writable(null);
+  const _ahead = writable(null);
+  const _expired = writable(false);
+  const _error = writable(false);
+  let queue = null;
+  onMount(() => {
+    queue = CentralQ.init(options);
+    queue.on("passed", (detail) => {
+      _token.set(detail.token);
+      _position.set(null);
+      _ahead.set(null);
+      _expired.set(false);
+      _error.set(false);
+    });
+    queue.on("position", (detail) => {
+      _position.set(detail.position);
+      _ahead.set(detail.ahead);
+    });
+    queue.on("expired", () => {
+      _token.set(null);
+      _expired.set(true);
+    });
+    queue.on("error", () => {
+      _error.set(true);
+    });
+    return () => {
+      queue?.destroy();
+      queue = null;
+    };
+  });
+  return {
+    token: readonly(_token),
+    position: readonly(_position),
+    ahead: readonly(_ahead),
+    expired: readonly(_expired),
+    error: readonly(_error),
+    leave: () => {
+      queue?.leave();
+      _token.set(null);
+      _position.set(null);
+      _ahead.set(null);
+    }
+  };
+}
+function useQueue(optionsInput) {
+  const status = writable("idle");
+  const data = writable({
+    token: null,
+    position: null,
+    ahead: null,
+    expiresAt: null
+  });
+  const error = writable(null);
+  const isPending = writable(true);
+  const instance = writable(null);
+  const token = derived(data, ($data) => $data.token);
+  const position = derived(data, ($data) => $data.position);
+  const ahead = derived(data, ($data) => $data.ahead);
+  const expiresAt = derived(data, ($data) => $data.expiresAt);
+  const reset = () => {
+    status.set("idle");
+    error.set(null);
+    data.set({ token: null, position: null, ahead: null, expiresAt: null });
+    isPending.set(true);
+  };
+  const leave = () => {
+    get(instance)?.leave();
+    status.set("idle");
+    data.set({ token: null, position: null, ahead: null, expiresAt: null });
+    isPending.set(true);
+  };
+  onMount(() => {
+    let queue = null;
+    let cancelled = false;
+    const options = typeof optionsInput === "function" ? optionsInput() : optionsInput;
+    if (options.enabled === false) {
+      reset();
+      return;
+    }
+    status.set("joining");
+    error.set(null);
+    isPending.set(true);
+    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) => {
+          data.set({
+            token: detail.token,
+            position: null,
+            ahead: null,
+            expiresAt: detail.expiresAt
+          });
+          status.set("passed");
+          error.set(null);
+          isPending.set(false);
+        });
+        queue.on("position", (detail) => {
+          data.update((prev) => ({
+            ...prev,
+            token: null,
+            position: detail.position,
+            ahead: detail.ahead
+          }));
+          status.set("waiting");
+          isPending.set(false);
+        });
+        queue.on("expired", () => {
+          data.set({
+            token: null,
+            position: null,
+            ahead: null,
+            expiresAt: null
+          });
+          status.set("expired");
+          isPending.set(false);
+        });
+        queue.on("error", () => {
+          status.set("error");
+          error.set(new Error("Queue connection error"));
+          isPending.set(false);
+        });
+        instance.set(queue);
+      } catch (err) {
+        if (cancelled) return;
+        status.set("error");
+        error.set(
+          err instanceof Error ? err : new Error("Queue connection error")
+        );
+        isPending.set(false);
+      }
+    };
+    init();
+    return () => {
+      cancelled = true;
+      queue?.destroy();
+      instance.set(null);
+    };
+  });
+  return {
+    status: readonly(status),
+    token,
+    position,
+    ahead,
+    expiresAt,
+    data: readonly(data),
+    isPending: readonly(isPending),
+    error: readonly(error),
+    leave,
+    reset,
+    instance: readonly(instance)
+  };
+}
+export {
+  createCentralQ,
+  useQueue
+};

package/dist/vue.d.mts

@@ -0,0 +1,31 @@
+import { Ref } from 'vue';
+import { c as CentralQCreateOptions, a as CentralQClient, Q as QueueStatus, C as CentralQ } from './centralq-I9tdL_Xr.mjs';
+
+interface QueueData {
+    token: string | null;
+    position: number | null;
+    ahead: number | null;
+    expiresAt: number | null;
+}
+interface UseQueueOptions extends Omit<CentralQCreateOptions, "apiUrl" | "apiKey"> {
+    client: CentralQClient;
+    enabled?: boolean;
+    autoInitToken?: boolean;
+}
+type UseQueueOptionsInput = UseQueueOptions | (() => UseQueueOptions);
+interface UseQueueReturn {
+    status: Readonly<Ref<QueueStatus>>;
+    token: Readonly<Ref<string | null>>;
+    position: Readonly<Ref<number | null>>;
+    ahead: Readonly<Ref<number | null>>;
+    expiresAt: Readonly<Ref<number | null>>;
+    data: Readonly<Ref<QueueData>>;
+    isPending: Readonly<Ref<boolean>>;
+    error: Readonly<Ref<Error | null>>;
+    instance: Readonly<Ref<CentralQ | null>>;
+    leave: () => void;
+    reset: () => void;
+}
+declare function useQueue(optionsInput: UseQueueOptionsInput): UseQueueReturn;
+
+export { type QueueData, type UseQueueOptions, type UseQueueOptionsInput, type UseQueueReturn, useQueue };

package/dist/vue.d.ts

@@ -0,0 +1,31 @@
+import { Ref } from 'vue';
+import { c as CentralQCreateOptions, a as CentralQClient, Q as QueueStatus, C as CentralQ } from './centralq-I9tdL_Xr.js';
+
+interface QueueData {
+    token: string | null;
+    position: number | null;
+    ahead: number | null;
+    expiresAt: number | null;
+}
+interface UseQueueOptions extends Omit<CentralQCreateOptions, "apiUrl" | "apiKey"> {
+    client: CentralQClient;
+    enabled?: boolean;
+    autoInitToken?: boolean;
+}
+type UseQueueOptionsInput = UseQueueOptions | (() => UseQueueOptions);
+interface UseQueueReturn {
+    status: Readonly<Ref<QueueStatus>>;
+    token: Readonly<Ref<string | null>>;
+    position: Readonly<Ref<number | null>>;
+    ahead: Readonly<Ref<number | null>>;
+    expiresAt: Readonly<Ref<number | null>>;
+    data: Readonly<Ref<QueueData>>;
+    isPending: Readonly<Ref<boolean>>;
+    error: Readonly<Ref<Error | null>>;
+    instance: Readonly<Ref<CentralQ | null>>;
+    leave: () => void;
+    reset: () => void;
+}
+declare function useQueue(optionsInput: UseQueueOptionsInput): UseQueueReturn;
+
+export { type QueueData, type UseQueueOptions, type UseQueueOptionsInput, type UseQueueReturn, useQueue };

package/dist/vue.js

@@ -0,0 +1,152 @@
+"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/vue.ts
+var vue_exports = {};
+__export(vue_exports, {
+  useQueue: () => useQueue
+});
+module.exports = __toCommonJS(vue_exports);
+var import_vue = require("vue");
+function useQueue(optionsInput) {
+  const status = (0, import_vue.ref)("idle");
+  const token = (0, import_vue.ref)(null);
+  const position = (0, import_vue.ref)(null);
+  const ahead = (0, import_vue.ref)(null);
+  const expiresAt = (0, import_vue.ref)(null);
+  const data = (0, import_vue.computed)(() => ({
+    token: token.value,
+    position: position.value,
+    ahead: ahead.value,
+    expiresAt: expiresAt.value
+  }));
+  const isPending = (0, import_vue.ref)(true);
+  const error = (0, import_vue.ref)(null);
+  const instance = (0, import_vue.shallowRef)(null);
+  let cancelled = false;
+  const readOptions = () => typeof optionsInput === "function" ? optionsInput() : optionsInput;
+  const reset = () => {
+    status.value = "idle";
+    token.value = null;
+    position.value = null;
+    ahead.value = null;
+    expiresAt.value = null;
+    isPending.value = true;
+    error.value = null;
+  };
+  const leave = () => {
+    instance.value?.leave();
+    reset();
+  };
+  const bindQueueListeners = (queue) => {
+    queue.on("passed", (detail) => {
+      token.value = detail.token;
+      position.value = null;
+      ahead.value = null;
+      expiresAt.value = detail.expiresAt;
+      status.value = "passed";
+      isPending.value = false;
+      error.value = null;
+    });
+    queue.on("position", (detail) => {
+      token.value = null;
+      position.value = detail.position;
+      ahead.value = detail.ahead;
+      status.value = "waiting";
+      isPending.value = false;
+    });
+    queue.on("expired", () => {
+      token.value = null;
+      position.value = null;
+      ahead.value = null;
+      expiresAt.value = null;
+      status.value = "expired";
+      isPending.value = false;
+    });
+    queue.on("error", () => {
+      status.value = "error";
+      isPending.value = false;
+      error.value = new Error("Queue connection error");
+    });
+  };
+  (0, import_vue.onMounted)(async () => {
+    const options = readOptions();
+    if (options.enabled === false) {
+      reset();
+      return;
+    }
+    status.value = "joining";
+    isPending.value = true;
+    error.value = null;
+    try {
+      let resolvedUserId = options.userId;
+      let queueInitToken = options.queueInitToken;
+      if (!resolvedUserId || !queueInitToken) {
+        if (options.autoInitToken === false) {
+          throw new Error(
+            "Falta queueInitToken/userId y autoInitToken est\xE1 deshabilitado"
+          );
+        }
+        const init = await options.client.issueQueueInitToken(
+          options.eventId,
+          resolvedUserId
+        );
+        resolvedUserId = init.userId;
+        queueInitToken = init.queueInitToken;
+      }
+      if (cancelled) return;
+      const queue = options.client.createQueue({
+        eventId: options.eventId,
+        userId: resolvedUserId,
+        queueInitToken,
+        pollInterval: options.pollInterval,
+        container: options.container
+      });
+      bindQueueListeners(queue);
+      instance.value = queue;
+    } catch (err) {
+      if (cancelled) return;
+      status.value = "error";
+      isPending.value = false;
+      error.value = err instanceof Error ? err : new Error("Queue connection error");
+    }
+  });
+  (0, import_vue.onUnmounted)(() => {
+    cancelled = true;
+    instance.value?.destroy();
+    instance.value = null;
+  });
+  return {
+    status: (0, import_vue.readonly)(status),
+    token: (0, import_vue.readonly)(token),
+    position: (0, import_vue.readonly)(position),
+    ahead: (0, import_vue.readonly)(ahead),
+    expiresAt: (0, import_vue.readonly)(expiresAt),
+    data: (0, import_vue.readonly)(data),
+    isPending: (0, import_vue.readonly)(isPending),
+    error: (0, import_vue.readonly)(error),
+    instance,
+    leave,
+    reset
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useQueue
+});

package/dist/vue.mjs

@@ -0,0 +1,136 @@
+import "./chunk-XRJFNASX.mjs";
+
+// src/vue.ts
+import {
+  ref,
+  readonly,
+  computed,
+  shallowRef,
+  onMounted,
+  onUnmounted
+} from "vue";
+function useQueue(optionsInput) {
+  const status = ref("idle");
+  const token = ref(null);
+  const position = ref(null);
+  const ahead = ref(null);
+  const expiresAt = ref(null);
+  const data = computed(() => ({
+    token: token.value,
+    position: position.value,
+    ahead: ahead.value,
+    expiresAt: expiresAt.value
+  }));
+  const isPending = ref(true);
+  const error = ref(null);
+  const instance = shallowRef(null);
+  let cancelled = false;
+  const readOptions = () => typeof optionsInput === "function" ? optionsInput() : optionsInput;
+  const reset = () => {
+    status.value = "idle";
+    token.value = null;
+    position.value = null;
+    ahead.value = null;
+    expiresAt.value = null;
+    isPending.value = true;
+    error.value = null;
+  };
+  const leave = () => {
+    instance.value?.leave();
+    reset();
+  };
+  const bindQueueListeners = (queue) => {
+    queue.on("passed", (detail) => {
+      token.value = detail.token;
+      position.value = null;
+      ahead.value = null;
+      expiresAt.value = detail.expiresAt;
+      status.value = "passed";
+      isPending.value = false;
+      error.value = null;
+    });
+    queue.on("position", (detail) => {
+      token.value = null;
+      position.value = detail.position;
+      ahead.value = detail.ahead;
+      status.value = "waiting";
+      isPending.value = false;
+    });
+    queue.on("expired", () => {
+      token.value = null;
+      position.value = null;
+      ahead.value = null;
+      expiresAt.value = null;
+      status.value = "expired";
+      isPending.value = false;
+    });
+    queue.on("error", () => {
+      status.value = "error";
+      isPending.value = false;
+      error.value = new Error("Queue connection error");
+    });
+  };
+  onMounted(async () => {
+    const options = readOptions();
+    if (options.enabled === false) {
+      reset();
+      return;
+    }
+    status.value = "joining";
+    isPending.value = true;
+    error.value = null;
+    try {
+      let resolvedUserId = options.userId;
+      let queueInitToken = options.queueInitToken;
+      if (!resolvedUserId || !queueInitToken) {
+        if (options.autoInitToken === false) {
+          throw new Error(
+            "Falta queueInitToken/userId y autoInitToken est\xE1 deshabilitado"
+          );
+        }
+        const init = await options.client.issueQueueInitToken(
+          options.eventId,
+          resolvedUserId
+        );
+        resolvedUserId = init.userId;
+        queueInitToken = init.queueInitToken;
+      }
+      if (cancelled) return;
+      const queue = options.client.createQueue({
+        eventId: options.eventId,
+        userId: resolvedUserId,
+        queueInitToken,
+        pollInterval: options.pollInterval,
+        container: options.container
+      });
+      bindQueueListeners(queue);
+      instance.value = queue;
+    } catch (err) {
+      if (cancelled) return;
+      status.value = "error";
+      isPending.value = false;
+      error.value = err instanceof Error ? err : new Error("Queue connection error");
+    }
+  });
+  onUnmounted(() => {
+    cancelled = true;
+    instance.value?.destroy();
+    instance.value = null;
+  });
+  return {
+    status: readonly(status),
+    token: readonly(token),
+    position: readonly(position),
+    ahead: readonly(ahead),
+    expiresAt: readonly(expiresAt),
+    data: readonly(data),
+    isPending: readonly(isPending),
+    error: readonly(error),
+    instance,
+    leave,
+    reset
+  };
+}
+export {
+  useQueue
+};

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@central-ticket/queue-sdk",
+  "version": "0.0.1",
+  "keywords": [
+    "virtual-queue",
+    "waiting-room",
+    "ticketing",
+    "event-ticketing",
+    "queue-management",
+    "queue-token",
+    "sdk",
+    "centralq",
+    "react",
+    "vue",
+    "svelte",
+    "web-component",
+    "typescript"
+  ],
+  "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"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.mjs",
+      "require": "./dist/react.js"
+    },
+    "./svelte": {
+      "types": "./dist/svelte.d.ts",
+      "import": "./dist/svelte.mjs",
+      "require": "./dist/svelte.js"
+    },
+    "./vue": {
+      "types": "./dist/vue.d.ts",
+      "import": "./dist/vue.mjs",
+      "require": "./dist/vue.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.mjs",
+      "require": "./dist/server.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/react.ts src/svelte.ts src/vue.ts src/server.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts src/react.ts src/svelte.ts src/vue.ts src/server.ts --format cjs,esm --dts --watch",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "svelte": ">=4",
+    "vue": ">=3"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "svelte": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/react": ">=18",
+    "react": ">=18",
+    "svelte": "^5.51.0",
+    "vue": "^3.5.18",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^2.1.8"
+  },
+  "dependencies": {
+    "lit": "^3.3.2"
+  }
+}