vue-streaming 2.0.1 → 2.0.2

package/dist/WebSocketStream.vue_vue_type_script_setup_true_lang-D5yjtuTd.js

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