tuikit-atomicx-vue3 4.4.0 → 4.5.0

package/dist/components/RoomParticipantView/StreamPlay.js

@@ -0,0 +1,74 @@
+import { defineComponent as f, ref as I, computed as _, watch as d, nextTick as w, onMounted as T, onBeforeUnmount as v, createElementBlock as S, openBlock as g } from "vue";
+import { getNanoId as M } from "../../utils/utils.js";
+import { useStreamPlayManager as L } from "./StreamPlayManager/index.js";
+import { FillMode as b } from "../../types/participant.js";
+import { _ as z } from "../../_plugin-vue_export-helper-CHgC5LLL.js";
+const F = ["id"], P = /* @__PURE__ */ f({
+  __name: "StreamPlay",
+  props: {
+    participant: {},
+    streamType: {},
+    fillMode: { default: b.Fill },
+    lazyLoad: { default: () => ({
+      enable: !0,
+      viewport: "body"
+    }) },
+    enableTouchScale: { type: Boolean, default: !1 },
+    onStreamLoading: { type: Function, default: () => {
+    } },
+    onStreamPlaying: { type: Function, default: () => {
+    } },
+    onStreamError: { type: Function, default: () => {
+    } }
+  },
+  setup(c) {
+    const { bindView: o, unbindView: n, setStreamConfig: m } = L(), e = c, a = I(), u = M(5), y = _(
+      () => `${e.participant.userId}_${e.streamType}_${u}`
+    );
+    return d(
+      () => [e.participant.userId, e.streamType],
+      async (i, s) => {
+        const [t, r] = s || [], [l, p] = i;
+        t && r && (t !== l || r !== p) && (await w(), await n({
+          userId: t,
+          streamType: r,
+          view: a.value
+        }), await o({
+          userId: l,
+          streamType: p,
+          view: a.value,
+          lazyLoad: e.lazyLoad
+        }));
+      }
+    ), d(() => e.fillMode, async () => {
+      m({
+        userId: e.participant.userId,
+        streamType: e.streamType,
+        renderParams: {
+          fillMode: e.fillMode
+        }
+      });
+    }), T(async () => {
+      a.value && await o({
+        userId: e.participant.userId,
+        streamType: e.streamType,
+        view: a.value,
+        lazyLoad: e.lazyLoad
+      });
+    }), v(async () => {
+      a.value && await n({
+        userId: e.participant.userId,
+        streamType: e.streamType,
+        view: a.value
+      });
+    }), (i, s) => (g(), S("div", {
+      id: y.value,
+      ref_key: "playRegionDomRef",
+      ref: a,
+      class: "stream-play-container"
+    }, null, 8, F));
+  }
+}), D = /* @__PURE__ */ z(P, [["__scopeId", "data-v-c3a418cd"]]);
+export {
+  D as default
+};

package/dist/components/RoomParticipantView/StreamPlay.vue.d.ts

