vue-streaming 0.1.4 → 2.0.0

package/dist/WebSocketStream.vue_vue_type_script_setup_true_lang-C_F2vNNk.js

@@ -0,0 +1,1081 @@
+import { defineComponent as T, ref as H, watch as L, computed as O, onMounted as U, createElementBlock as b, openBlock as w, createElementVNode as _, createCommentVNode as E, normalizeClass as G, unref as t, toDisplayString as x, Fragment as J, renderList as Q, onUnmounted as Z, normalizeStyle as ee, renderSlot as M, toRefs as I } from "vue";
+import { a as te, g as ne, u as oe, b as se, c as re, d as ae, f as ie, e as le, h as ce } from "./useWebSocket-CrE6QkTW.js";
+const ue = { class: "hls-player" }, de = { class: "hls-player__video-container" }, pe = ["controls", "muted", "loop", "poster"], me = {
+  key: 0,
+  class: "hls-player__overlay"
+}, fe = {
+  key: 1,
+  class: "hls-player__overlay hls-player__overlay--error"
+}, ve = { class: "hls-player__error" }, _e = {
+  key: 0,
+  class: "hls-player__controls"
+}, ye = { class: "hls-player__quality" }, he = ["value"], ge = ["value"], be = { class: "hls-player__stats" }, we = { key: 0 }, Ce = /* @__PURE__ */ T({
+  __name: "HLSPlayer",
+  props: {
+    src: {},
+    autoPlay: { type: Boolean, default: !0 },
+    controls: { type: Boolean, default: !0 },
+    muted: { type: Boolean, default: !1 },
+    loop: { type: Boolean, default: !1 },
+    poster: {},
+    lowLatency: { type: Boolean, default: !1 },
+    startLevel: { default: -1 },
+    videoClass: {}
+  },
+  emits: ["ready", "play", "pause", "ended", "error", "levelChange", "timeUpdate", "stateChange"],
+  setup(C, { expose: R, emit: S }) {
+    const e = C, o = S, v = H(null), y = {
+      url: e.src,
+      autoPlay: e.autoPlay,
+      lowLatencyMode: e.lowLatency,
+      startLevel: e.startLevel
+    }, g = {
+      onManifestLoaded: (k) => {
+        o("ready");
+      },
+      onLevelSwitched: (k) => {
+        o("levelChange", k);
+      },
+      onPlaybackStarted: () => {
+        o("play");
+      },
+      onPlaybackEnded: () => {
+        o("ended");
+      },
+      onError: (k) => {
+        o("error", k);
+      }
+    }, {
+      state: i,
+      isPlaying: u,
+      isBuffering: f,
+      levels: r,
+      currentLevel: l,
+      autoLevelEnabled: d,
+      currentTime: p,
+      duration: c,
+      buffered: n,
+      volume: s,
+      muted: a,
+      stats: B,
+      error: m,
+      isSupported: h,
+      attach: A,
+      play: j,
+      pause: P,
+      stop: $,
+      seek: D,
+      setLevel: q,
+      setVolume: K,
+      toggleMute: X,
+      destroy: Y
+    } = te(y, g);
+    L(i, (k) => {
+      o("stateChange", k);
+    }), L(p, (k) => {
+      o("timeUpdate", k);
+    });
+    function N(k) {
+      if (!isFinite(k)) return "0:00";
+      const F = Math.floor(k / 60), z = Math.floor(k % 60);
+      return `${F}:${z.toString().padStart(2, "0")}`;
+    }
+    const V = O(() => l.value < 0 || l.value >= r.value.length ? null : r.value[l.value]);
+    return U(async () => {
+      if (v.value)
+        try {
+          await A(v.value);
+        } catch (k) {
+          console.error("[HLSPlayer] Failed to attach:", k);
+        }
+    }), L(
+      () => e.src,
+      async (k) => {
+        v.value && k && (Y(), y.url = k, await A(v.value));
+      }
+    ), R({
+      play: j,
+      pause: P,
+      stop: $,
+      seek: D,
+      setLevel: q,
+      setVolume: K,
+      toggleMute: X,
+      state: i,
+      levels: r,
+      currentLevel: l,
+      stats: B
+    }), (k, F) => (w(), b("div", ue, [
+      _("div", de, [
+        _("video", {
+          ref_key: "videoRef",
+          ref: v,
+          class: G(["hls-player__video", k.videoClass]),
+          controls: k.controls,
+          muted: k.muted,
+          loop: k.loop,
+          poster: k.poster,
+          playsinline: ""
+        }, null, 10, pe),
+        t(f) ? (w(), b("div", me, [...F[1] || (F[1] = [
+          _("div", { class: "hls-player__spinner" }, null, -1)
+        ])])) : E("", !0),
+        t(m) ? (w(), b("div", fe, [
+          _("div", ve, [
+            _("span", null, "⚠️ " + x(t(m).message), 1)
+          ])
+        ])) : E("", !0)
+      ]),
+      t(r).length > 1 ? (w(), b("div", _e, [
+        _("div", ye, [
+          F[3] || (F[3] = _("label", null, "Quality:", -1)),
+          _("select", {
+            value: t(l),
+            onChange: F[0] || (F[0] = (z) => t(q)(Number(z.target.value)))
+          }, [
+            F[2] || (F[2] = _("option", { value: -1 }, "Auto", -1)),
+            (w(!0), b(J, null, Q(t(r), (z) => (w(), b("option", {
+              key: z.index,
+              value: z.index
+            }, x(z.height) + "p (" + x(Math.round(z.bitrate / 1e3)) + "kbps) ", 9, ge))), 128))
+          ], 40, he)
+        ]),
+        _("div", be, [
+          V.value ? (w(), b("span", we, x(V.value.width) + "x" + x(V.value.height), 1)) : E("", !0),
+          _("span", null, x(Math.round(t(B).bandwidth / 1e6 * 10) / 10) + " Mbps", 1),
+          _("span", null, x(N(t(p))) + " / " + x(N(t(c))), 1)
+        ])
+      ])) : E("", !0)
+    ]));
+  }
+}), W = (C, R) => {
+  const S = C.__vccOpts || C;
+  for (const [e, o] of R)
+    S[e] = o;
+  return S;
+}, nt = /* @__PURE__ */ W(Ce, [["__scopeId", "data-v-b04c54da"]]), Se = { class: "pointcloud-viewer" }, Re = {
+  key: 0,
+  class: "pointcloud-viewer__overlay"
+}, ke = {
+  key: 1,
+  class: "pointcloud-viewer__overlay pointcloud-viewer__overlay--error"
+}, xe = { class: "pointcloud-viewer__stats" }, Pe = { key: 0 }, Be = /* @__PURE__ */ T({
+  __name: "PointCloudViewer",
+  props: {
+    points: {},
+    pointSize: { default: 0.02 },
+    pointColor: { default: 65280 },
+    usePointColors: { type: Boolean, default: !0 },
+    cameraPosition: { default: () => ({ x: 5, y: 5, z: 5 }) },
+    autoRotate: { type: Boolean, default: !1 },
+    autoRotateSpeed: { default: 1 },
+    backgroundColor: { default: 1973790 },
+    showAxes: { type: Boolean, default: !1 },
+    showGrid: { type: Boolean, default: !0 },
+    bounds: {}
+  },
+  emits: ["ready", "click", "error"],
+  setup(C, { expose: R, emit: S }) {
+    const e = C, o = S, v = H(null), y = H(!0), g = H(null);
+    let i = null, u = null, f = null, r = null, l = null, d = null, p = null;
+    async function c() {
+      if (v.value)
+        try {
+          i = await import("three");
+          const { OrbitControls: m } = await import("three/examples/jsm/controls/OrbitControls.js"), h = v.value, A = h.clientWidth, j = h.clientHeight;
+          if (u = new i.Scene(), u.background = new i.Color(e.backgroundColor), f = new i.PerspectiveCamera(75, A / j, 0.1, 1e3), f.position.set(
+            e.cameraPosition.x,
+            e.cameraPosition.y,
+            e.cameraPosition.z
+          ), r = new i.WebGLRenderer({ antialias: !0 }), r.setSize(A, j), r.setPixelRatio(window.devicePixelRatio), h.appendChild(r.domElement), l = new m(f, r.domElement), l.autoRotate = e.autoRotate, l.autoRotateSpeed = e.autoRotateSpeed, e.showGrid) {
+            const $ = new i.GridHelper(10, 10, 4473924, 3355443);
+            u.add($);
+          }
+          if (e.showAxes) {
+            const $ = new i.AxesHelper(5);
+            u.add($);
+          }
+          new ResizeObserver(() => {
+            if (!f || !r || !v.value) return;
+            const $ = v.value.clientWidth, D = v.value.clientHeight;
+            f.aspect = $ / D, f.updateProjectionMatrix(), r.setSize($, D);
+          }).observe(h), s(), y.value = !1, o("ready");
+        } catch (m) {
+          const h = m instanceof Error ? m : new Error(String(m));
+          g.value = h, o("error", h), console.error("[PointCloudViewer] Failed to initialize:", m);
+        }
+    }
+    function n() {
+      if (!i || !u || (d && (u.remove(d), d.geometry.dispose(), d.material.dispose(), d = null), e.points.length === 0)) return;
+      const m = new i.BufferGeometry(), h = new Float32Array(e.points.length * 3), A = new Float32Array(e.points.length * 3);
+      for (let P = 0; P < e.points.length; P++) {
+        const $ = e.points[P];
+        if (h[P * 3] = $.x, h[P * 3 + 1] = $.y, h[P * 3 + 2] = $.z, e.usePointColors && $.r !== void 0)
+          A[P * 3] = $.r, A[P * 3 + 1] = $.g ?? 0, A[P * 3 + 2] = $.b ?? 0;
+        else {
+          const D = new i.Color(e.pointColor);
+          A[P * 3] = D.r, A[P * 3 + 1] = D.g, A[P * 3 + 2] = D.b;
+        }
+      }
+      m.setAttribute("position", new i.BufferAttribute(h, 3)), m.setAttribute("color", new i.BufferAttribute(A, 3));
+      const j = new i.PointsMaterial({
+        size: e.pointSize,
+        vertexColors: !0,
+        sizeAttenuation: !0
+      });
+      if (d = new i.Points(m, j), u.add(d), e.bounds && f) {
+        const P = {
+          x: (e.bounds.min.x + e.bounds.max.x) / 2,
+          y: (e.bounds.min.y + e.bounds.max.y) / 2,
+          z: (e.bounds.min.z + e.bounds.max.z) / 2
+        }, $ = Math.max(
+          e.bounds.max.x - e.bounds.min.x,
+          e.bounds.max.y - e.bounds.min.y,
+          e.bounds.max.z - e.bounds.min.z
+        );
+        f.position.set(
+          P.x + $ * 1.5,
+          P.y + $ * 1.5,
+          P.z + $ * 1.5
+        ), f.lookAt(P.x, P.y, P.z);
+      }
+    }
+    function s() {
+      p = requestAnimationFrame(s), l && l.update(), r && u && f && r.render(u, f);
+    }
+    function a() {
+      p && (cancelAnimationFrame(p), p = null), d && u && (u.remove(d), d.geometry.dispose(), d.material.dispose()), l && l.dispose(), r && (r.dispose(), v.value && r.domElement.parentNode && v.value.removeChild(r.domElement)), u = null, f = null, r = null, l = null, d = null;
+    }
+    L(() => e.points, n, { deep: !0 }), L(
+      [() => e.pointSize, () => e.pointColor, () => e.usePointColors],
+      n
+    ), L(
+      () => e.autoRotate,
+      (m) => {
+        l && (l.autoRotate = m);
+      }
+    ), L(
+      () => e.autoRotateSpeed,
+      (m) => {
+        l && (l.autoRotateSpeed = m);
+      }
+    ), U(() => {
+      c();
+    }), Z(() => {
+      a();
+    });
+    const B = O(() => ({
+      pointCount: e.points.length,
+      hasColors: e.points.length > 0 && e.points[0].r !== void 0
+    }));
+    return R({
+      updatePointCloud: n,
+      stats: B
+    }), (m, h) => (w(), b("div", Se, [
+      _("div", {
+        ref_key: "containerRef",
+        ref: v,
+        class: "pointcloud-viewer__canvas"
+      }, null, 512),
+      y.value ? (w(), b("div", Re, [...h[0] || (h[0] = [
+        _("div", { class: "pointcloud-viewer__spinner" }, null, -1),
+        _("span", null, "Loading viewer...", -1)
+      ])])) : E("", !0),
+      g.value ? (w(), b("div", ke, [
+        _("span", null, "⚠️ " + x(g.value.message), 1),
+        h[1] || (h[1] = _("small", null, "Make sure 'three' package is installed", -1))
+      ])) : E("", !0),
+      _("div", xe, [
+        _("span", null, "Points: " + x(B.value.pointCount.toLocaleString()), 1),
+        B.value.hasColors ? (w(), b("span", Pe, "🎨 Colored")) : E("", !0)
+      ])
+    ]));
+  }
+}), ot = /* @__PURE__ */ W(Be, [["__scopeId", "data-v-7f487135"]]), $e = { class: "stream-viewer" }, Ae = { class: "stream-viewer__header" }, Ee = { class: "stream-viewer__stats" }, Le = {
+  key: 0,
+  class: "stream-viewer__errors"
+}, Te = { class: "stream-viewer__actions" }, Fe = {
+  key: 0,
+  class: "stream-viewer__timestamp"
+}, De = { class: "stream-viewer__data" }, ze = {
+  key: 0,
+  class: "stream-viewer__empty"
+}, Me = /* @__PURE__ */ T({
+  __name: "StreamViewer",
+  props: {
+    data: {},
+    type: { default: "auto" },
+    maxLines: { default: 100 },
+    autoScroll: { type: Boolean, default: !0 },
+    showTimestamps: { type: Boolean, default: !0 },
+    paused: { type: Boolean, default: !1 },
+    formatter: {}
+  },
+  emits: ["clear", "pause"],
+  setup(C, { expose: R, emit: S }) {
+    const e = C, o = S, v = H([]), y = H(null);
+    let g = 0;
+    function i(n) {
+      if (e.formatter)
+        return e.formatter(n);
+      if (n == null)
+        return String(n);
+      switch (e.type === "auto" ? u(n) : e.type) {
+        case "json":
+          try {
+            return JSON.stringify(n, null, 2);
+          } catch {
+            return String(n);
+          }
+        case "binary":
+          return n instanceof ArrayBuffer ? `Binary: ${new Uint8Array(n).length} bytes` : String(n);
+        default:
+          return String(n);
+      }
+    }
+    function u(n) {
+      return n instanceof ArrayBuffer || n instanceof Uint8Array ? "binary" : typeof n == "object" ? "json" : "text";
+    }
+    function f(n, s = "data") {
+      if (e.paused) return;
+      const a = {
+        id: g++,
+        timestamp: /* @__PURE__ */ new Date(),
+        data: i(n),
+        type: s
+      };
+      v.value = [...v.value, a].slice(-e.maxLines), e.autoScroll && r();
+    }
+    function r() {
+      requestAnimationFrame(() => {
+        y.value && (y.value.scrollTop = y.value.scrollHeight);
+      });
+    }
+    function l() {
+      v.value = [], o("clear");
+    }
+    function d() {
+      o("pause", !e.paused);
+    }
+    function p(n) {
+      return n.toLocaleTimeString("en-US", {
+        hour12: !1,
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        fractionalSecondDigits: 3
+      });
+    }
+    L(
+      () => e.data,
+      (n) => {
+        n !== void 0 && f(n);
+      }
+    );
+    const c = O(() => ({
+      total: v.value.length,
+      errors: v.value.filter((n) => n.type === "error").length
+    }));
+    return R({
+      addLog: f,
+      clear: l,
+      logs: v,
+      stats: c
+    }), (n, s) => (w(), b("div", $e, [
+      _("div", Ae, [
+        _("div", Ee, [
+          _("span", null, "Lines: " + x(c.value.total), 1),
+          c.value.errors > 0 ? (w(), b("span", Le, " Errors: " + x(c.value.errors), 1)) : E("", !0)
+        ]),
+        _("div", Te, [
+          _("button", {
+            onClick: d,
+            class: G(["stream-viewer__btn", { "stream-viewer__btn--active": n.paused }])
+          }, x(n.paused ? "▶ Resume" : "⏸ Pause"), 3),
+          _("button", {
+            onClick: l,
+            class: "stream-viewer__btn"
+          }, "🗑 Clear")
+        ])
+      ]),
+      _("div", {
+        ref_key: "containerRef",
+        ref: y,
+        class: "stream-viewer__content"
+      }, [
+        (w(!0), b(J, null, Q(v.value, (a) => (w(), b("div", {
+          key: a.id,
+          class: G(["stream-viewer__entry", `stream-viewer__entry--${a.type}`])
+        }, [
+          n.showTimestamps ? (w(), b("span", Fe, x(p(a.timestamp)), 1)) : E("", !0),
+          _("pre", De, x(a.data), 1)
+        ], 2))), 128)),
+        v.value.length === 0 ? (w(), b("div", ze, " Waiting for data... ")) : E("", !0)
+      ], 512)
+    ]));
+  }
+}), st = /* @__PURE__ */ W(Me, [["__scopeId", "data-v-06dc8d20"]]), He = { class: "webrtc-viewer" }, Ie = {
+  key: 0,
+  class: "webrtc-viewer__header"
+}, je = { class: "webrtc-viewer__status" }, Oe = { class: "webrtc-viewer__controls" }, Ue = { class: "webrtc-viewer__content" }, We = { class: "webrtc-viewer__default" }, Ve = {
+  key: 0,
+  class: "webrtc-viewer__placeholder"
+}, Ge = {
+  key: 1,
+  class: "webrtc-viewer__loading"
+}, qe = {
+  key: 2,
+  class: "webrtc-viewer__error"
+}, Ne = {
+  key: 3,
+  class: "webrtc-viewer__info"
+}, Je = { key: 0 }, Qe = { key: 1 }, Ke = {
+  key: 1,
+  class: "webrtc-viewer__footer"
+}, Xe = { key: 0 }, Ye = { key: 1 }, Ze = /* @__PURE__ */ T({
+  __name: "WebRTCViewer",
+  props: {
+    signalingUrl: {},
+    iceServers: { default: () => [{ urls: "stun:stun.l.google.com:19302" }] },
+    enablePointCloud: { type: Boolean, default: !0 },
+    enableDetections: { type: Boolean, default: !0 },
+    autoConnect: { type: Boolean, default: !0 },
+    autoReconnect: { type: Boolean, default: !0 },
+    maxReconnectAttempts: { default: 5 },
+    showStatus: { type: Boolean, default: !0 },
+    showStats: { type: Boolean, default: !0 }
+  },
+  emits: ["connected", "disconnected", "error", "pointcloud", "detections", "boundingboxes", "status"],
+  setup(C, { expose: R, emit: S }) {
+    const e = C, o = S, v = H("Idle"), y = {
+      signalingUrl: e.signalingUrl,
+      iceServers: e.iceServers,
+      enablePointCloud: e.enablePointCloud,
+      enableDetections: e.enableDetections,
+      autoReconnect: e.autoReconnect,
+      maxReconnectAttempts: e.maxReconnectAttempts
+    }, g = {
+      onStatus: (m) => {
+        v.value = m, o("status", m);
+      },
+      onConnectionState: (m) => {
+        m === "connected" ? o("connected") : (m === "disconnected" || m === "closed" || m === "failed") && o("disconnected");
+      },
+      onPointCloudFrame: (m) => {
+        o("pointcloud", m);
+      },
+      onDetectionFrame: (m) => {
+        o("detections", m);
+      },
+      onBoundingBoxData: (m) => {
+        o("boundingboxes", m);
+      },
+      onError: (m) => {
+        o("error", m);
+      }
+    }, {
+      isRunning: i,
+      connectionState: u,
+      dataChannels: f,
+      lastPointCloudFrame: r,
+      lastDetectionFrame: l,
+      lastBoundingBoxes: d,
+      error: p,
+      start: c,
+      stop: n,
+      sendControl: s
+    } = ne(y, g), a = O(() => {
+      var m, h;
+      return {
+        channels: f.value.size,
+        pointCount: ((m = r.value) == null ? void 0 : m.points.length) ?? 0,
+        detectionCount: ((h = l.value) == null ? void 0 : h.detections.length) ?? 0,
+        bboxCount: d.value.length
+      };
+    }), B = O(() => {
+      switch (u.value) {
+        case "connected":
+          return "#4caf50";
+        case "connecting":
+          return "#ff9800";
+        case "reconnecting":
+          return "#ff9800";
+        case "error":
+          return "#f44336";
+        default:
+          return "#9e9e9e";
+      }
+    });
+    return U(() => {
+      e.autoConnect && c();
+    }), L(
+      () => e.signalingUrl,
+      () => {
+        i.value && (n(), y.signalingUrl = e.signalingUrl, c());
+      }
+    ), R({
+      isRunning: i,
+      connectionState: u,
+      start: c,
+      stop: n,
+      sendControl: s,
+      lastPointCloudFrame: r,
+      lastDetectionFrame: l,
+      lastBoundingBoxes: d,
+      stats: a
+    }), (m, h) => (w(), b("div", He, [
+      m.showStatus ? (w(), b("div", Ie, [
+        _("div", je, [
+          _("span", {
+            class: "webrtc-viewer__indicator",
+            style: ee({ backgroundColor: B.value })
+          }, null, 4),
+          _("span", null, x(t(u)), 1)
+        ]),
+        _("div", Oe, [
+          t(i) ? (w(), b("button", {
+            key: 1,
+            onClick: h[1] || (h[1] = //@ts-ignore
+            (...A) => t(n) && t(n)(...A)),
+            class: "webrtc-viewer__btn webrtc-viewer__btn--disconnect"
+          }, " ⏹ Disconnect ")) : (w(), b("button", {
+            key: 0,
+            onClick: h[0] || (h[0] = //@ts-ignore
+            (...A) => t(c) && t(c)(...A)),
+            class: "webrtc-viewer__btn webrtc-viewer__btn--connect"
+          }, " ▶ Connect "))
+        ])
+      ])) : E("", !0),
+      _("div", Ue, [
+        M(m.$slots, "default", {
+          isRunning: t(i),
+          connectionState: t(u),
+          pointCloudFrame: t(r),
+          detectionFrame: t(l),
+          boundingBoxes: t(d),
+          error: t(p),
+          start: t(c),
+          stop: t(n),
+          sendControl: t(s)
+        }, () => [
+          _("div", We, [
+            t(i) ? t(u) === "connecting" ? (w(), b("div", Ge, [
+              h[3] || (h[3] = _("div", { class: "webrtc-viewer__spinner" }, null, -1)),
+              _("span", null, x(v.value), 1)
+            ])) : t(p) ? (w(), b("div", qe, [
+              _("span", null, "⚠️ " + x(t(p).message), 1)
+            ])) : (w(), b("div", Ne, [
+              h[4] || (h[4] = _("p", null, "WebRTC Connected", -1)),
+              a.value.pointCount > 0 ? (w(), b("p", Je, " Points: " + x(a.value.pointCount.toLocaleString()), 1)) : E("", !0),
+              a.value.bboxCount > 0 ? (w(), b("p", Qe, " Bounding Boxes: " + x(a.value.bboxCount), 1)) : E("", !0)
+            ])) : (w(), b("div", Ve, [...h[2] || (h[2] = [
+              _("span", null, "Click Connect to start WebRTC stream", -1)
+            ])]))
+          ])
+        ], !0)
+      ]),
+      m.showStats && t(i) ? (w(), b("div", Ke, [
+        _("span", null, "Channels: " + x(a.value.channels), 1),
+        e.enablePointCloud ? (w(), b("span", Xe, " Points: " + x(a.value.pointCount.toLocaleString()), 1)) : E("", !0),
+        e.enableDetections ? (w(), b("span", Ye, " Detections: " + x(a.value.detectionCount), 1)) : E("", !0)
+      ])) : E("", !0)
+    ]));
+  }
+}), rt = /* @__PURE__ */ W(Ze, [["__scopeId", "data-v-3f83a728"]]), at = /* @__PURE__ */ T({
+  __name: "DataStreamView",
+  props: {
+    config: { default: () => ({}) },
+    autoStart: { type: Boolean, default: !0 }
+  },
+  emits: ["data", "batch", "error"],
+  setup(C, { expose: R, emit: S }) {
+    const e = C, o = S, { config: v } = I(e), {
+      data: y,
+      buffer: g,
+      bufferSize: i,
+      isStreaming: u,
+      itemsPerSecond: f,
+      totalItems: r,
+      error: l,
+      start: d,
+      stop: p,
+      push: c,
+      clear: n,
+      getBuffer: s,
+      subscribe: a
+    } = oe(e.config, {
+      onData: (B) => o("data", B),
+      onBatch: (B) => o("batch", B),
+      onError: (B) => o("error", B)
+    });
+    return L(
+      v,
+      () => {
+        p(), d();
+      },
+      { deep: !0 }
+    ), R({
+      data: y,
+      buffer: g,
+      bufferSize: i,
+      isStreaming: u,
+      itemsPerSecond: f,
+      totalItems: r,
+      error: l,
+      start: d,
+      stop: p,
+      push: c,
+      clear: n,
+      getBuffer: s,
+      subscribe: a
+    }), (B, m) => M(B.$slots, "default", {
+      data: t(y),
+      buffer: t(g),
+      bufferSize: t(i),
+      isStreaming: t(u),
+      itemsPerSecond: t(f),
+      totalItems: t(r),
+      error: t(l),
+      start: t(d),
+      stop: t(p),
+      push: t(c),
+      clear: t(n)
+    });
+  }
+}), it = /* @__PURE__ */ T({
+  __name: "HTTPStream",
+  props: {
+    url: {},
+    method: { default: "GET" },
+    headers: { default: () => ({}) },
+    body: { default: void 0 },
+    credentials: { default: "same-origin" },
+    autoConnect: { type: Boolean, default: !0 },
+    autoReconnect: { type: Boolean, default: !0 },
+    maxReconnectAttempts: { default: 5 },
+    reconnectDelay: { default: 1e3 },
+    ndjson: { type: Boolean, default: !0 }
+  },
+  emits: ["open", "chunk", "complete", "error", "progress", "reconnecting", "reconnected", "reconnectFailed"],
+  setup(C, { expose: R, emit: S }) {
+    const e = C, o = S, { url: v } = I(e), {
+      isConnected: y,
+      isStreaming: g,
+      connectionState: i,
+      lastChunk: u,
+      chunks: f,
+      bytesReceived: r,
+      error: l,
+      reconnectAttempts: d,
+      connect: p,
+      disconnect: c,
+      clearChunks: n
+    } = se(
+      {
+        url: e.url,
+        method: e.method,
+        headers: e.headers,
+        body: e.body,
+        credentials: e.credentials,
+        autoConnect: e.autoConnect,
+        autoReconnect: e.autoReconnect,
+        maxReconnectAttempts: e.maxReconnectAttempts,
+        reconnectDelay: e.reconnectDelay,
+        ndjson: e.ndjson
+      },
+      {
+        onOpen: () => o("open"),
+        onChunk: (s, a) => o("chunk", s, a),
+        onComplete: () => o("complete"),
+        onError: (s) => o("error", s),
+        onProgress: (s) => o("progress", s),
+        onReconnecting: (s, a) => o("reconnecting", s, a),
+        onReconnected: () => o("reconnected"),
+        onReconnectFailed: () => o("reconnectFailed")
+      }
+    );
+    return L(v, () => {
+      c(), p();
+    }), R({
+      isConnected: y,
+      isStreaming: g,
+      connectionState: i,
+      lastChunk: u,
+      chunks: f,
+      bytesReceived: r,
+      error: l,
+      reconnectAttempts: d,
+      connect: p,
+      disconnect: c,
+      clearChunks: n
+    }), (s, a) => M(s.$slots, "default", {
+      isConnected: t(y),
+      isStreaming: t(g),
+      connectionState: t(i),
+      lastChunk: t(u),
+      chunks: t(f),
+      bytesReceived: t(r),
+      error: t(l),
+      reconnectAttempts: t(d),
+      connect: t(p),
+      disconnect: t(c),
+      clearChunks: t(n)
+    });
+  }
+}), lt = /* @__PURE__ */ T({
+  __name: "LaravelEchoStream",
+  props: {
+    config: {},
+    channel: { default: void 0 },
+    channelType: { default: "public" },
+    events: { default: () => [] },
+    autoSubscribe: { type: Boolean, default: !0 }
+  },
+  emits: ["connected", "event", "error", "subscribed", "unsubscribed", "here", "joining", "leaving"],
+  setup(C, { expose: R, emit: S }) {
+    const e = C, o = S, { channel: v } = I(e), {
+      isConnected: y,
+      channels: g,
+      channel: i,
+      privateChannel: u,
+      presenceChannel: f,
+      leave: r,
+      leaveAll: l,
+      connect: d
+    } = re(e.config, {
+      onConnected: (n) => o("connected", n),
+      onError: (n) => o("error", n)
+    });
+    let p = null;
+    function c() {
+      if (e.channel) {
+        if (e.channelType === "private")
+          p = u(e.channel);
+        else if (e.channelType === "presence") {
+          const n = f(e.channel);
+          p = n, n.here((s) => o("here", s)), n.joining((s) => o("joining", s)), n.leaving((s) => o("leaving", s));
+        } else
+          p = i(e.channel);
+        e.events.forEach((n) => {
+          p == null || p.listen(n, (s) => {
+            o("event", n, s);
+          });
+        }), o("subscribed", e.channel);
+      }
+    }
+    return U(async () => {
+      await d(), e.autoSubscribe && e.channel && c();
+    }), L(v, (n, s) => {
+      s && (r(s), o("unsubscribed", s)), n && e.autoSubscribe && c();
+    }), R({
+      isConnected: y,
+      channels: g,
+      subscribePublic: i,
+      privateChannel: u,
+      presenceChannel: f,
+      leave: r,
+      leaveAll: l,
+      connect: d
+    }), (n, s) => M(n.$slots, "default", {
+      isConnected: t(y),
+      channels: t(g),
+      subscribePublic: t(i),
+      privateChannel: t(u),
+      presenceChannel: t(f),
+      leave: t(r),
+      leaveAll: t(l)
+    });
+  }
+}), ct = /* @__PURE__ */ T({
+  __name: "LongPollingStream",
+  props: {
+    url: {},
+    method: { default: "GET" },
+    headers: { default: () => ({}) },
+    body: { default: void 0 },
+    credentials: { default: "same-origin" },
+    interval: { default: 0 },
+    timeout: { default: 3e4 },
+    autoStart: { type: Boolean, default: !0 },
+    autoRestart: { type: Boolean, default: !0 },
+    maxRestartAttempts: { default: 5 },
+    restartDelay: { default: 1e3 },
+    includeTimestamp: { type: Boolean, default: !1 },
+    timestampParam: { default: "since" }
+  },
+  emits: ["start", "data", "error", "stop", "restarting", "restarted", "restartFailed"],
+  setup(C, { expose: R, emit: S }) {
+    const e = C, o = S, { url: v } = I(e), {
+      isPolling: y,
+      connectionState: g,
+      lastData: i,
+      dataHistory: u,
+      requestCount: f,
+      error: r,
+      restartAttempts: l,
+      start: d,
+      stop: p,
+      poll: c,
+      clearHistory: n
+    } = ae(
+      {
+        url: e.url,
+        method: e.method,
+        headers: e.headers,
+        body: e.body,
+        credentials: e.credentials,
+        interval: e.interval,
+        timeout: e.timeout,
+        autoStart: e.autoStart,
+        autoRestart: e.autoRestart,
+        maxRestartAttempts: e.maxRestartAttempts,
+        restartDelay: e.restartDelay,
+        includeTimestamp: e.includeTimestamp,
+        timestampParam: e.timestampParam
+      },
+      {
+        onStart: () => o("start"),
+        onData: (s) => o("data", s),
+        onError: (s) => o("error", s),
+        onStop: () => o("stop"),
+        onRestarting: (s, a) => o("restarting", s, a),
+        onRestarted: () => o("restarted"),
+        onRestartFailed: () => o("restartFailed")
+      }
+    );
+    return L(v, () => {
+      p(), d();
+    }), R({
+      isPolling: y,
+      connectionState: g,
+      lastData: i,
+      dataHistory: u,
+      requestCount: f,
+      error: r,
+      restartAttempts: l,
+      start: d,
+      stop: p,
+      poll: c,
+      clearHistory: n
+    }), (s, a) => M(s.$slots, "default", {
+      isPolling: t(y),
+      connectionState: t(g),
+      lastData: t(i),
+      dataHistory: t(u),
+      requestCount: t(f),
+      error: t(r),
+      restartAttempts: t(l),
+      start: t(d),
+      stop: t(p),
+      poll: t(c),
+      clearHistory: t(n)
+    });
+  }
+}), ut = /* @__PURE__ */ T({
+  __name: "SocketIOStream",
+  props: {
+    config: {},
+    autoConnect: { type: Boolean, default: !0 },
+    events: { default: () => [] }
+  },
+  emits: ["connect", "disconnect", "error", "event", "reconnecting", "reconnected", "reconnectFailed"],
+  setup(C, { expose: R, emit: S }) {
+    const e = C, o = S, { config: v } = I(e), {
+      isConnected: y,
+      connectionState: g,
+      socketId: i,
+      rooms: u,
+      error: f,
+      connect: r,
+      disconnect: l,
+      emit: d,
+      on: p,
+      off: c,
+      join: n,
+      leave: s
+    } = ie(e.config, {
+      onConnect: (a) => o("connect", a),
+      onDisconnect: (a) => o("disconnect", a),
+      onError: (a) => o("error", a),
+      onReconnecting: (a) => o("reconnecting", a),
+      onReconnectFailed: () => o("reconnectFailed")
+    });
+    return e.events.forEach((a) => {
+      p(a, (B) => {
+        o("event", a, B);
+      });
+    }), L(
+      () => v.value.url,
+      () => {
+        l(), r();
+      }
+    ), R({
+      isConnected: y,
+      connectionState: g,
+      socketId: i,
+      rooms: u,
+      error: f,
+      connect: r,
+      disconnect: l,
+      emit: d,
+      on: p,
+      off: c,
+      join: n,
+      leave: s
+    }), (a, B) => M(a.$slots, "default", {
+      isConnected: t(y),
+      connectionState: t(g),
+      socketId: t(i),
+      rooms: t(u),
+      error: t(f),
+      connect: t(r),
+      disconnect: t(l),
+      emit: t(d),
+      on: t(p),
+      off: t(c),
+      join: t(n),
+      leave: t(s)
+    });
+  }
+}), dt = /* @__PURE__ */ T({
+  __name: "SSEStream",
+  props: {
+    url: {},
+    withCredentials: { type: Boolean, default: !1 },
+    autoConnect: { type: Boolean, default: !0 },
+    autoReconnect: { type: Boolean, default: !0 },
+    maxReconnectAttempts: { default: 5 },
+    reconnectDelay: { default: 1e3 },
+    eventTypes: { default: () => ["message"] }
+  },
+  emits: ["open", "error", "message", "event", "reconnecting", "reconnected", "reconnectFailed"],
+  setup(C, { expose: R, emit: S }) {
+    const e = C, o = S, { url: v } = I(e), {
+      isConnected: y,
+      connectionState: g,
+      lastMessage: i,
+      lastEventType: u,
+      lastEventId: f,
+      error: r,
+      reconnectAttempts: l,
+      connect: d,
+      disconnect: p,
+      addEventListener: c,
+      removeEventListener: n
+    } = le(
+      {
+        url: e.url,
+        withCredentials: e.withCredentials,
+        autoConnect: e.autoConnect,
+        autoReconnect: e.autoReconnect,
+        maxReconnectAttempts: e.maxReconnectAttempts,
+        reconnectDelay: e.reconnectDelay,
+        eventTypes: e.eventTypes
+      },
+      {
+        onOpen: () => o("open"),
+        onError: (s) => o("error", s),
+        onMessage: (s, a) => o("message", s, a),
+        onEvent: (s, a, B) => o("event", s, a, B),
+        onReconnecting: (s, a) => o("reconnecting", s, a),
+        onReconnected: () => o("reconnected"),
+        onReconnectFailed: () => o("reconnectFailed")
+      }
+    );
+    return L(v, () => {
+      p(), d();
+    }), R({
+      isConnected: y,
+      connectionState: g,
+      lastMessage: i,
+      lastEventType: u,
+      lastEventId: f,
+      error: r,
+      reconnectAttempts: l,
+      connect: d,
+      disconnect: p,
+      addEventListener: c,
+      removeEventListener: n
+    }), (s, a) => M(s.$slots, "default", {
+      isConnected: t(y),
+      connectionState: t(g),
+      lastMessage: t(i),
+      lastEventType: t(u),
+      lastEventId: t(f),
+      error: t(r),
+      reconnectAttempts: t(l),
+      connect: t(d),
+      disconnect: t(p),
+      addEventListener: t(c),
+      removeEventListener: t(n)
+    });
+  }
+}), pt = /* @__PURE__ */ T({
+  __name: "WebSocketStream",
+  props: {
+    config: {},
+    autoConnect: { type: Boolean, default: !0 }
+  },
+  emits: ["open", "close", "error", "message", "reconnecting", "reconnected", "reconnectFailed"],
+  setup(C, { expose: R, emit: S }) {
+    const e = C, o = S, { config: v } = I(e), {
+      isConnected: y,
+      connectionState: g,
+      lastMessage: i,
+      error: u,
+      reconnectAttempts: f,
+      connect: r,
+      disconnect: l,
+      send: d,
+      sendJSON: p
+    } = ce(e.config, {
+      onOpen: () => o("open"),
+      onClose: (c, n) => o("close", c, n),
+      onError: (c) => o("error", c),
+      onMessage: (c, n) => o("message", c, n),
+      onReconnecting: (c, n) => o("reconnecting", c, n),
+      onReconnected: () => o("reconnected"),
+      onReconnectFailed: () => o("reconnectFailed")
+    });
+    return L(
+      () => v.value.url,
+      () => {
+        l(), r();
+      }
+    ), R({
+      isConnected: y,
+      connectionState: g,
+      lastMessage: i,
+      error: u,
+      reconnectAttempts: f,
+      connect: r,
+      disconnect: l,
+      send: d,
+      sendJSON: p
+    }), (c, n) => M(c.$slots, "default", {
+      isConnected: t(y),
+      connectionState: t(g),
+      lastMessage: t(i),
+      error: t(u),
+      reconnectAttempts: t(f),
+      connect: t(r),
+      disconnect: t(l),
+      send: t(d),
+      sendJson: t(p)
+    });
+  }
+});
+export {
+  nt as H,
+  ot as P,
+  st as S,
+  rt as W,
+  at as _,
+  it as a,
+  lt as b,
+  ct as c,
+  dt as d,
+  ut as e,
+  pt as f
+};
+//# sourceMappingURL=WebSocketStream.vue_vue_type_script_setup_true_lang-C_F2vNNk.js.map