vue-streaming 2.0.1 → 2.0.2

package/dist/useWebSocket-C3JPFBmy.js

@@ -0,0 +1,1328 @@
+import { ref as v, onUnmounted as U } from "vue";
+import { parseArrayBboxFormat as K, normalizeBboxes as V, bboxesToDetectionFrame as q, parsePointCloudJSON as J, parsePointCloudBinary as Q, createReconnectManager as G } from "./utils/index.js";
+const X = {
+  autoPlay: !0,
+  startLevel: -1,
+  lowLatencyMode: !1,
+  maxBufferLength: 30,
+  maxMaxBufferLength: 600,
+  enableWorker: !0,
+  startPosition: -1,
+  hlsConfig: {}
+};
+function se(N, e = {}) {
+  const n = { ...X, ...N }, d = v("idle"), a = v(!1), m = v(!1), y = v([]), A = v(-1), T = v(!0), f = v(0), i = v(0), w = v(0), S = v(1), R = v(!1), L = v({
+    bandwidth: 0,
+    buffered: 0,
+    dropped: 0,
+    loaded: 0,
+    currentLevel: -1,
+    bufferedDuration: 0,
+    droppedFrames: 0,
+    latency: 0
+  }), I = v(null), F = v(!1);
+  let E = null, O = null, p = null, D = null;
+  async function u() {
+    if (O) return O;
+    try {
+      const l = await import("hls.js");
+      return O = l.default || l, F.value = O.isSupported(), O;
+    } catch {
+      return console.error("[useHLS] hls.js not installed. Run: npm install hls.js"), null;
+    }
+  }
+  function h() {
+    if (p && (f.value = p.currentTime, i.value = p.duration || 0, p.buffered.length > 0)) {
+      const l = p.buffered.end(
+        p.buffered.length - 1
+      );
+      w.value = i.value > 0 ? l / i.value * 100 : 0, L.value.bufferedDuration = l - p.currentTime;
+    }
+  }
+  function t(l) {
+    l.onplay = () => {
+      var g;
+      a.value = !0, d.value = "playing", (g = e.onPlaybackStarted) == null || g.call(e);
+    }, l.onpause = () => {
+      a.value = !1, d.value = "paused";
+    }, l.onended = () => {
+      var g;
+      a.value = !1, d.value = "ended", (g = e.onPlaybackEnded) == null || g.call(e);
+    }, l.onwaiting = () => {
+      var g;
+      m.value = !0, d.value = "buffering", (g = e.onBuffering) == null || g.call(e);
+    }, l.onplaying = () => {
+      var g;
+      m.value = !1, d.value === "buffering" && (d.value = "playing"), (g = e.onBuffered) == null || g.call(e);
+    }, l.onseeking = () => {
+      d.value = "seeking";
+    }, l.onseeked = () => {
+      d.value = a.value ? "playing" : "paused";
+    }, l.onvolumechange = () => {
+      S.value = l.volume, R.value = l.muted;
+    }, l.onerror = () => {
+      var _, H;
+      const g = new Error(((_ = l.error) == null ? void 0 : _.message) || "Video playback error");
+      I.value = g, d.value = "error", (H = e.onError) == null || H.call(e, g, !0);
+    }, D = setInterval(h, 250);
+  }
+  function s() {
+    !E || !O || (E.on(
+      O.Events.MANIFEST_PARSED,
+      (l, g) => {
+        var _;
+        y.value = g.levels.map((H, z) => ({
+          index: z,
+          bitrate: H.bitrate,
+          width: H.width,
+          height: H.height,
+          codec: H.codec,
+          name: `${H.height}p`
+        })), d.value = "loaded", (_ = e.onManifestLoaded) == null || _.call(e, y.value);
+      }
+    ), E.on(
+      O.Events.LEVEL_SWITCHED,
+      (l, g) => {
+        var _;
+        A.value = g.level, L.value.currentLevel = g.level, (_ = e.onLevelSwitched) == null || _.call(e, g.level);
+      }
+    ), E.on(
+      O.Events.FRAG_LOADED,
+      (l, g) => {
+        L.value.bandwidth = g.frag.duration * 8 * 1e6 / (g.stats.loading.end - g.stats.loading.start);
+      }
+    ), E.on(
+      O.Events.ERROR,
+      (l, g) => {
+        var H;
+        const _ = new Error(`HLS Error: ${g.type} - ${g.details}`);
+        g.fatal && (I.value = _, d.value = "error", g.type === O.ErrorTypes.MEDIA_ERROR && (E == null || E.recoverMediaError())), (H = e.onError) == null || H.call(e, _, g.fatal);
+      }
+    ));
+  }
+  async function r(l) {
+    const g = await u();
+    if (!g)
+      throw new Error("HLS.js is not available");
+    if (!g.isSupported()) {
+      if (l.canPlayType("application/vnd.apple.mpegurl")) {
+        l.src = n.url, p = l, t(l), d.value = "loaded", n.autoPlay && await M();
+        return;
+      }
+      throw new Error("HLS is not supported in this browser");
+    }
+    p = l, d.value = "loading", E = new g({
+      startLevel: n.startLevel,
+      lowLatencyMode: n.lowLatencyMode,
+      maxBufferLength: n.maxBufferLength,
+      enableWorker: n.enableWorker,
+      startPosition: n.startPosition
+    }), s(), t(l), E.loadSource(n.url), E.attachMedia(l), n.autoPlay && E.on(g.Events.MANIFEST_PARSED, () => {
+      M();
+    });
+  }
+  function o() {
+    E && E.detachMedia(), D && (clearInterval(D), D = null), p = null;
+  }
+  function c(l) {
+    const g = l || n.url;
+    E ? E.loadSource(g) : p && (p.src = g), d.value = "loading";
+  }
+  async function M() {
+    if (!p)
+      throw new Error("No video element attached");
+    try {
+      await p.play();
+    } catch (l) {
+      if (l.name === "NotAllowedError")
+        R.value = !0, p.muted = !0, await p.play();
+      else
+        throw l;
+    }
+  }
+  function C() {
+    p == null || p.pause();
+  }
+  function P() {
+    E && E.stopLoad(), p && (p.pause(), p.currentTime = 0), a.value = !1, d.value = "idle";
+  }
+  function x(l) {
+    p && (p.currentTime = l);
+  }
+  function $(l) {
+    E && (E.currentLevel = l, T.value = l === -1);
+  }
+  function j(l) {
+    p && (p.volume = Math.max(0, Math.min(1, l)));
+  }
+  function W() {
+    p && (p.muted = !p.muted);
+  }
+  function B() {
+    D && (clearInterval(D), D = null), E && (E.destroy(), E = null), p = null, d.value = "idle", y.value = [], A.value = -1;
+  }
+  return U(() => {
+    B();
+  }), {
+    state: d,
+    isPlaying: a,
+    isBuffering: m,
+    levels: y,
+    currentLevel: A,
+    autoLevelEnabled: T,
+    currentTime: f,
+    duration: i,
+    buffered: w,
+    volume: S,
+    muted: R,
+    stats: L,
+    error: I,
+    isSupported: F,
+    attach: r,
+    detach: o,
+    load: c,
+    play: M,
+    pause: C,
+    stop: P,
+    seek: x,
+    setLevel: $,
+    setVolume: j,
+    toggleMute: W,
+    destroy: B
+  };
+}
+const Y = {
+  iceServers: [{ urls: "stun:stun.l.google.com:19302" }],
+  iceGatheringTimeout: 2e3,
+  enablePointCloud: !0,
+  enableDetections: !0,
+  autoReconnect: !0,
+  maxReconnectAttempts: 5,
+  reconnectDelay: 3e3
+};
+function Z(N, e) {
+  return new Promise((n) => {
+    if (N.iceGatheringState === "complete") {
+      n();
+      return;
+    }
+    const d = setTimeout(() => {
+      n();
+    }, e);
+    N.onicegatheringstatechange = () => {
+      N.iceGatheringState === "complete" && (clearTimeout(d), n());
+    };
+  });
+}
+function fe(N, e = {}) {
+  const n = { ...Y, ...N }, d = v(!1), a = v("idle"), m = v(/* @__PURE__ */ new Map()), y = v(null), A = v(null), T = v([]), f = v(null);
+  let i = null, w = null, S = null, R = null, L = 0, I = null;
+  function F(r, o) {
+    if (!w || w.readyState !== "open") return;
+    const c = { type: "control", stream: r, enabled: o };
+    w.send(JSON.stringify(c));
+  }
+  function E(r, o) {
+    const c = m.value.get(r);
+    if (!c || c.readyState !== "open")
+      return console.warn(`[useWebRTC] Channel ${r} not available`), !1;
+    try {
+      return c.send(o), !0;
+    } catch (M) {
+      return console.error(`[useWebRTC] Send error on ${r}:`, M), !1;
+    }
+  }
+  function O(r) {
+    var o;
+    switch (m.value.set(r.label, r), (o = e.onDataChannel) == null || o.call(e, r), r.label) {
+      case "pointcloud":
+        p(r);
+        break;
+      case "pointcloud_b":
+      case "bbox":
+      case "bounding_boxes":
+      case "detections":
+        D(r);
+        break;
+    }
+  }
+  function p(r) {
+    S = r, S.binaryType = "arraybuffer", S.onopen = () => {
+      var o;
+      (o = e.onStatus) == null || o.call(e, "Pointcloud channel open"), n.enablePointCloud && F("pointcloud", !0);
+    }, S.onmessage = (o) => {
+      var c, M;
+      try {
+        let C = [];
+        if (o.data instanceof ArrayBuffer && o.data.byteLength > 0) {
+          const P = o.data;
+          (c = e.onPointCloudData) == null || c.call(e, P);
+          try {
+            const x = new TextDecoder().decode(P);
+            if (x.startsWith("[") || x.startsWith("{")) {
+              const $ = J(x);
+              $ && $.length > 0 && (C = $);
+            }
+          } catch {
+          }
+          C.length === 0 && (C = Q(P));
+        } else if (typeof o.data == "string") {
+          const P = J(o.data);
+          P && (C = P);
+        }
+        if (C.length > 0) {
+          const P = {
+            points: C,
+            timestamp: Date.now(),
+            format: "parsed"
+          };
+          y.value = P, (M = e.onPointCloudFrame) == null || M.call(e, P);
+        }
+      } catch (C) {
+        console.error("[useWebRTC] Error parsing pointcloud data:", C);
+      }
+    }, S.onerror = (o) => {
+      var c;
+      console.error("[useWebRTC] Pointcloud channel error:", o), (c = e.onStatus) == null || c.call(e, "Pointcloud channel error");
+    }, S.onclose = () => {
+      var o;
+      (o = e.onStatus) == null || o.call(e, "Pointcloud channel closed");
+    };
+  }
+  function D(r) {
+    R = r, R.binaryType = "arraybuffer", R.onopen = () => {
+      var o;
+      (o = e.onStatus) == null || o.call(e, "BBox channel open"), n.enableDetections && F("bbox", !0);
+    }, R.onmessage = (o) => {
+      var c, M;
+      try {
+        let C;
+        if (typeof o.data == "string")
+          C = JSON.parse(o.data);
+        else if (o.data instanceof ArrayBuffer) {
+          const P = new TextDecoder().decode(o.data);
+          try {
+            C = JSON.parse(P);
+          } catch {
+            return;
+          }
+        } else
+          return;
+        if (Array.isArray(C)) {
+          let P;
+          if (C.length > 0 && Array.isArray(C[0]) && typeof C[0][0] == "number" ? P = K(C) : P = V(C), P.length > 0) {
+            T.value = P, (c = e.onBoundingBoxData) == null || c.call(e, P);
+            const x = q(P);
+            A.value = x, (M = e.onDetectionFrame) == null || M.call(e, x);
+          }
+        }
+      } catch (C) {
+        console.error("[useWebRTC] Error parsing bbox data:", C);
+      }
+    }, R.onerror = (o) => {
+      console.error("[useWebRTC] BBox channel error:", o);
+    }, R.onclose = () => {
+      var o;
+      (o = e.onStatus) == null || o.call(e, "BBox channel closed");
+    };
+  }
+  async function u() {
+    var r, o, c, M, C, P;
+    if (!d.value) {
+      (r = e.onStatus) == null || r.call(e, "Creating WebRTC connection..."), a.value = "connecting", f.value = null;
+      try {
+        i && (i.close(), i = null), i = new RTCPeerConnection({
+          iceServers: n.iceServers
+        }), i.onconnectionstatechange = () => {
+          var l, g;
+          const B = (i == null ? void 0 : i.connectionState) ?? "closed";
+          if (a.value = B, (l = e.onConnectionState) == null || l.call(e, B), B === "failed" || B === "disconnected") {
+            const _ = new Error(`Connection ${B}`);
+            f.value = _, (g = e.onError) == null || g.call(e, _), n.autoReconnect && L < n.maxReconnectAttempts && t();
+          }
+          B === "connected" && (L = 0);
+        }, i.ondatachannel = (B) => {
+          O(B.channel);
+        }, w = i.createDataChannel("control"), w.onopen = () => {
+          var B;
+          (B = e.onStatus) == null || B.call(e, "Control channel open"), m.value.set("control", w);
+        };
+        const x = await i.createOffer();
+        await i.setLocalDescription(x), await Z(i, n.iceGatheringTimeout);
+        const $ = ((o = i.localDescription) == null ? void 0 : o.sdp) ?? "";
+        if (!$) throw new Error("Empty SDP offer");
+        const j = await fetch(n.signalingUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ offer: $ })
+        });
+        if (!j.ok)
+          throw new Error(`Signaling failed: HTTP ${j.status}`);
+        const W = await j.json();
+        if (!W.answer)
+          throw new Error("No answer SDP in response");
+        await i.setRemoteDescription({ type: "answer", sdp: W.answer }), d.value = !0, (c = e.onStatus) == null || c.call(e, "Connected, waiting for data..."), (M = e.onConnectionState) == null || M.call(e, i.connectionState);
+      } catch (x) {
+        const $ = x instanceof Error ? x : new Error(String(x));
+        f.value = $, a.value = "error", (C = e.onStatus) == null || C.call(e, `Error: ${$.message}`), (P = e.onError) == null || P.call(e, $), h(), n.autoReconnect && L < n.maxReconnectAttempts && t();
+      }
+    }
+  }
+  function h() {
+    var r, o;
+    d.value = !1, a.value = "closed", (r = e.onStatus) == null || r.call(e, "Stopped"), (o = e.onConnectionState) == null || o.call(e, "closed"), I && (clearTimeout(I), I = null), m.value.forEach((c) => c.close()), m.value.clear(), w = null, S = null, R = null, i && (i.close(), i = null);
+  }
+  function t() {
+    var r;
+    I || (L++, (r = e.onStatus) == null || r.call(
+      e,
+      `Reconnecting in ${n.reconnectDelay / 1e3}s (attempt ${L}/${n.maxReconnectAttempts})...`
+    ), I = setTimeout(() => {
+      I = null, u();
+    }, n.reconnectDelay));
+  }
+  function s() {
+    return i;
+  }
+  return U(() => {
+    h();
+  }), {
+    isRunning: d,
+    connectionState: a,
+    dataChannels: m,
+    lastPointCloudFrame: y,
+    lastDetectionFrame: A,
+    lastBoundingBoxes: T,
+    error: f,
+    start: u,
+    stop: h,
+    sendControl: F,
+    sendOnChannel: E,
+    getPeerConnection: s
+  };
+}
+const b = {
+  transform: (N) => N,
+  filter: () => !0,
+  bufferSize: 100,
+  throttleMs: 0,
+  flushInterval: 0,
+  deduplicate: !1,
+  dedupeKey: null,
+  deduplicateKey: null,
+  batchSize: 0,
+  batchTimeoutMs: 0
+};
+function ae(N = {}, e = {}) {
+  const n = { ...b, ...N }, d = v(null), a = v([]), m = v(n.bufferSize), y = v(!1), A = v(0), T = v(0), f = v(null), i = /* @__PURE__ */ new Set(), w = /* @__PURE__ */ new Set();
+  let S = 0, R = null, L = null, I = [];
+  function F() {
+    R || (R = setInterval(() => {
+      A.value = S, S = 0;
+    }, 1e3));
+  }
+  function E() {
+    R && (clearInterval(R), R = null), A.value = 0;
+  }
+  function O() {
+    !n.flushInterval || n.flushInterval <= 0 || L || (L = setInterval(() => {
+      var o;
+      I.length > 0 && ((o = e.onBatch) == null || o.call(e, I), I = []);
+    }, n.flushInterval));
+  }
+  function p() {
+    var o;
+    L && (clearInterval(L), L = null), I.length > 0 && ((o = e.onBatch) == null || o.call(e, I), I = []);
+  }
+  function D() {
+    y.value || (y.value = !0, F(), O());
+  }
+  function u() {
+    y.value = !1, E(), p();
+  }
+  function h(o) {
+    var c, M, C;
+    if (y.value)
+      try {
+        const P = n.transform(o);
+        if (n.filter && !n.filter(P))
+          return;
+        if (n.deduplicate) {
+          let x;
+          const $ = n.dedupeKey || n.deduplicateKey;
+          if (typeof $ == "function" ? x = $(P) : typeof $ == "string" && (x = String(P[$])), x !== void 0 && w.has(x))
+            return;
+          x !== void 0 && (w.add(x), w.size > n.bufferSize * 2 && Array.from(w).slice(0, n.bufferSize).forEach((W) => w.delete(W)));
+        }
+        d.value = P, T.value++, S++, a.value = [...a.value, P].slice(-n.bufferSize), a.value.length >= n.bufferSize && ((c = e.onBufferFull) == null || c.call(e)), n.flushInterval && n.flushInterval > 0 && I.push(P), (M = e.onData) == null || M.call(e, P), i.forEach((x) => x(P));
+      } catch (P) {
+        const x = P instanceof Error ? P : new Error(String(P));
+        f.value = x, (C = e.onError) == null || C.call(e, x);
+      }
+  }
+  function t() {
+    d.value = null, a.value = [], w.clear(), T.value = 0, I = [];
+  }
+  function s() {
+    return [...a.value];
+  }
+  function r(o) {
+    return i.add(o), () => {
+      i.delete(o);
+    };
+  }
+  return U(() => {
+    u(), i.clear(), t();
+  }), {
+    data: d,
+    buffer: a,
+    bufferSize: m,
+    isStreaming: y,
+    itemsPerSecond: A,
+    totalItems: T,
+    error: f,
+    start: D,
+    stop: u,
+    push: h,
+    clear: t,
+    getBuffer: s,
+    subscribe: r
+  };
+}
+const k = {
+  method: "GET",
+  headers: {},
+  credentials: "same-origin",
+  autoConnect: !0,
+  autoReconnect: !0,
+  maxReconnectAttempts: 5,
+  reconnectDelay: 1e3,
+  maxReconnectDelay: 3e4,
+  ndjson: !0
+};
+function de(N, e = {}) {
+  const n = { ...k, ...N }, d = v(!1), a = v(!1), m = v("disconnected"), y = v(null), A = v([]), T = v(0), f = v(null), i = v(0);
+  let w = null, S = !1;
+  const R = G({
+    maxAttempts: n.maxReconnectAttempts,
+    delay: n.reconnectDelay,
+    delayMax: n.maxReconnectDelay,
+    onAttempt: (p, D) => {
+      var u;
+      i.value = p, m.value = "reconnecting", (u = e.onReconnecting) == null || u.call(e, p, D);
+    },
+    onSuccess: () => {
+      var p;
+      i.value = 0, (p = e.onReconnected) == null || p.call(e);
+    },
+    onFailure: () => {
+      var p;
+      m.value = "failed", (p = e.onReconnectFailed) == null || p.call(e);
+    }
+  });
+  function L(p) {
+    const D = p.trim();
+    if (!D) return null;
+    try {
+      return JSON.parse(D);
+    } catch {
+      return D;
+    }
+  }
+  function I(p) {
+    var u, h;
+    if (!p) return;
+    let D;
+    if (n.parseChunk)
+      D = n.parseChunk(p);
+    else if (n.ndjson) {
+      const t = p.split(`
+`);
+      for (const s of t) {
+        const r = L(s);
+        r !== null && (y.value = r, A.value.push(r), (u = e.onChunk) == null || u.call(e, r, s));
+      }
+      return;
+    } else
+      D = p;
+    D != null && (y.value = D, A.value.push(D), (h = e.onChunk) == null || h.call(e, D, p));
+  }
+  async function F() {
+    var p, D, u, h;
+    if (!a.value) {
+      S = !1, m.value = "connecting", f.value = null, w = new AbortController();
+      try {
+        const t = {
+          method: n.method,
+          headers: {
+            Accept: "text/event-stream, application/x-ndjson, application/json, text/plain",
+            ...n.headers
+          },
+          credentials: n.credentials,
+          signal: w.signal
+        };
+        n.body && ["POST", "PUT", "PATCH"].includes(n.method) && (t.body = typeof n.body == "string" ? n.body : JSON.stringify(n.body));
+        const s = await fetch(n.url, t);
+        if (!s.ok)
+          throw new Error(`HTTP ${s.status}: ${s.statusText}`);
+        if (!s.body)
+          throw new Error("Response body is not readable");
+        d.value = !0, a.value = !0, m.value = "connected", (p = e.onOpen) == null || p.call(e);
+        const r = s.body.getReader(), o = new TextDecoder();
+        let c = "";
+        for (; ; ) {
+          const { done: M, value: C } = await r.read();
+          if (M) {
+            c && I(c);
+            break;
+          }
+          const P = o.decode(C, { stream: !0 });
+          T.value += C.length, (D = e.onProgress) == null || D.call(e, T.value), c += P;
+          const x = c.lastIndexOf(`
+`);
+          if (x !== -1) {
+            const $ = c.slice(0, x);
+            c = c.slice(x + 1), I($);
+          }
+        }
+        a.value = !1, m.value = "disconnected", (u = e.onComplete) == null || u.call(e);
+      } catch (t) {
+        if (t.name === "AbortError")
+          return;
+        f.value = t, d.value = !1, a.value = !1, m.value = "error", (h = e.onError) == null || h.call(e, t), !S && n.autoReconnect && R.scheduleReconnect(async () => {
+          try {
+            return await F(), !0;
+          } catch {
+            return !1;
+          }
+        });
+      }
+    }
+  }
+  function E() {
+    S = !0, R.cancel(), w && (w.abort(), w = null), d.value = !1, a.value = !1, m.value = "disconnected";
+  }
+  function O() {
+    A.value = [], y.value = null, T.value = 0;
+  }
+  return n.autoConnect && F(), U(() => {
+    E();
+  }), {
+    isConnected: d,
+    isStreaming: a,
+    connectionState: m,
+    lastChunk: y,
+    chunks: A,
+    bytesReceived: T,
+    error: f,
+    reconnectAttempts: i,
+    connect: F,
+    disconnect: E,
+    clearChunks: O
+  };
+}
+const ee = {
+  broadcaster: "pusher",
+  wsPort: 6001,
+  wssPort: 6001,
+  forceTLS: !1,
+  disableStats: !1,
+  cluster: "mt1",
+  authEndpoint: "/broadcasting/auth",
+  authHeaders: {},
+  auth: { headers: {} },
+  enabledTransports: ["ws", "wss"],
+  options: {}
+};
+function ve(N = {}, e = {}, n) {
+  const d = { ...ee, ...N }, a = v(!1), m = v("idle"), y = v(null), A = v([]), T = v(null);
+  let f = n || null;
+  const i = !!n;
+  async function w() {
+    if (f) return f;
+    try {
+      const [{ default: t }, { default: s }] = await Promise.all([
+        import("laravel-echo"),
+        import("pusher-js")
+      ]);
+      return window.Pusher = s, f = new t({
+        broadcaster: d.broadcaster || "pusher",
+        key: d.key,
+        wsHost: d.wsHost,
+        wsPort: d.wsPort,
+        wssPort: d.wssPort,
+        forceTLS: d.forceTLS,
+        cluster: d.cluster,
+        authEndpoint: d.authEndpoint,
+        auth: {
+          headers: d.authHeaders
+        },
+        enabledTransports: d.enabledTransports,
+        disableStats: !0,
+        ...d.options
+      }), f;
+    } catch {
+      throw new Error(
+        "laravel-echo and/or pusher-js not installed. Run: npm install laravel-echo pusher-js"
+      );
+    }
+  }
+  function S(t, s) {
+    var o;
+    A.value.find((c) => c.name === t) || (A.value = [
+      ...A.value,
+      { name: t, type: s, subscribedAt: /* @__PURE__ */ new Date() }
+    ], (o = e.onSubscribed) == null || o.call(e, t));
+  }
+  function R(t) {
+    A.value = A.value.filter((s) => s.name !== t);
+  }
+  async function L() {
+    var t;
+    m.value = "connecting", T.value = null;
+    try {
+      const s = await w(), r = s.connector, o = (r == null ? void 0 : r.pusher) ?? (r == null ? void 0 : r.socket) ?? s.client;
+      if (!o || !o.connection) {
+        a.value = !0, m.value = "connected", (t = e.onConnected) == null || t.call(e, "");
+        return;
+      }
+      return new Promise((c, M) => {
+        var j;
+        let C = !1;
+        const x = setTimeout(() => {
+          var W;
+          C || (C = !0, o.connection.state === "connected" && (a.value = !0, m.value = "connected", y.value = o.connection.socket_id || null, (W = e.onConnected) == null || W.call(e, y.value || "")), c());
+        }, 15e3);
+        o.connection.bind(
+          "state_change",
+          (W) => {
+            var B, l, g;
+            if (W.current === "connected")
+              a.value = !0, m.value = "connected", y.value = o.connection.socket_id || null, (B = e.onConnected) == null || B.call(e, y.value || ""), C || (C = !0, clearTimeout(x), c());
+            else if (W.current === "disconnected" || W.current === "unavailable")
+              a.value = !1, m.value = "disconnected", y.value = null, (l = e.onDisconnected) == null || l.call(e), C || (C = !0, clearTimeout(x), c());
+            else if (W.current === "failed") {
+              a.value = !1, m.value = "error";
+              const _ = new Error("Pusher connection failed");
+              T.value = _, (g = e.onError) == null || g.call(e, _), C || (C = !0, clearTimeout(x), c());
+            }
+          }
+        ), o.connection.bind("error", (W) => {
+          var l, g;
+          const B = W instanceof Error ? W : new Error(
+            typeof W == "object" && W !== null ? ((l = W.message) == null ? void 0 : l.toString()) || JSON.stringify(W) : String(W)
+          );
+          T.value = B, m.value = "error", (g = e.onError) == null || g.call(e, B);
+        }), o.connection.state === "connected" && (a.value = !0, m.value = "connected", y.value = o.connection.socket_id || null, (j = e.onConnected) == null || j.call(e, y.value || ""), C || (C = !0, clearTimeout(x), c()));
+      });
+    } catch (s) {
+      const r = s instanceof Error ? s : new Error(String(s));
+      throw T.value = r, m.value = "error", r;
+    }
+  }
+  function I() {
+    f && !i && (f.disconnect(), f = null), a.value = !1, m.value = "closed", y.value = null, A.value = [];
+  }
+  function F(t, s) {
+    return {
+      listen(r, o) {
+        return t.listen(r, o), this;
+      },
+      stopListening(r, o) {
+        return t.stopListening(r, o), this;
+      },
+      listenForWhisper(r, o) {
+        return t.listenForWhisper(r, o), this;
+      },
+      whisper(r, o) {
+        return t.whisper(r, o), this;
+      }
+    };
+  }
+  function E(t, s) {
+    return {
+      ...F(t),
+      here(o) {
+        return t.here(o), this;
+      },
+      joining(o) {
+        return t.joining((c) => {
+          var M;
+          (M = e.onMemberJoined) == null || M.call(e, s, c), o(c);
+        }), this;
+      },
+      leaving(o) {
+        return t.leaving((c) => {
+          var M;
+          (M = e.onMemberLeft) == null || M.call(e, s, c), o(c);
+        }), this;
+      }
+    };
+  }
+  function O(t) {
+    if (!f)
+      throw new Error("Echo not connected. Call connect() first.");
+    const s = f.channel(t);
+    return S(t, "public"), F(s);
+  }
+  function p(t) {
+    if (!f)
+      throw new Error("Echo not connected. Call connect() first.");
+    const s = f.private(t);
+    return S(`private-${t}`, "private"), F(s);
+  }
+  function D(t) {
+    if (!f)
+      throw new Error("Echo not connected. Call connect() first.");
+    const s = f.join(t);
+    return S(`presence-${t}`, "presence"), E(s, t);
+  }
+  function u(t) {
+    f && (f.leaveChannel(t), R(t), R(`private-${t}`), R(`presence-${t}`));
+  }
+  function h() {
+    [...A.value.map((s) => s.name)].forEach((s) => u(s));
+  }
+  return U(() => {
+    I();
+  }), {
+    isConnected: a,
+    connectionState: m,
+    socketId: y,
+    channels: A,
+    error: T,
+    connect: L,
+    disconnect: I,
+    channel: O,
+    privateChannel: p,
+    presenceChannel: D,
+    leave: u,
+    leaveAll: h
+  };
+}
+const ne = {
+  method: "GET",
+  headers: {},
+  credentials: "same-origin",
+  interval: 0,
+  timeout: 3e4,
+  autoStart: !0,
+  autoRestart: !0,
+  maxRestartAttempts: 5,
+  restartDelay: 1e3,
+  maxRestartDelay: 3e4,
+  includeTimestamp: !1,
+  timestampParam: "since"
+};
+function pe(N, e = {}) {
+  const n = { ...ne, ...N }, d = v(!1), a = v("disconnected"), m = v(null), y = v([]), A = v(0), T = v(null), f = v(0);
+  let i = null, w = null, S = !1, R = null;
+  const L = G({
+    maxAttempts: n.maxRestartAttempts,
+    delay: n.restartDelay,
+    delayMax: n.maxRestartDelay,
+    onAttempt: (t, s) => {
+      var r;
+      f.value = t, a.value = "reconnecting", (r = e.onRestarting) == null || r.call(e, t, s);
+    },
+    onSuccess: () => {
+      var t;
+      f.value = 0, (t = e.onRestarted) == null || t.call(e);
+    },
+    onFailure: () => {
+      var t;
+      a.value = "failed", (t = e.onRestartFailed) == null || t.call(e);
+    }
+  });
+  function I() {
+    if (!n.includeTimestamp || !R)
+      return n.url;
+    const t = new URL(n.url);
+    return t.searchParams.set(n.timestampParam, R.toString()), t.toString();
+  }
+  async function F() {
+    i = new AbortController();
+    const t = setTimeout(() => {
+      i == null || i.abort();
+    }, n.timeout);
+    try {
+      const s = {
+        method: n.method,
+        headers: {
+          Accept: "application/json",
+          ...n.headers
+        },
+        credentials: n.credentials,
+        signal: i.signal
+      };
+      n.body && n.method === "POST" && (s.body = typeof n.body == "string" ? n.body : JSON.stringify(n.body), s.headers = {
+        ...s.headers,
+        "Content-Type": "application/json"
+      });
+      const r = await fetch(I(), s);
+      if (clearTimeout(t), !r.ok)
+        throw new Error(`HTTP ${r.status}: ${r.statusText}`);
+      return await r.json();
+    } catch (s) {
+      throw clearTimeout(t), s;
+    }
+  }
+  async function E() {
+    var t, s;
+    for (; d.value && !S; )
+      try {
+        A.value++;
+        const r = await F();
+        R = Date.now(), m.value = r, y.value.push(r), T.value = null, (t = e.onData) == null || t.call(e, r), n.interval > 0 && d.value && !S && await new Promise((o) => {
+          w = setTimeout(o, n.interval);
+        });
+      } catch (r) {
+        if (r.name === "AbortError") {
+          if (S)
+            break;
+          continue;
+        }
+        if (T.value = r, (s = e.onError) == null || s.call(e, r), !S && n.autoRestart) {
+          d.value = !1, a.value = "error", L.scheduleReconnect(async () => {
+            try {
+              return await O(), !0;
+            } catch {
+              return !1;
+            }
+          });
+          return;
+        }
+        break;
+      }
+    S || (d.value = !1, a.value = "disconnected");
+  }
+  async function O() {
+    var t;
+    d.value || (S = !1, d.value = !0, a.value = "connected", T.value = null, (t = e.onStart) == null || t.call(e), E());
+  }
+  function p() {
+    O();
+  }
+  function D() {
+    var t;
+    S = !0, L.cancel(), w && (clearTimeout(w), w = null), i && (i.abort(), i = null), d.value = !1, a.value = "disconnected", (t = e.onStop) == null || t.call(e);
+  }
+  async function u() {
+    var s, r;
+    const t = d.value;
+    w && (clearTimeout(w), w = null);
+    try {
+      const o = await F();
+      R = Date.now(), m.value = o, y.value.push(o), (s = e.onData) == null || s.call(e, o);
+    } catch (o) {
+      o.name !== "AbortError" && (T.value = o, (r = e.onError) == null || r.call(e, o));
+    }
+    t && !S && E();
+  }
+  function h() {
+    y.value = [], m.value = null, A.value = 0;
+  }
+  return n.autoStart && p(), U(() => {
+    D();
+  }), {
+    isPolling: d,
+    connectionState: a,
+    lastData: m,
+    dataHistory: y,
+    requestCount: A,
+    error: T,
+    restartAttempts: f,
+    start: p,
+    stop: D,
+    poll: u,
+    clearHistory: h
+  };
+}
+const te = {
+  path: "/socket.io",
+  namespace: "/",
+  reconnection: !0,
+  reconnectionAttempts: 5,
+  reconnectionDelay: 1e3,
+  transports: ["websocket", "polling"],
+  extraHeaders: {},
+  options: {},
+  autoConnect: !0,
+  autoReconnect: !0,
+  maxReconnectAttempts: 5,
+  reconnectDelay: 1e3
+};
+function he(N, e = {}) {
+  const n = { ...te, ...N }, d = v(!1), a = v("idle"), m = v(null), y = v([]), A = v(0), T = v(null);
+  let f = null, i = null;
+  async function w() {
+    if (i) return i;
+    try {
+      const u = await import("socket.io-client");
+      return i = u.io || u.default, i;
+    } catch {
+      throw new Error(
+        "socket.io-client is not installed. Run: npm install socket.io-client"
+      );
+    }
+  }
+  async function S() {
+    if (!(f != null && f.connected)) {
+      a.value = "connecting", T.value = null;
+      try {
+        const u = await w();
+        if (!u)
+          throw new Error("Socket.IO client not available");
+        const h = n.namespace === "/" ? n.url : `${n.url}${n.namespace}`;
+        f = u(h, {
+          path: n.path,
+          auth: n.auth,
+          reconnection: n.reconnection,
+          reconnectionAttempts: n.reconnectionAttempts,
+          reconnectionDelay: n.reconnectionDelay,
+          transports: n.transports,
+          extraHeaders: n.extraHeaders
+        }), await new Promise((t, s) => {
+          f.on("connect", () => {
+            var r;
+            d.value = !0, a.value = "connected", m.value = (f == null ? void 0 : f.id) || null, A.value = 0, (r = e.onConnect) == null || r.call(e, m.value || ""), t();
+          }), f.on("disconnect", (r) => {
+            var o;
+            d.value = !1, a.value = "disconnected", m.value = null, (o = e.onDisconnect) == null || o.call(e, r);
+          }), f.on("connect_error", (r) => {
+            var o;
+            T.value = r, a.value = "error", (o = e.onError) == null || o.call(e, r), s(r);
+          }), f.io.on("reconnect_attempt", (r) => {
+            var o;
+            A.value = r, a.value = "reconnecting", (o = e.onReconnecting) == null || o.call(e, r);
+          }), f.io.on("reconnect_failed", () => {
+            var r;
+            a.value = "error", (r = e.onReconnectFailed) == null || r.call(e);
+          }), f.connect();
+        });
+      } catch (u) {
+        const h = u instanceof Error ? u : new Error(String(u));
+        throw T.value = h, a.value = "error", h;
+      }
+    }
+  }
+  function R() {
+    f && (f.disconnect(), f = null), d.value = !1, a.value = "closed", m.value = null, y.value = [];
+  }
+  function L(u, h) {
+    if (!(f != null && f.connected)) {
+      console.warn("[useSocketIO] Cannot emit: Socket is not connected");
+      return;
+    }
+    f.emit(u, h);
+  }
+  function I(u, h, t = 5e3) {
+    return new Promise((s, r) => {
+      if (!(f != null && f.connected)) {
+        r(new Error("Socket is not connected"));
+        return;
+      }
+      const o = setTimeout(() => {
+        r(new Error(`Emit timeout for event: ${u}`));
+      }, t);
+      f.emit(u, h, (c) => {
+        clearTimeout(o), s(c);
+      });
+    });
+  }
+  function F(u, h) {
+    if (!f) {
+      console.warn("[useSocketIO] Cannot listen: Socket not initialized");
+      return;
+    }
+    f.on(u, h);
+  }
+  function E(u, h) {
+    f && f.off(u, h);
+  }
+  async function O(u) {
+    if (!(f != null && f.connected))
+      throw new Error("Socket is not connected");
+    return new Promise((h, t) => {
+      let s = !1;
+      f.emit("join", u, (r) => {
+        if (!s)
+          if (s = !0, r != null && r.error)
+            t(new Error(r.error));
+          else {
+            const o = {
+              name: u,
+              joinedAt: /* @__PURE__ */ new Date()
+            };
+            y.value = [...y.value, o], h();
+          }
+      }), setTimeout(() => {
+        if (s) return;
+        s = !0;
+        const r = {
+          name: u,
+          joinedAt: /* @__PURE__ */ new Date()
+        };
+        y.value = [...y.value, r], h();
+      }, 1e3);
+    });
+  }
+  async function p(u) {
+    if (f != null && f.connected)
+      return new Promise((h) => {
+        let t = !1;
+        f.emit("leave", u, () => {
+          t || (t = !0, y.value = y.value.filter((s) => s.name !== u), h());
+        }), setTimeout(() => {
+          t || (t = !0, y.value = y.value.filter((s) => s.name !== u), h());
+        }, 1e3);
+      });
+  }
+  function D() {
+    return f;
+  }
+  return U(() => {
+    R();
+  }), {
+    isConnected: d,
+    connectionState: a,
+    socketId: m,
+    rooms: y,
+    reconnectAttempts: A,
+    error: T,
+    connect: S,
+    disconnect: R,
+    emit: L,
+    emitWithAck: I,
+    on: F,
+    off: E,
+    join: O,
+    leave: p,
+    getSocket: D
+  };
+}
+const oe = {
+  withCredentials: !1,
+  autoConnect: !0,
+  autoReconnect: !0,
+  maxReconnectAttempts: 5,
+  reconnectDelay: 1e3,
+  maxReconnectDelay: 3e4,
+  eventTypes: ["message"]
+};
+function me(N, e = {}) {
+  const n = { ...oe, ...N }, d = v(!1), a = v("disconnected"), m = v(null), y = v(""), A = v(null), T = v(null), f = v(0);
+  let i = null, w = !1;
+  const S = /* @__PURE__ */ new Map(), R = G({
+    maxAttempts: n.maxReconnectAttempts,
+    delay: n.reconnectDelay,
+    delayMax: n.maxReconnectDelay,
+    onAttempt: (u, h) => {
+      var t;
+      f.value = u, a.value = "reconnecting", (t = e.onReconnecting) == null || t.call(e, u, h);
+    },
+    onSuccess: () => {
+      var u;
+      f.value = 0, (u = e.onReconnected) == null || u.call(e);
+    },
+    onFailure: () => {
+      var u;
+      a.value = "failed", (u = e.onReconnectFailed) == null || u.call(e);
+    }
+  });
+  function L(u) {
+    var h, t;
+    try {
+      let s;
+      try {
+        s = JSON.parse(u.data);
+      } catch {
+        s = u.data;
+      }
+      m.value = s, y.value = u.type || "message", A.value = u.lastEventId || null, (h = e.onMessage) == null || h.call(e, s, u), (t = e.onEvent) == null || t.call(e, u.type || "message", s, u);
+      const r = S.get(u.type || "message");
+      r && r.forEach((o) => o(s));
+    } catch (s) {
+      console.error("[useSSE] Error processing message:", s);
+    }
+  }
+  function I() {
+    var u;
+    d.value = !0, a.value = "connected", T.value = null, R.reset(), (u = e.onOpen) == null || u.call(e);
+  }
+  function F(u) {
+    var h;
+    T.value = u, (h = e.onError) == null || h.call(e, u), (i == null ? void 0 : i.readyState) === EventSource.CLOSED && (d.value = !1, a.value = "error", !w && n.autoReconnect && R.scheduleReconnect(async () => {
+      try {
+        return E(), !0;
+      } catch {
+        return !1;
+      }
+    }));
+  }
+  function E() {
+    var u;
+    if (!(i && i.readyState !== EventSource.CLOSED)) {
+      w = !1, a.value = "connecting";
+      try {
+        i = new EventSource(n.url, {
+          withCredentials: n.withCredentials
+        }), i.onmessage = L, i.onopen = I, i.onerror = F, n.eventTypes.forEach((h) => {
+          h !== "message" && i && i.addEventListener(
+            h,
+            L
+          );
+        });
+      } catch (h) {
+        a.value = "error", T.value = h, (u = e.onError) == null || u.call(e, h);
+      }
+    }
+  }
+  function O() {
+    w = !0, R.cancel(), i && (i.close(), i = null), d.value = !1, a.value = "disconnected";
+  }
+  function p(u, h) {
+    S.has(u) || (S.set(u, /* @__PURE__ */ new Set()), i && u !== "message" && i.addEventListener(u, L)), S.get(u).add(h);
+  }
+  function D(u, h) {
+    const t = S.get(u);
+    t && (t.delete(h), t.size === 0 && S.delete(u));
+  }
+  return n.autoConnect && E(), U(() => {
+    O(), S.clear();
+  }), {
+    isConnected: d,
+    connectionState: a,
+    lastMessage: m,
+    lastEventType: y,
+    lastEventId: A,
+    error: T,
+    reconnectAttempts: f,
+    connect: E,
+    disconnect: O,
+    addEventListener: p,
+    removeEventListener: D
+  };
+}
+const re = {
+  autoConnect: !0,
+  autoReconnect: !0,
+  maxReconnectAttempts: 5,
+  reconnectDelay: 1e3,
+  maxReconnectDelay: 3e4,
+  heartbeatInterval: 0,
+  heartbeatMessage: "",
+  binaryType: "arraybuffer"
+};
+function le(N, e = {}) {
+  const n = { ...re, ...N }, d = v(!1), a = v("idle"), m = v(WebSocket.CLOSED), y = v(0), A = v(null), T = v(null), f = v(0);
+  let i = null, w = null, S = !1;
+  const R = G({
+    maxAttempts: n.maxReconnectAttempts,
+    delay: n.reconnectDelay,
+    delayMax: n.maxReconnectDelay,
+    onAttempt: (u, h) => {
+      var t;
+      f.value = u, a.value = "reconnecting", (t = e.onReconnecting) == null || t.call(e, u, h);
+    },
+    onSuccess: () => {
+      var u;
+      f.value = 0, (u = e.onReconnected) == null || u.call(e);
+    },
+    onFailure: () => {
+      var u;
+      a.value = "error", (u = e.onReconnectFailed) == null || u.call(e);
+    }
+  });
+  function L() {
+    !n.heartbeatInterval || n.heartbeatInterval <= 0 || (w = setInterval(() => {
+      if (i && i.readyState === WebSocket.OPEN) {
+        const u = typeof n.heartbeatMessage == "function" ? n.heartbeatMessage() : n.heartbeatMessage || JSON.stringify({ type: "ping", timestamp: Date.now() });
+        i.send(u);
+      }
+    }, n.heartbeatInterval));
+  }
+  function I() {
+    w && (clearInterval(w), w = null);
+  }
+  function F() {
+    i && (y.value = i.bufferedAmount);
+  }
+  async function E() {
+    if (!(i && i.readyState === WebSocket.OPEN))
+      return S = !1, a.value = "connecting", T.value = null, new Promise((u, h) => {
+        try {
+          i = new WebSocket(n.url, n.protocols), i.binaryType = n.binaryType, i.onopen = () => {
+            var t;
+            d.value = !0, a.value = "connected", m.value = WebSocket.OPEN, R.reset(), f.value = 0, L(), (t = e.onOpen) == null || t.call(e), u();
+          }, i.onclose = (t) => {
+            var s;
+            d.value = !1, a.value = "disconnected", m.value = WebSocket.CLOSED, I(), (s = e.onClose) == null || s.call(e, t.code, t.reason), !S && n.autoReconnect && R.scheduleReconnect(async () => {
+              try {
+                return await E(), !0;
+              } catch {
+                return !1;
+              }
+            });
+          }, i.onerror = (t) => {
+            var s;
+            T.value = t, a.value = "error", (s = e.onError) == null || s.call(e, t), h(t);
+          }, i.onmessage = (t) => {
+            var r;
+            A.value = t.data, F();
+            let s = t.data;
+            if (typeof t.data == "string")
+              try {
+                s = JSON.parse(t.data);
+              } catch {
+              }
+            (r = e.onMessage) == null || r.call(e, s, t);
+          }, m.value = i.readyState;
+        } catch (t) {
+          a.value = "error", h(t);
+        }
+      });
+  }
+  function O() {
+    S = !0, R.cancel(), I(), i && (i.close(1e3, "Client disconnect"), i = null), d.value = !1, a.value = "closed", m.value = WebSocket.CLOSED;
+  }
+  function p(u) {
+    if (!i || i.readyState !== WebSocket.OPEN)
+      return console.warn("[useWebSocket] Cannot send: WebSocket is not connected"), !1;
+    try {
+      return i.send(u), F(), !0;
+    } catch (h) {
+      return console.error("[useWebSocket] Send error:", h), !1;
+    }
+  }
+  function D(u) {
+    return p(JSON.stringify(u));
+  }
+  return U(() => {
+    O();
+  }), {
+    isConnected: d,
+    connectionState: a,
+    readyState: m,
+    bufferedAmount: y,
+    lastMessage: A,
+    error: T,
+    reconnectAttempts: f,
+    connect: E,
+    disconnect: O,
+    send: p,
+    sendJSON: D
+  };
+}
+export {
+  se as a,
+  de as b,
+  ve as c,
+  pe as d,
+  me as e,
+  he as f,
+  fe as g,
+  le as h,
+  ae as u
+};
+//# sourceMappingURL=useWebSocket-C3JPFBmy.js.map