@@ -0,0 +1,66 @@
+import { FillMode, RoomParticipant, VideoStreamType } from '../../types';
+
+interface Props {
+    participant: RoomParticipant;
+    streamType: VideoStreamType;
+    fillMode?: FillMode;
+    lazyLoad?: {
+        enable: boolean;
+        viewport?: string | HTMLDivElement;
+    };
+    enableTouchScale?: boolean;
+    onStreamLoading?: () => void;
+    onStreamPlaying?: () => void;
+    onStreamError?: (error: Error) => void;
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    fillMode: FillMode;
+    enableTouchScale: boolean;
+    draggable: boolean;
+    lazyLoad: () => {
+        enable: boolean;
+        viewport: string;
+    };
+    onStreamLoading: () => void;
+    onStreamPlaying: () => void;
+    onStreamError: () => void;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    fillMode: FillMode;
+    enableTouchScale: boolean;
+    draggable: boolean;
+    lazyLoad: () => {
+        enable: boolean;
+        viewport: string;
+    };
+    onStreamLoading: () => void;
+    onStreamPlaying: () => void;
+    onStreamError: () => void;
+}>>> & Readonly<{}>, {
+    lazyLoad: {
+        enable: boolean;
+        viewport?: string | HTMLDivElement;
+    };
+    fillMode: FillMode;
+    enableTouchScale: boolean;
+    onStreamLoading: () => void;
+    onStreamPlaying: () => void;
+    onStreamError: (error: Error) => void;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/RoomParticipantView/StreamPlayManager/LazyLoadManager.d.ts

@@ -0,0 +1,56 @@
+import { VideoStreamType } from '../../../types';
+
+/**
+ * 懒加载管理器 - 负责懒加载和可见性监控
+ * 职责：
+ * 1. 监听 DOM 元素的可见性变化
+ * 2. 管理 IntersectionObserver 实例
+ * 3. 提供可见性状态查询接口
+ */
+export declare class LazyLoadManager {
+    private intersectionObserver;
+    private observerDomMap;
+    private observerRoot;
+    private onVisibilityChange;
+    constructor({ onVisibilityChange }: {
+        onVisibilityChange: (options: {
+            userId: string;
+            streamType: VideoStreamType;
+            isVisible: boolean;
+            target: HTMLElement;
+        }) => void;
+    });
+    initObserver({ root }: {
+        root: string | HTMLDivElement | null;
+    }): void;
+    observe(options: {
+        userId: string;
+        streamType: VideoStreamType;
+        viewElement: HTMLDivElement;
+    }): boolean;
+    /**
+     * 移除 DOM 元素监听
+     */
+    unobserve(viewElement: HTMLDivElement): void;
+    /**
+     * 检查 DOM 元素是否可见
+     */
+    isVisible(viewElement: HTMLDivElement): boolean;
+    /**
+     * 检查指定流是否有可见的视图
+     */
+    hasVisibleView(userId: string, streamType: VideoStreamType): boolean;
+    /**
+     * 交集观察器回调
+     */
+    private intersectionObserverCallback;
+    /**
+     * 清理所有资源
+     */
+    destroy(): void;
+    /**
+     * 获取监听的 DOM 数量
+     */
+    getObservedCount(): number;
+}
+export default LazyLoadManager;

package/dist/components/RoomParticipantView/StreamPlayManager/LazyLoadManager.js

@@ -0,0 +1,94 @@
+var c = Object.defineProperty;
+var l = (t, e, r) => e in t ? c(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var o = (t, e, r) => l(t, typeof e != "symbol" ? e + "" : e, r);
+class h {
+  constructor({ onVisibilityChange: e }) {
+    o(this, "intersectionObserver", null);
+    o(this, "observerDomMap", /* @__PURE__ */ new Map());
+    o(this, "observerRoot", null);
+    // 回调函数类型
+    o(this, "onVisibilityChange");
+    this.onVisibilityChange = e;
+  }
+  initObserver({ root: e }) {
+    let r = e;
+    if (typeof r == "string" && (r = document.getElementById(r)), !this.intersectionObserver || r !== this.observerRoot) {
+      this.intersectionObserver && this.intersectionObserver.disconnect();
+      const s = r;
+      this.intersectionObserver = new IntersectionObserver(
+        this.intersectionObserverCallback.bind(this),
+        {
+          root: s,
+          rootMargin: "20px"
+        }
+      ), this.observerDomMap.clear(), this.observerRoot = s;
+    }
+  }
+  observe(e) {
+    const { userId: r, streamType: s, viewElement: i } = e;
+    return this.intersectionObserver ? i ? (this.observerDomMap.set(i, {
+      userId: r,
+      streamType: s,
+      isIntersection: !1
+    }), this.intersectionObserver.observe(i), !0) : (console.warn("[StreamPlay][LazyLoadManager] DOM element not found:", view), !1) : (console.warn("[StreamPlay][LazyLoadManager] Observer not initialized"), !1);
+  }
+  /**
+   * 移除 DOM 元素监听
+   */
+  unobserve(e) {
+    this.intersectionObserver && (e && this.intersectionObserver.unobserve(e), this.observerDomMap.delete(e));
+  }
+  /**
+   * 检查 DOM 元素是否可见
+   */
+  isVisible(e) {
+    if (!e)
+      return !1;
+    const r = this.observerDomMap.get(e);
+    return (r == null ? void 0 : r.isIntersection) || !1;
+  }
+  /**
+   * 检查指定流是否有可见的视图
+   */
+  hasVisibleView(e, r) {
+    return Array.from(this.observerDomMap.entries()).forEach(([, s]) => {
+      if (s.userId === e && s.streamType === r && s.isIntersection)
+        return !0;
+    }), !1;
+  }
+  /**
+   * 交集观察器回调
+   */
+  intersectionObserverCallback(e) {
+    e.forEach((r) => {
+      const { isIntersecting: s, target: i } = r, n = this.observerDomMap.get(i);
+      if (!n)
+        return;
+      const { userId: a, streamType: b } = n;
+      n.isIntersection = s, this.onVisibilityChange({
+        userId: a,
+        streamType: b,
+        isVisible: s,
+        target: i
+      }), console.log(
+        `[StreamPlay][LazyLoadManager] ${a}_${b} ${s ? "enter" : "left"} viewPort`
+      );
+    });
+  }
+  /**
+   * 清理所有资源
+   */
+  destroy() {
+    this.intersectionObserver && (this.intersectionObserver.disconnect(), this.intersectionObserver = null), this.observerDomMap.clear(), this.observerRoot = null;
+  }
+  /**
+   * 获取监听的 DOM 数量
+   */
+  getObservedCount() {
+    return this.observerDomMap.size;
+  }
+}
+export {
+  h as LazyLoadManager,
+  h as default
+};

package/dist/components/RoomParticipantView/StreamPlayManager/StreamInfoManager.d.ts

@@ -0,0 +1,58 @@
+import { VideoStreamQuality, StreamInfo } from './types';
+import { VideoStreamType } from '../../../types';
+
+/**
+ * 流信息管理器 - 负责视图绑定和流信息管理
+ * TODO: StreamInfoManager 里面信息的增加和删除应该只和 onUserVideoStateChanged 的回调同步
+ * 职责：
+ * 1. 管理流信息的存储和查询
+ * 2. 处理视图的绑定和解绑
+ * 3. 提供流状态查询接口
+ * 4. 管理视图ID转换
+ */
+export declare class StreamInfoManager {
+    private streamInfoMap;
+    addView(options: {
+        userId: string;
+        streamType: VideoStreamType;
+        view: HTMLDivElement;
+        initVisible?: boolean;
+    }): StreamInfo;
+    removeView(options: {
+        userId: string;
+        streamType: VideoStreamType;
+        view: HTMLDivElement;
+    }): StreamInfo | null;
+    setViewVisible(options: {
+        userId: string;
+        streamType: VideoStreamType;
+        view: HTMLDivElement;
+        isVisible: boolean;
+    }): StreamInfo | null;
+    updateStreamInfo(options: {
+        userId: string;
+        streamType: VideoStreamType;
+        updates: Partial<StreamInfo>;
+    }): StreamInfo | null;
+    getStreamInfo(userId: string, streamType: VideoStreamType): StreamInfo | null;
+    isStreamPlaying(userId: string, streamType: VideoStreamType): boolean;
+    getPlayingStreams(): Array<{
+        userId: string;
+        streamType: VideoStreamType;
+        viewCount: number;
+        videoQuality?: VideoStreamQuality;
+    }>;
+    getAllStreams(): Array<{
+        userId: string;
+        streamType: VideoStreamType;
+        streamInfo: StreamInfo;
+    }>;
+    getVisibleViewIdList(userId: string, streamType: VideoStreamType): string[];
+    getAllViewIdList(userId: string, streamType: VideoStreamType): string[];
+    isViewExists(view: string | HTMLDivElement): boolean;
+    getValidViews(views: (string | HTMLDivElement)[]): (string | HTMLDivElement)[];
+    clear(): void;
+    private getStreamKey;
+    private parseStreamKey;
+}
+export default StreamInfoManager;

package/dist/components/RoomParticipantView/StreamPlayManager/StreamInfoManager.js

@@ -0,0 +1,97 @@
+var l = Object.defineProperty;
+var f = (o, e, t) => e in o ? l(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t;
+var m = (o, e, t) => f(o, typeof e != "symbol" ? e + "" : e, t);
+import { VideoStreamQuality as u } from "./types.js";
+import { FillMode as g } from "../../../types/participant.js";
+class c {
+  constructor() {
+    // 存储流信息的映射表，key: userId_streamType, value: 流信息
+    m(this, "streamInfoMap", /* @__PURE__ */ new Map());
+  }
+  addView(e) {
+    const { userId: t, streamType: s, view: i, initVisible: a } = e, r = this.getStreamKey(t, s), n = this.streamInfoMap.get(r) || {
+      views: /* @__PURE__ */ new Map(),
+      isPlaying: !1,
+      videoQuality: u.LD,
+      fillMode: g.Fit
+    };
+    return n.views.has(i) || n.views.set(i, { isVisible: a || !1 }), this.streamInfoMap.set(r, n), console.log(`[StreamPlay][StreamInfoManager] 视图添加: ${r}, 视图数量: ${n.views.size}`), n;
+  }
+  removeView(e) {
+    const { userId: t, streamType: s, view: i } = e, a = this.getStreamKey(t, s), r = this.streamInfoMap.get(a);
+    return r ? (r.views.delete(i), r.views.size === 0 ? (this.streamInfoMap.delete(a), console.log(`[StreamPlay][StreamInfoManager] remove stream info: ${a}`), null) : (this.streamInfoMap.set(a, r), console.log(`[StreamPlay][StreamInfoManager] ${a} remove view: ${i}, remaining view count: ${r.views.length}`), r)) : null;
+  }
+  setViewVisible(e) {
+    const { userId: t, streamType: s, view: i, isVisible: a } = e, r = this.getStreamInfo(t, s);
+    if (!r)
+      return null;
+    const n = r.views.get(i);
+    return n ? n.isVisible = a : r.views.set(i, { isVisible: a }), this.streamInfoMap.set(this.getStreamKey(t, s), r), r;
+  }
+  updateStreamInfo(e) {
+    const { userId: t, streamType: s, updates: i } = e, a = this.getStreamKey(t, s), r = this.streamInfoMap.get(a);
+    return r ? (Object.assign(r, i), this.streamInfoMap.set(a, r), r) : null;
+  }
+  getStreamInfo(e, t) {
+    const s = this.getStreamKey(e, t);
+    return this.streamInfoMap.get(s) || null;
+  }
+  isStreamPlaying(e, t) {
+    const s = this.getStreamInfo(e, t);
+    return (s == null ? void 0 : s.isPlaying) || !1;
+  }
+  getPlayingStreams() {
+    const e = [];
+    return Array.from(this.streamInfoMap.entries()).forEach(([t, s]) => {
+      if (s.isPlaying) {
+        const [i, a] = this.parseStreamKey(t);
+        e.push({
+          userId: i,
+          streamType: a,
+          viewCount: s.views.size,
+          videoQuality: s.videoQuality
+        });
+      }
+    }), e;
+  }
+  getAllStreams() {
+    const e = [];
+    for (const [t, s] of this.streamInfoMap) {
+      const [i, a] = this.parseStreamKey(t);
+      e.push({
+        userId: i,
+        streamType: a,
+        streamInfo: s
+      });
+    }
+    return e;
+  }
+  getVisibleViewIdList(e, t) {
+    const s = this.getStreamInfo(e, t);
+    return s ? Array.from(s.views.entries()).filter(([i, a]) => a.isVisible).map(([i]) => i.id || "") : [];
+  }
+  getAllViewIdList(e, t) {
+    const s = this.getStreamInfo(e, t);
+    return s ? Array.from(s.views.keys()).map((i) => i.id || "") : [];
+  }
+  isViewExists(e) {
+    return typeof e == "string" ? !!document.getElementById(e) : !!e && document.contains(e);
+  }
+  getValidViews(e) {
+    return e.filter((t) => this.isViewExists(t));
+  }
+  clear() {
+    this.streamInfoMap.clear();
+  }
+  getStreamKey(e, t) {
+    return `${e}_${t}`;
+  }
+  parseStreamKey(e) {
+    const t = e.split("_");
+    return [t.slice(0, t.length - 1).join("_"), t.slice(-1)[0]];
+  }
+}
+export {
+  c as StreamInfoManager,
+  c as default
+};

package/dist/components/RoomParticipantView/StreamPlayManager/StreamPlayer.d.ts

@@ -0,0 +1,46 @@
+import { VideoStreamType, FillMode } from '../../../types';
+import { VideoStreamQuality } from './types';
+
+/**
+ * 流播放器 - 负责视频流的播放控制
+ * 职责：
+ * 1. 管理视频流的播放和停止
+ * 2. 处理本地和远程流的不同逻辑
+ * 3. 设置视频渲染参数
+ * 4. 管理流类型转换
+ */
+export declare class StreamPlayer {
+    startPlayVideo(options: {
+        userId: string;
+        streamType: VideoStreamType;
+        videoQuality?: VideoStreamQuality;
+        viewIdList: string[];
+    }): Promise<void>;
+    stopPlayVideo(options: {
+        userId: string;
+        streamType: VideoStreamType;
+        videoQuality?: VideoStreamQuality;
+    }): Promise<void>;
+    /**
+     * 更新视频视图绑定
+     */
+    updateVideoView(options: {
+        userId: string;
+        streamType: VideoStreamType;
+        viewIdList: string[];
+    }): Promise<void>;
+    updateVideoQuality(options: {
+        userId: string;
+        streamType: VideoStreamType;
+        videoQuality: VideoStreamQuality;
+    }): Promise<void>;
+    setRenderParams(options: {
+        userId: string;
+        streamType: VideoStreamType;
+        renderParams: {
+            fillMode?: FillMode;
+        };
+    }): Promise<void>;
+    private getPlayStreamType;
+}
+export default StreamPlayer;

package/dist/components/RoomParticipantView/StreamPlayManager/StreamPlayer.js

@@ -0,0 +1,100 @@
+import { TRTCVideoFillMode as w, TRTCVideoRotation as S, TRTCVideoMirrorType as V } from "@tencentcloud/tuiroom-engine-js";
+import { useRoomEngine as P } from "../../../hooks/useRoomEngine.js";
+import { useLoginState as R } from "../../../states/LoginState.js";
+import { VideoStreamQuality as f } from "./types.js";
+import { VideoStreamType as u, FillMode as p } from "../../../types/participant.js";
+import { TUIVideoStreamType as n } from "../../../types/types.js";
+const y = P(), { loginUserInfo: c } = R();
+class $ {
+  async startPlayVideo(l) {
+    var i, s, r, d;
+    const { userId: e, streamType: t, videoQuality: o, viewIdList: a } = l;
+    if (a.length === 0)
+      throw console.warn(`[StreamPlayer] ${e}_${t} No valid views to play video`), new Error(`[StreamPlayer] ${e}_${t} No valid views to play video`);
+    try {
+      const m = this.getPlayStreamType(t, o);
+      e === ((i = c.value) == null ? void 0 : i.userId) ? (m === n.kCameraStream || m === n.kCameraStreamLow) && await ((s = y.instance) == null ? void 0 : s.setLocalVideoView({ view: a })) : (await ((r = y.instance) == null ? void 0 : r.setRemoteVideoView({
+        userId: e,
+        streamType: m,
+        view: a
+      })), await ((d = y.instance) == null ? void 0 : d.startPlayRemoteVideo({
+        userId: e,
+        streamType: m
+      })), console.log(`[StreamPlayer] startPlayRemoteVideo: ${e}_${t}, videoQuality: ${o}`));
+    } catch (m) {
+      throw console.error("[StreamPlayer] startPlayVideo error:", m), m;
+    }
+  }
+  async stopPlayVideo(l) {
+    var a, i, s;
+    const { userId: e, streamType: t, videoQuality: o } = l;
+    try {
+      const r = this.getPlayStreamType(t, o);
+      e === ((a = c.value) == null ? void 0 : a.userId) ? (r === n.kCameraStream || r === n.kCameraStreamLow) && await ((i = y.instance) == null ? void 0 : i.setLocalVideoView({ view: null })) : await ((s = y.instance) == null ? void 0 : s.stopPlayRemoteVideo({
+        userId: e,
+        streamType: r
+      }));
+    } catch (r) {
+      throw console.error("[StreamPlayer] stopPlayVideo error:", r), r;
+    }
+  }
+  /**
+   * 更新视频视图绑定
+   */
+  async updateVideoView(l) {
+    var a, i, s;
+    const { userId: e, streamType: t, viewIdList: o } = l;
+    if (o.length === 0) {
+      console.warn("[StreamPlayer] No valid views to update");
+      return;
+    }
+    try {
+      const r = this.getPlayStreamType(t);
+      e === ((a = c.value) == null ? void 0 : a.userId) ? (r === n.kCameraStream || r === n.kCameraStreamLow) && await ((i = y.instance) == null ? void 0 : i.setLocalVideoView({ view: o })) : await ((s = y.instance) == null ? void 0 : s.setRemoteVideoView({
+        userId: e,
+        streamType: r,
+        view: o
+      })), console.log(`[StreamPlayer] 视图更新: ${e}_${t}, 视图数量: ${o.length}`);
+    } catch (r) {
+      throw console.error("[StreamPlayer] updateVideoView error:", r), r;
+    }
+  }
+  async updateVideoQuality(l) {
+    var i, s;
+    const { userId: e, streamType: t, videoQuality: o } = l;
+    if (e === ((i = c.value) == null ? void 0 : i.userId) || t === u.Screen)
+      return;
+    const a = this.getPlayStreamType(t, o);
+    await ((s = y.instance) == null ? void 0 : s.startPlayRemoteVideo({
+      userId: e,
+      streamType: a
+    }));
+  }
+  async setRenderParams(l) {
+    var d, m;
+    const { userId: e, streamType: t, renderParams: o } = l, a = (d = y.instance) == null ? void 0 : d.getTRTCCloud(), i = this.getPlayStreamType(t), r = {
+      [p.Fill]: w.TRTCVideoFillMode_Fill,
+      [p.Fit]: w.TRTCVideoFillMode_Fit
+    }[o.fillMode || p.Fit];
+    try {
+      e === ((m = c.value) == null ? void 0 : m.userId) ? await (a == null ? void 0 : a.setLocalRenderParams({
+        mirrorType: V.TRTCVideoMirrorType_Auto,
+        rotation: S.TRTCVideoRotation0,
+        fillMode: r
+      })) : await (a == null ? void 0 : a.setRemoteRenderParams(e, i, {
+        mirrorType: V.TRTCVideoMirrorType_Auto,
+        rotation: S.TRTCVideoRotation0,
+        fillMode: r
+      }));
+    } catch (T) {
+      throw console.error("[StreamPlayer] setRenderParams error:", T), T;
+    }
+  }
+  getPlayStreamType(l, e) {
+    return l === u.Screen ? n.kScreenStream : e === f.LD ? n.kCameraStreamLow : n.kCameraStream;
+  }
+}
+export {
+  $ as StreamPlayer,
+  $ as default
+};

package/dist/components/RoomParticipantView/StreamPlayManager/VideoQualityManager.d.ts

@@ -0,0 +1,92 @@
+import { VideoStreamType } from '../../../types';
+import { VideoStreamQuality } from './types';
+
+/**
+ * 视频质量管理器 - 负责 DOM 尺寸监控和质量切换
+ * 职责：
+ * 1. 监听 DOM 元素的尺寸变化
+ * 2. 计算最优的流质量
+ * 3. 管理大流分配策略
+ * 4. 提供质量计算接口
+ */
+export declare class VideoQualityManager {
+    private resizeObserver;
+    private bodyResizeObserver;
+    private domInfoMap;
+    private highQualityDomMap;
+    private cachedBodyArea;
+    private loginUserId;
+    private onQualityChange;
+    constructor({ onQualityChange, loginUserId }: {
+        onQualityChange: (options: {
+            userId: string;
+            streamType: VideoStreamType;
+            newQuality: VideoStreamQuality;
+            oldQuality?: VideoStreamQuality;
+            reason: string;
+        }) => void;
+        loginUserId: string;
+    });
+    setLoginUserId(loginUserId: string): void;
+    private pendingEntries;
+    /**
+     * 初始化 ResizeObserver
+     */
+    private initResizeObserver;
+    /**
+     * 初始化屏幕面积缓存
+     */
+    private initBodyAreaCache;
+    private handleBodyResize;
+    /**
+     * 更新屏幕面积缓存
+     */
+    private updateBodyAreaCache;
+    /**
+     * 添加 DOM 元素监听
+     */
+    observe(options: {
+        userId: string;
+        streamType: VideoStreamType;
+        viewElement: HTMLDivElement;
+    }): boolean;
+    /**
+     * 移除 DOM 元素监听
+     */
+    unobserve(viewElement: HTMLDivElement): void;
+    /**
+     * 处理 DOM 尺寸变化
+     */
+    private handleResize;
+    /**
+     * 计算最优质量
+     */
+    calculateOptimalQuality(options: {
+        userId: string;
+        streamType: VideoStreamType;
+        views?: (HTMLDivElement)[];
+    }): VideoStreamQuality;
+    private tryToRemoveHighQualityDom;
+    /**
+     * 更新大流映射
+     */
+    private updateHighQualityMap;
+    private removeHighQualityDom;
+    /**
+     * 根据流信息获取相关视图
+     */
+    private getViewsByStream;
+    /**
+     * 获取 DOM 元素的尺寸
+     */
+    private getDomRect;
+    /**
+     * 清理所有资源
+     */
+    destroy(): void;
+    /**
+     * 获取监听的 DOM 数量
+     */
+    getObservedCount(): number;
+}
+export default VideoQualityManager;