smart-web-ui 1.0.0 → 1.0.1

package/dist/JessibucaPlayer.js

@@ -0,0 +1,181 @@
+import { ref as g, reactive as f, computed as s, onMounted as h, onUnmounted as v, openBlock as U, createElementBlock as _, createElementVNode as T, renderSlot as w } from "vue";
+import { _ as R } from "./chunks/_plugin-vue_export-helper-CHgC5LLL.js";
+import { m as x } from "./chunks/merge-H4ZkNr1T.js";
+const r = [];
+for (let e = 0; e < 256; ++e)
+  r.push((e + 256).toString(16).slice(1));
+function P(e, t = 0) {
+  return (r[e[t + 0]] + r[e[t + 1]] + r[e[t + 2]] + r[e[t + 3]] + "-" + r[e[t + 4]] + r[e[t + 5]] + "-" + r[e[t + 6]] + r[e[t + 7]] + "-" + r[e[t + 8]] + r[e[t + 9]] + "-" + r[e[t + 10]] + r[e[t + 11]] + r[e[t + 12]] + r[e[t + 13]] + r[e[t + 14]] + r[e[t + 15]]).toLowerCase();
+}
+let i;
+const S = new Uint8Array(16);
+function D() {
+  if (!i) {
+    if (typeof crypto > "u" || !crypto.getRandomValues)
+      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+    i = crypto.getRandomValues.bind(crypto);
+  }
+  return i(S);
+}
+const I = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), d = { randomUUID: I };
+function B(e, t, u) {
+  var n;
+  if (d.randomUUID && !e)
+    return d.randomUUID();
+  e = e || {};
+  const o = e.random ?? ((n = e.rng) == null ? void 0 : n.call(e)) ?? D();
+  if (o.length < 16)
+    throw new Error("Random bytes length must be >= 16");
+  return o[6] = o[6] & 15 | 64, o[8] = o[8] & 63 | 128, P(o);
+}
+const E = { class: "JessibucaPlayer" }, J = ["id"], O = {
+  __name: "JessibucaPlayer",
+  props: {
+    url: {
+      type: String,
+      required: !0
+    },
+    options: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  setup(e) {
+    const t = {
+      decoder: "./jesncrypt/decoder-pro.js",
+      debug: !1,
+      // 是否开启控制台调试打印
+      debugLevel: "debug",
+      // debug模式下的日志级别，支持debug、warn，默认是warn
+      videoBuffer: 0.1,
+      // 设置缓冲时长，单位秒。
+      videoBufferDelay: 0.3,
+      // 设置最大缓冲延迟时长，单位秒，如果延迟超过该值，就会进行丢帧处理。
+      isResize: !1,
+      // 当为true的时候：视频画面做等比缩放后,高或宽对齐canvas区域,画面不被拉伸,但有黑边。 等同于 setScaleMode(1)，当为false的时候：视频画面完全填充canvas区域,画面会被拉伸。等同于 setScaleMode(0)
+      forceNoOffscreen: !1,
+      // 是否不使用离屏模式（提升渲染能力）
+      supportDblclickFullscreen: !1,
+      // 是否支持屏幕的双击事件，触发全屏，取消全屏事件。
+      loadingText: "加载中",
+      // 加载提示文字。
+      /*超时配置*/
+      timeout: 10,
+      // 设置超时时长, 单位秒，在连接成功之前(loading)和播放中途(heart),如果超过设定时长无数据返回,则回调timeout事件
+      mseWaitVideoCanplayTimeout: 3,
+      // 流异常超时时长，不能比loadingTimeout大
+      loadingTimeout: 3,
+      // 设置超时时长, 单位秒，在刚开始播放的时候，在连接成功之前,如果超过设定时长无数据返回,则回调timeout事件
+      loadingTimeoutReplay: !0,
+      // 加载超时是否重试
+      loadingTimeoutReplayTimes: -1,
+      // 加载超时重试次数，-1无限重试
+      heartTimeout: 3,
+      // 设置超时时长, 单位秒，播放中途,如果超过设定时长无数据返回,则回调timeout事件
+      heartTimeoutReplay: !0,
+      // 播放超时是否重试
+      heartTimeoutReplayTime: -1,
+      // 播放超时重试次数，-1无限重试
+      heartTimeoutReplayUseLastFrameShow: !0,
+      // 播放过程中，超时重连时，是否使用最后一帧来显示。
+      /*解码配置*/
+      useMSE: !1,
+      // 是否开启MediaSource硬解码
+      useWCS: !1,
+      // 是否开启Webcodecs硬解码
+      autoWasm: !0,
+      // 是否在其他模式不支持的情况下，自动启用wasm
+      useSIMD: !0,
+      // 是否使用SIMD 软解码，仅仅wasm软解码的时候有效
+      /*音频配置*/
+      muted: !0,
+      // 是否静音。
+      isNotMute: !1,
+      // 是否开启声音，默认是关闭声音播放的。
+      audioEngine: "worklet",
+      // 音频解码引擎
+      /*渲染配置*/
+      hasAudio: !1,
+      // 是否包含音频
+      useVideoRender: !0,
+      // 是否使用video标签进行渲染
+      useCanvasRender: !1,
+      // 是否使用canvas标签进行渲染
+      useWebGPU: !1,
+      // true使用Webgpu进行渲染、false使用Webgl进行渲染
+      /*按钮配置*/
+      hiddenControl: !0,
+      // 隐藏控制栏
+      controlAutoHide: !0,
+      // 控制栏是否自动隐藏
+      showBandwidth: !0,
+      // 是否显示网速
+      operateBtns: {
+        // 配置底部操作按钮
+        fullscreen: !0,
+        // 是否显示全屏按钮
+        screenshot: !0,
+        // 是否显示截图按钮
+        play: !0,
+        // 是否显示播放暂停按钮
+        audio: !0,
+        // 是否显示声音按钮
+        record: !0,
+        // 是否显示录制按钮
+        ptz: !0,
+        // 是否显示PTZ轮盘按钮
+        quality: !0,
+        // 是否显示清晰度按钮
+        close: !0,
+        // 是否显示关闭按钮(会销毁播放器)
+        zoom: !0,
+        // 是否显示电子放大
+        scale: !0,
+        // 是否显示scale(拉伸、缩放)按钮
+        performance: !0,
+        // 是否显示性能按钮
+        face: !0
+        // 是否显示人脸识别按钮
+      },
+      extendOperateBtns: {
+        // 添加自定义按钮
+      }
+    }, u = e, o = g(null), n = f({
+      id: B()
+    }), l = s(() => document.getElementById(n.id)), m = s(() => ({
+      ...t,
+      container: l.value
+    })), p = s(
+      () => x({}, m.value, u.options)
+    ), y = () => {
+      if (!l.value) {
+        console.error("Jessibuca 播放器容器未找到");
+        return;
+      }
+      try {
+        o.value = new window.JessibucaPro(p.value), o.value.play(u.url);
+      } catch (a) {
+        console.error("初始化 Jessibuca 播放器失败:", a);
+      }
+    }, b = () => {
+      o.value && (o.value.destroy(), o.value = null);
+    };
+    return h(() => {
+      u.url && y();
+    }), v(() => {
+      b();
+    }), (a, V) => (U(), _("div", E, [
+      T("div", {
+        id: n.id
+      }, [
+        w(a.$slots, "Content", {}, void 0, !0)
+      ], 8, J)
+    ]));
+  }
+}, c = /* @__PURE__ */ R(O, [["__scopeId", "data-v-3d75bb2a"]]);
+c.install = (e) => {
+  e.component("JessibucaPlayer", c);
+};
+export {
+  c as default
+};

package/dist/LineChart.js

@@ -0,0 +1,279 @@
+import { ref as L, computed as d, watch as c, onMounted as C, onBeforeUnmount as v, openBlock as z, createElementBlock as w, mergeProps as F, nextTick as A } from "vue";
+import { i as _ } from "./chunks/index-CBkwld9S.js";
+import { _ as O } from "./chunks/_plugin-vue_export-helper-CHgC5LLL.js";
+import { m as T } from "./chunks/merge-H4ZkNr1T.js";
+const k = {
+  __name: "LineChart",
+  props: {
+    data: {
+      type: Array,
+      required: !0
+    },
+    xData: {
+      type: Array,
+      required: !0
+    },
+    colorList: {
+      type: Array,
+      default: () => [
+        "rgba(255, 153, 0, 1)",
+        "#FF2E2E",
+        "#07D1FA",
+        "#FFD15C",
+        "#20E6A4"
+      ]
+    },
+    areaColorList: {
+      type: Array,
+      default: () => [
+        { to: "rgba(255,153,0, 0.2)", from: "rgba(255,153,0, 0.7)" },
+        { to: "rgba(255, 46, 46, 0.2)", from: "rgba(255, 46, 46, 0.7)" },
+        { to: "rgba(7, 209, 250, 0.2)", from: "rgba(7, 209, 250, 0.7)" },
+        { to: "rgba(255, 209, 92, 0.2)", from: "rgba(255, 209, 92, 0.7)" },
+        { to: "rgba(32, 230, 164, 0.2)", from: "rgba(32, 230, 164, 0.7)" }
+      ]
+    },
+    options: {
+      type: Object,
+      default: () => ({})
+    },
+    // x轴文字长度
+    xTextLength: {
+      type: Number,
+      default: 5
+    },
+    // 横轴网格线是否显示
+    yLineShow: {
+      type: Boolean,
+      default: !0
+    },
+    // 横轴网格线格式
+    yLineType: {
+      type: String,
+      default: "dashed"
+      //solid实线dashed虚线dotted细点画线
+    },
+    zoomKey: {
+      type: String,
+      // 'none' | 'ctrl' | 'alt' | 'shift'
+      default: "ctrl"
+      // 默认按住 Ctrl 键缩放
+    },
+    legendType: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  setup(n) {
+    const e = n, i = L(null);
+    let t = null;
+    const h = d(() => {
+      const o = e.data || [], a = e.xData || [], g = e.areaColorList || [
+        { to: "rgba(255,153,0, 0.2)", from: "rgba(255,153,0, 0.7)" },
+        { to: "rgba(255, 46, 46, 0.2)", from: "rgba(255, 46, 46, 0.7)" },
+        { to: "rgba(7, 209, 250, 0.2)", from: "rgba(7, 209, 250, 0.7)" },
+        { to: "rgba(255, 209, 92, 0.2)", from: "rgba(255, 209, 92, 0.7)" },
+        { to: "rgba(32, 230, 164, 0.2)", from: "rgba(32, 230, 164, 0.7)" }
+      ];
+      return {
+        color: e.colorList,
+        // 网格配置，设置图表上下左右的边距
+        grid: {
+          top: 30,
+          bottom: 30,
+          left: 40,
+          right: 20
+        },
+        tooltip: {
+          trigger: "axis",
+          backgroundColor: "rgba(1, 13, 19, 0.5)",
+          // 提示框背景颜色
+          borderColor: "#ffffff40",
+          // 提示框边框颜色
+          axisPointer: {
+            type: "shadow"
+            // 坐标轴指示器类型为阴影
+          },
+          textStyle: {
+            color: "#ffffff",
+            // 提示框文字颜色
+            fontSize: 12,
+            // 提示框文字大小
+            fontFamily: "PingFang SC"
+            // 提示框文字字体
+          }
+        },
+        // 图例配置，显示图表中不同系列的名称和颜色
+        legend: {
+          show: e.legendType,
+          // 显示图例
+          right: "5%",
+          // 图例相对于右侧的位置
+          textStyle: {
+            color: "#ffffff",
+            // 图例文字颜色
+            fontSize: 12,
+            // 图例文字大小
+            fontFamily: "PingFang SC"
+            // 图例文字字体
+          }
+        },
+        xAxis: {
+          type: "category",
+          data: a,
+          // 绑定 x 轴数据
+          axisTick: {
+            show: !1
+            // 隐藏 X 轴刻度线
+          },
+          boundaryGap: !1,
+          axisLine: {
+            lineStyle: {
+              type: "solid",
+              // 轴线类型，如虚线
+              width: 1,
+              color: "rgba(255, 255, 255, 0.72)"
+              // 轴线颜色
+            }
+          },
+          // 隐藏右侧的标签（如果需要）
+          axisLabel: {
+            show: !0,
+            // 显示 x 轴标签
+            // interval: 0, // 强制显示所有标签
+            formatter: function(r) {
+              return r.length > e.xTextLength ? r.slice(0, e.xTextLength) + "..." : r;
+            },
+            textStyle: {
+              fontSize: 12,
+              // x 轴标签文字大小
+              color: "#fff",
+              // x 轴标签文字颜色
+              fontFamily: "PingFang SC"
+              // x 轴标签文字字体
+            }
+          }
+        },
+        yAxis: {
+          type: "value",
+          // 设置纵轴网格线样式
+          splitLine: {
+            show: e.yLineShow,
+            // 是否显示网格线
+            lineStyle: {
+              type: e.yLineType,
+              // 网格线类型，如虚线
+              color: "#ffffff50"
+              // 网格线颜色
+            }
+          },
+          axisLabel: {
+            textStyle: {
+              fontSize: 12,
+              // y 轴标签文字大小
+              color: "#fff",
+              // y 轴标签文字颜色
+              fontFamily: "PingFang SC"
+              // y 轴标签文字字体
+            }
+          }
+        },
+        series: o.map((r, p) => {
+          var y, u, m;
+          return {
+            name: r.name,
+            type: "line",
+            smooth: !0,
+            symbol: "none",
+            symbolSize: 8,
+            zlevel: 3,
+            areaStyle: {
+              color: {
+                type: "linear",
+                x: 0,
+                y: 0,
+                x2: 0,
+                y2: 1,
+                colorStops: [
+                  {
+                    offset: 0,
+                    color: ((y = g[p]) == null ? void 0 : y.from) || "transparent"
+                  },
+                  {
+                    offset: 1,
+                    color: ((u = g[p]) == null ? void 0 : u.to) || "transparent"
+                  }
+                ],
+                global: !1
+              }
+            },
+            data: ((m = r.data) == null ? void 0 : m.map((S) => S.value)) || []
+          };
+        }),
+        // 数据缩放配置
+        dataZoom: [
+          {
+            type: "inside",
+            // 内置型数据缩放组件
+            xAxisIndex: 0,
+            // 控制第一个 x 轴
+            // 根据 zoomKey 的值设置是否需要按键触发缩放
+            zoomOnMouseWheel: e.zoomKey === "none" ? !0 : e.zoomKey,
+            moveOnMouseMove: !0,
+            // 允许鼠标拖动平移
+            moveOnMouseWheel: !0,
+            // 允许鼠标滚轮平移
+            preventDefaultMouseMove: !1,
+            // 允许默认滚动行为
+            throttle: 50,
+            // 操作节流时间
+            start: 0,
+            end: o.length > 30 ? o.length / 1.7 : o.length > 23 ? o.length / 1.5 : o.length > 13 ? 50 : o.length > 7 ? 70 : 100
+            // maxSpan: 80, // 最大缩放范围
+            // minSpan: 20, // 最小缩放范围
+          }
+        ],
+        animation: !0
+        // 禁用动画提升性能
+      };
+    }), f = d(
+      () => T({}, h.value, e.options)
+    ), x = () => {
+      i.value && (t = _(
+        i.value,
+        {},
+        {
+          renderer: "svg"
+        }
+      ), l(), t.dispatchAction({
+        type: "takeGlobalCursor",
+        key: "dataZoomSelect",
+        dataZoomSelectActive: !0
+      }));
+    }, l = () => {
+      t && (t.setOption(f.value, !0), A(() => t.resize()));
+    }, s = () => {
+      t == null || t.resize({ animation: { duration: 300 } });
+    };
+    return c(
+      () => e.data,
+      (o, a) => {
+        JSON.stringify(o) !== JSON.stringify(a) && l();
+      },
+      { deep: !0 }
+    ), c(f, l), C(() => {
+      x(), window.addEventListener("resize", s);
+    }), v(() => {
+      window.removeEventListener("resize", s), t == null || t.dispose(), t = null;
+    }), (o, a) => (z(), w("div", F({
+      ref_key: "chartContainer",
+      ref: i
+    }, o.$attrs, { class: "echarts-container" }), null, 16));
+  }
+}, b = /* @__PURE__ */ O(k, [["__scopeId", "data-v-ff94f4cc"]]);
+b.install = (n) => {
+  n.component("LineChart", b);
+};
+export {
+  b as default
+};

package/dist/MenuOne.js

@@ -0,0 +1,75 @@
+import { openBlock as n, createElementBlock as a, Fragment as X, renderList as p, normalizeStyle as C, normalizeClass as i, createElementVNode as M, toDisplayString as N } from "vue";
+import { _ as S } from "./chunks/_plugin-vue_export-helper-CHgC5LLL.js";
+const y = { class: "MenuOne-list" }, o = ["onClick"], E = {
+  __name: "MenuOne",
+  props: {
+    data: {
+      type: Array,
+      default: () => [
+        {
+          title: "标题1",
+          key: 1
+        },
+        {
+          title: "标题2",
+          key: 2
+        },
+        {
+          title: "标题3",
+          key: 3
+        },
+        {
+          title: "标题4",
+          key: 4
+        }
+      ]
+    },
+    menuBgImg: {
+      type: String,
+      default: () => new URL("data:image/png;base64,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", import.meta.url).href
+    },
+    menuBgActiveImg: {
+      type: String,
+      default: () => new URL("data:image/png;base64,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", import.meta.url).href
+    },
+    itemHeight: {
+      type: String,
+      default: "40px"
+    },
+    itemWidth: {
+      type: String,
+      default: "220px"
+    },
+    selectedIndex: {
+      type: Number,
+      default: -1
+    }
+  },
+  emits: ["update:selectedIndex"],
+  setup(A, { emit: m }) {
+    const t = A, Q = m, w = (e) => ({
+      backgroundImage: `url(${// 优先判断是否选中
+      e.key === t.selectedIndex ? t.menuBgActiveImg : t.menuBgImg})`,
+      height: t.itemHeight,
+      width: t.itemWidth
+    }), d = (e) => {
+      Q("update:selectedIndex", e.key);
+    };
+    return (e, c) => (n(), a("div", y, [
+      (n(!0), a(X, null, p(A.data, (z, f) => (n(), a("div", {
+        key: `menuOne_${f}`,
+        class: i(["MenuOne-list-item", { "is-selected": A.selectedIndex === f }]),
+        style: C(w(z)),
+        onClick: (K) => d(z)
+      }, [
+        M("span", null, N(z.title), 1)
+      ], 14, o))), 128))
+    ]));
+  }
+}, r = /* @__PURE__ */ S(E, [["__scopeId", "data-v-eb143c9f"]]);
+r.install = (A) => {
+  A.component("MenuOne", r);
+};
+export {
+  r as default
+};