tuikit-atomicx-vue3 3.4.1 → 3.5.0-beta.7

package/dist/components/LiveView/PlayerControl/PlayerControl.js

@@ -0,0 +1,168 @@
+import $ from "./AudioControl.js";
+import { defineComponent as ee, ref as v, onMounted as te, onBeforeUnmount as oe, createBlock as p, openBlock as C, Transition as ne, withCtx as se, withDirectives as le, createElementVNode as s, normalizeClass as ce, unref as o, createVNode as m, vShow as ue } from "vue";
+import { useUIKit as re, IconPause as ae, IconPlay as ie, IconPictureInPicture as de, IconFullScreen as ve, TUIToast as me, TOAST_TYPE as he } from "@tencentcloud/uikit-base-component-vue3";
+import fe from "./MultiResolution.js";
+import { usePlayerControlState as pe } from "./PlayerControlState.js";
+import { isMobile as u } from "../../../utils/env.js";
+import { _ as Ce } from "../../../_plugin-vue_export-helper-CHgC5LLL.js";
+const _e = { class: "control-buttons" }, Pe = ["title"], ye = { class: "right-controls" }, Ee = { class: "control-btn audio-control-btn" }, Te = ["title"], Le = ["title"], Ie = 3e3, ge = /* @__PURE__ */ ee({
+  __name: "PlayerControl",
+  props: {
+    isLandscapeStyleMode: { type: Boolean }
+  },
+  setup(w) {
+    const {
+      isMuted: _,
+      isPlaying: h,
+      isFullscreen: P,
+      isPictureInPicture: f,
+      currentVolume: S,
+      pause: b,
+      resume: x,
+      requestPictureInPicture: A,
+      exitPictureInPicture: y,
+      requestFullscreen: k,
+      exitFullscreen: F,
+      setVolume: V,
+      setMute: z,
+      cleanup: D
+    } = pe(), R = w, { t: l } = re(), n = v(), c = v(!1), r = v(null), B = () => {
+      h.value ? b() : x();
+    }, O = async () => {
+      let e = !1;
+      f.value ? e = await y() : e = await A(), e || me({
+        type: he.ERROR,
+        message: l("The system does not support picture-in-picture mode")
+      });
+    }, N = () => {
+      console.log("handleFullscreen"), P.value ? F() : k();
+    }, U = async (e) => {
+      u && d(), await V(e);
+    }, X = async () => {
+      await z(!_.value);
+    }, d = () => {
+      a(), r.value = window.setTimeout(() => {
+        c.value = !1, r.value = null;
+      }, Ie);
+    }, a = () => {
+      r.value && (clearTimeout(r.value), r.value = null);
+    }, E = () => {
+      a(), c.value = !0;
+    }, T = () => {
+      d();
+    }, Y = () => {
+      if (!u && n.value) {
+        const { parentElement: e } = n.value;
+        e && (e.addEventListener("mouseover", E), e.addEventListener("mouseout", T));
+      }
+    }, q = () => {
+      if (!u && n.value) {
+        const { parentElement: e } = n.value;
+        e && (e.removeEventListener("mouseover", E), e.removeEventListener("mouseout", T));
+      }
+    }, i = v(null), H = (e, t) => Math.sqrt((t.clientX - e.x) ** 2 + (t.clientY - e.y) ** 2), K = (e) => {
+      var t;
+      return ((t = n.value) == null ? void 0 : t.contains(e)) || !1;
+    }, j = (e) => {
+      const t = document.getElementById("live-core-view-container");
+      return (t == null ? void 0 : t.contains(e)) || !1;
+    }, G = () => {
+      a(), d();
+    }, J = () => {
+      c.value = !c.value, c.value && d();
+    }, L = (e) => {
+      if (e.touches.length === 1) {
+        const t = e.touches[0];
+        i.value = {
+          x: t.clientX,
+          y: t.clientY
+        };
+      }
+    }, I = (e) => {
+      n.value && n.value.contains(e.target) && a();
+    }, g = (e) => {
+      if (!i.value)
+        return;
+      const t = e.changedTouches[0];
+      if (H(i.value, t) > 20) {
+        i.value = null;
+        return;
+      }
+      const M = e.target;
+      K(M) ? G() : j(M) ? J() : c.value = !1, i.value = null;
+    }, Q = () => {
+      u && (document.addEventListener("touchstart", L, !0), document.addEventListener("touchmove", I, !0), document.addEventListener("touchend", g, !0));
+    }, W = () => {
+      u && (document.removeEventListener("touchstart", L, !0), document.removeEventListener("touchmove", I, !0), document.removeEventListener("touchend", g, !0));
+    }, Z = () => {
+      W(), q(), a();
+    };
+    return te(() => {
+      Q(), Y();
+    }), oe(() => {
+      f.value && y(), Z(), D();
+    }), (e, t) => (C(), p(ne, { name: "player-control" }, {
+      default: se(() => [
+        le(s("div", {
+          ref_key: "playerControlRef",
+          ref: n,
+          class: ce([
+            "playback-controls",
+            o(u) ? "mobile-mode" : "pc-mode",
+            { "mobile-landscape-mode": R.isLandscapeStyleMode }
+          ])
+        }, [
+          s("div", _e, [
+            s("span", {
+              class: "control-btn play-pause-btn",
+              title: o(h) ? o(l)("Pause") : o(l)("Play"),
+              onClick: B
+            }, [
+              o(h) ? (C(), p(o(ae), {
+                key: 0,
+                size: "20"
+              })) : (C(), p(o(ie), {
+                key: 1,
+                size: "20"
+              }))
+            ], 8, Pe),
+            t[0] || (t[0] = s("div", { class: "center-controls" }, null, -1)),
+            s("div", ye, [
+              m(fe),
+              s("span", Ee, [
+                m($, {
+                  class: "audio-control-icon",
+                  "icon-size": 20,
+                  volume: o(S),
+                  "is-muted": o(_),
+                  onVolumeChange: U,
+                  onMuteChange: X
+                }, null, 8, ["volume", "is-muted"])
+              ]),
+              s("span", {
+                class: "control-btn",
+                title: o(f) ? o(l)("Exit Picture in Picture") : o(l)("Picture in Picture"),
+                onClick: O
+              }, [
+                m(o(de), { size: "20" })
+              ], 8, Te),
+              s("span", {
+                class: "control-btn fullscreen-btn",
+                title: o(P) ? o(l)("Exit Fullscreen") : o(l)("Fullscreen"),
+                onClick: N
+              }, [
+                m(o(ve), { size: "20" })
+              ], 8, Le)
+            ])
+          ])
+        ], 2), [
+          [ue, c.value]
+        ])
+      ]),
+      _: 1
+    }));
+  }
+}), ze = /* @__PURE__ */ Ce(ge, [["__scopeId", "data-v-f07ad1d4"]]);
+export {
+  ze as default
+};

package/dist/components/{LiveCoreView → LiveView}/PlayerControl/PlayerControlState.d.ts

@@ -19,6 +19,7 @@ export interface PlayerControlState {
     isLandscapeStyleMode: Ref<boolean>;
     isPictureInPicture: Ref<boolean>;
     currentVolume: Ref<number>;
+    isMuted: Ref<boolean>;
     resolutionList: Ref<Resolution[]>;
     currentResolution: Ref<Resolution | undefined>;
     resume: () => Promise<boolean>;
@@ -28,9 +29,8 @@ export interface PlayerControlState {
     requestPictureInPicture: () => Promise<boolean>;
     exitPictureInPicture: () => Promise<boolean>;
     switchResolution: (resolution: Resolution) => Promise<boolean>;
-    getResolutionList: (roomId: string) => Promise<Resolution[]>;
-    initializeResolution: (roomId: string, applyResolution?: boolean) => Promise<void>;
     setVolume: (volume: number) => Promise<boolean>;
+    setMute: (muted: boolean) => Promise<boolean>;
     changeFillMode: (fillMode: FillMode) => Promise<boolean>;
     cleanup: () => void;
 }

package/dist/components/LiveView/PlayerControl/PlayerControlState.js

@@ -0,0 +1,222 @@
+import { ref as o, computed as N, watch as B } from "vue";
+import { TUIVideoQuality as L } from "@tencentcloud/tuiroom-engine-js";
+import { useRoomEngine as K } from "../../../hooks/useRoomEngine.js";
+import { useLiveSeatState as W } from "../../../states/LiveSeatState/index.js";
+import { hadLandscapeRotationToUndo as Z, getDeviceType as ee, shouldRotateToLandscapeForFullscreen as te } from "./utils/deviceDetection.js";
+import { EventListenerManager as ne, DOMElementGetter as d } from "./utils/domHelpers.js";
+import { OrientationManager as P, StyleManager as S, FullscreenMode as M, FullscreenManager as b } from "./utils/fullscreenManager.js";
+import { useLiveListState as ae } from "../../../states/LiveListState/LiveListState.js";
+var re = /* @__PURE__ */ ((a) => (a.CONTAIN = "contain", a.COVER = "cover", a.FILL = "fill", a))(re || {}), se = ((a) => (a[a.R360P = L.kVideoQuality_360p] = "R360P", a[a.R540P = L.kVideoQuality_540p] = "R540P", a[a.R720P = L.kVideoQuality_720p] = "R720P", a[a.R1080P = L.kVideoQuality_1080p] = "R1080P", a))(se || {});
+const l = {
+  // Default volume level when component initializes (100% volume)
+  DEFAULT_VOLUME: 100,
+  // Minimum allowed volume level (silent)
+  MIN_VOLUME: 0,
+  // Maximum allowed volume level (full volume)
+  MAX_VOLUME: 100,
+  // Volume level when muted (silent)
+  MUTE_VOLUME: 0
+}, ie = {
+  // Delay in milliseconds before resuming playback after leaving picture-in-picture
+  // Allows browser to handle state transitions naturally
+  PIP_RESUME_DELAY: 300
+}, x = {
+  // Index of the first element in an array
+  FIRST_INDEX: 0
+}, v = o(!0), V = o(
+  "contain"
+  /* CONTAIN */
+), i = o(!1), E = o(!1), w = o(!1), m = o(l.DEFAULT_VOLUME), F = o(!1);
+let I = l.DEFAULT_VOLUME;
+const h = o([]), p = o(), u = K();
+function pe() {
+  const { currentLive: a } = ae(), { canvas: f } = W(), c = new ne(), O = `player-control-${Date.now()}`, g = N(
+    () => f.value ? f.value.width > f.value.height : !1
+  ), C = N(
+    () => f.value ? f.value.width < f.value.height : !1
+  ), y = ee(), r = async (e, t, n) => {
+    try {
+      return await e();
+    } catch (s) {
+      return console.error(`${t} operation failed:`, s), n;
+    }
+  }, R = async () => r(async () => {
+    var e;
+    return await ((e = u.instance) == null ? void 0 : e.callExperimentalAPI(JSON.stringify({
+      api: "resume",
+      params: {}
+    }))), v.value = !0, !0;
+  }, "Resume playback", !1), D = async () => r(async () => {
+    var e;
+    return await ((e = u.instance) == null ? void 0 : e.callExperimentalAPI(JSON.stringify({
+      api: "pause",
+      params: {}
+    }))), v.value = !1, !0;
+  }, "Pause playback", !1), k = (e) => {
+    if (!i.value || !g.value)
+      return;
+    const t = d.getAllElements();
+    if (!t.view) {
+      console.warn("live-core-view element not found for orientation change handling");
+      return;
+    }
+    S.smartApplyLandscapeStyles(t.view, e);
+  }, q = async () => r(async () => {
+    const e = d.getAllElements(), t = d.validateElements(e);
+    if (!t.isValid)
+      throw new Error(`Missing required DOM elements: ${t.missingElements.join(", ")}`);
+    const n = te(y, g.value), s = await b.requestFullscreen(
+      e.container,
+      e.view,
+      y,
+      C.value,
+      n
+    );
+    return s.success ? i.value = !0 : console.error("Fullscreen request failed:", s.error), E.value = s.shouldRotateToLandscape, s;
+  }, "Request fullscreen", { success: !1, mode: M.CSS_SIMULATED, shouldRotateToLandscape: !1 }), Q = async () => r(async () => {
+    const e = d.getAllElements();
+    if (!e.view)
+      throw new Error("live-core-view element not found");
+    const t = Z(y, g.value), n = await b.exitFullscreen(
+      e.view,
+      y,
+      t
+    );
+    return n.mode === M.CSS_SIMULATED && (i.value = !1), n.success || console.error("Fullscreen exit failed:", n.error), E.value = !1, n;
+  }, "Exit fullscreen", { success: !1, mode: M.CSS_SIMULATED, shouldRotateToLandscape: !1 }), X = async () => r(async () => {
+    const e = d.getVideoElement();
+    if (!e)
+      throw new Error("Video element not found");
+    if (!e.requestPictureInPicture)
+      throw new Error("Picture-in-picture not supported in current environment");
+    return U(), await e.requestPictureInPicture(), !0;
+  }, "Request picture-in-picture", !1), J = async () => r(async () => {
+    if (!document.exitPictureInPicture)
+      throw new Error("Exit picture-in-picture not supported in current environment");
+    return await document.exitPictureInPicture(), !0;
+  }, "Exit picture-in-picture", !1), T = async (e) => r(async () => {
+    if (!u.instance)
+      throw new Error("Room engine instance not available");
+    return console.debug("Switching to resolution:", e), await u.instance.callExperimentalAPI(
+      JSON.stringify({
+        api: "switchPlaybackQuality",
+        params: {
+          quality: e,
+          autoSwitch: !1
+        }
+      })
+    ), v.value || (v.value = !0), p.value = e, !0;
+  }, "Switch resolution", !1), $ = async (e) => r(async () => {
+    if (!u.instance)
+      throw new Error("Room engine instance not available");
+    return await u.instance.callExperimentalAPI(
+      JSON.stringify({
+        api: "queryPlaybackQualityList",
+        params: {
+          roomId: e
+        }
+      })
+    ) || [];
+  }, "Get resolution list", []), z = async (e, t = !0) => {
+    try {
+      const n = await $(e);
+      if (h.value = n, n.length === x.FIRST_INDEX) {
+        console.warn("[Resolution] No resolutions available for room:", e), p.value = void 0;
+        return;
+      }
+      const s = n[x.FIRST_INDEX];
+      p.value = s, t && await T(s);
+    } catch (n) {
+      console.error("[Resolution] Failed to initialize resolution:", n);
+    }
+  }, A = async (e) => r(async () => {
+    var t;
+    if (e < l.MIN_VOLUME || e > l.MAX_VOLUME)
+      throw new Error(`Volume value must be between ${l.MIN_VOLUME}-${l.MAX_VOLUME}`);
+    return await ((t = u.instance) == null ? void 0 : t.setAudioPlayoutVolume({ volume: e })), m.value = e, I = e, F.value = e == l.MUTE_VOLUME, !0;
+  }, "Set volume", !1), G = async (e) => r(async () => {
+    var n;
+    let t;
+    return e ? (I = m.value, t = l.MUTE_VOLUME) : t = I || l.DEFAULT_VOLUME, await ((n = u.instance) == null ? void 0 : n.setAudioPlayoutVolume({ volume: t })), m.value = t, F.value = e, !0;
+  }, "Set mute", !1), Y = async (e) => r(async () => (V.value = e, !0), "Change fill mode", !1), _ = () => {
+    try {
+      const e = d.getAllElements();
+      if (!e.view) {
+        console.warn("View element not found for fullscreen exit cleanup");
+        return;
+      }
+      S.removeFullscreenStyles(e.view), S.removeLandscapeStyles(e.view), y !== "desktop" && P.unlockOrientation().catch(() => {
+      }), E.value = !1;
+    } catch (e) {
+      console.error("Fullscreen exit cleanup failed:", e);
+    }
+  }, j = () => {
+    const e = () => {
+      const n = !!document.fullscreenElement, s = i.value;
+      i.value = n, s && !n && _();
+    };
+    c.addListener("fullscreenchange", document, "fullscreenchange", e), c.addListener("webkitfullscreenchange", document, "webkitfullscreenchange", e), c.addListener("mozfullscreenchange", document, "mozfullscreenchange", e), c.addListener("MSFullscreenChange", document, "MSFullscreenChange", e);
+    const t = () => {
+      document.visibilityState === "visible" && i.value && (document.fullscreenElement || (i.value = !1, _()));
+    };
+    c.addListener("visibilitychange", document, "visibilitychange", t);
+  }, U = () => {
+    const e = d.getVideoElement();
+    if (!e) {
+      console.warn("Video element not found for setting up event listeners");
+      return;
+    }
+    const t = () => {
+      w.value = !0;
+    }, n = () => {
+      w.value = !1, setTimeout(R, ie.PIP_RESUME_DELAY);
+    };
+    c.addListener("enterpictureinpicture", e, "enterpictureinpicture", t), c.addListener("leavepictureinpicture", e, "leavepictureinpicture", n);
+  }, H = () => {
+    P.removeOrientationListener(O), c.removeAllListeners();
+  };
+  return j(), U(), P.addOrientationListener(O, k), B(
+    () => {
+      var e;
+      return (e = a.value) == null ? void 0 : e.liveId;
+    },
+    async (e) => {
+      e && (v.value = !0, w.value = !1, i.value = !1, h.value = [], p.value = void 0, await A(m.value), await z(e, !1), console.log("[PlayerControl] State after entering room:", JSON.stringify({
+        isPlaying: v.value,
+        currentFillMode: V.value,
+        isFullscreen: i.value,
+        isLandscapeStyleMode: E.value,
+        isPictureInPicture: w.value,
+        currentVolume: m.value,
+        resolutionList: h.value,
+        currentResolution: p.value
+      })));
+    }
+  ), {
+    isPlaying: v,
+    currentFillMode: V,
+    isFullscreen: i,
+    isLandscapeStyleMode: E,
+    isPictureInPicture: w,
+    currentVolume: m,
+    isMuted: F,
+    resolutionList: h,
+    currentResolution: p,
+    resume: R,
+    pause: D,
+    requestFullscreen: q,
+    exitFullscreen: Q,
+    requestPictureInPicture: X,
+    exitPictureInPicture: J,
+    switchResolution: T,
+    setVolume: A,
+    setMute: G,
+    changeFillMode: Y,
+    cleanup: H
+  };
+}
+export {
+  re as FillMode,
+  se as Resolution,
+  pe as usePlayerControlState
+};

package/dist/components/{LiveCoreView → LiveView}/PlayerControl/utils/domHelpers.d.ts

@@ -40,7 +40,8 @@ export declare class DOMElementGetter {
      */
     static getTcPlayerElement(): HTMLElement | null;
     /**
-     * Validate if elements exist
+     * Validate if required elements exist for fullscreen
+     * Note: video element is optional because canvas rendering (TRTC SDK) doesn't use video
      */
     static validateElements(elements: {
         container?: HTMLElement | null;
@@ -73,3 +74,9 @@ export declare class EventListenerManager {
      */
     getListenerCount(): number;
 }
+/**
+ * Wait for video element to be mounted in DOM
+ * @param timeout Maximum wait time in milliseconds
+ * @returns Promise that resolves with video element or null if timeout
+ */
+export declare const waitForVideoMounted: (timeout?: number) => Promise<HTMLVideoElement | null>;

package/dist/components/LiveView/PlayerControl/utils/domHelpers.js

@@ -0,0 +1,132 @@
+var L = Object.defineProperty;
+var m = (i, e, t) => e in i ? L(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
+var d = (i, e, t) => m(i, typeof e != "symbol" ? e + "" : e, t);
+const c = {
+  LIVE_CORE_VIEW_CONTAINER: ".live-core-view-container",
+  LIVE_CORE_VIEW: ".live-core-view",
+  VIDEO_ELEMENT: "#atomicx-live-stream-content video",
+  TCPLAYER_ELEMENT: ".tcplayer"
+};
+class s {
+  /**
+   * Get live-core-view-container element
+   */
+  static getLiveCoreViewContainer() {
+    return document.querySelector(c.LIVE_CORE_VIEW_CONTAINER);
+  }
+  /**
+   * Get live-core-view element
+   */
+  static getLiveCoreView() {
+    return document.querySelector(c.LIVE_CORE_VIEW);
+  }
+  /**
+   * Get video element
+   */
+  static getVideoElement() {
+    return document.querySelector(c.VIDEO_ELEMENT);
+  }
+  /**
+   * Get all required DOM elements
+   */
+  static getAllElements() {
+    return {
+      container: s.getLiveCoreViewContainer(),
+      view: s.getLiveCoreView(),
+      video: s.getVideoElement()
+    };
+  }
+  /**
+   * Check if tcplayer element exists in live-core-view-container
+   */
+  static hasTcPlayerElement() {
+    const e = s.getLiveCoreViewContainer();
+    return e ? e.querySelector(c.TCPLAYER_ELEMENT) !== null : !1;
+  }
+  /**
+   * Get tcplayer element from live-core-view-container
+   */
+  static getTcPlayerElement() {
+    const e = s.getLiveCoreViewContainer();
+    return e ? e.querySelector(c.TCPLAYER_ELEMENT) : null;
+  }
+  /**
+   * Validate if required elements exist for fullscreen
+   * Note: video element is optional because canvas rendering (TRTC SDK) doesn't use video
+   */
+  static validateElements(e) {
+    const t = [];
+    return e.container === null && t.push("live-core-view-container"), e.view === null && t.push("live-core-view"), {
+      isValid: t.length === 0,
+      missingElements: t
+    };
+  }
+}
+class C {
+  constructor() {
+    d(this, "listeners", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Add event listener
+   */
+  addListener(e, t, r, o) {
+    this.removeListener(e), t.addEventListener(r, o), this.listeners.set(e, { element: t, event: r, handler: o });
+  }
+  /**
+   * Remove specified event listener
+   */
+  removeListener(e) {
+    const t = this.listeners.get(e);
+    t && (t.element.removeEventListener(t.event, t.handler), this.listeners.delete(e));
+  }
+  /**
+   * Remove all event listeners
+   */
+  removeAllListeners() {
+    for (const [e] of this.listeners)
+      this.removeListener(e);
+  }
+  /**
+   * Get current listener count
+   */
+  getListenerCount() {
+    return this.listeners.size;
+  }
+}
+const g = (i = 3e3) => new Promise((e) => {
+  const t = document.querySelector("#atomicx-live-stream-content");
+  if (!t) {
+    e(null);
+    return;
+  }
+  let r = null;
+  const o = new MutationObserver((v) => {
+    for (const a of v)
+      a.type === "childList" && a.addedNodes.forEach((l) => {
+        if (l.nodeName === "VIDEO") {
+          const n = l, u = n.onvolumechange;
+          n.onvolumechange = null;
+          const E = () => {
+            r && clearTimeout(r), o.disconnect(), n.removeEventListener("loadeddata", E), setTimeout(() => {
+              n.onvolumechange = u;
+            }, 100), e(n);
+          };
+          n.readyState >= 2 ? (r && clearTimeout(r), o.disconnect(), setTimeout(() => {
+            n.onvolumechange = u;
+          }, 100), e(n)) : n.addEventListener("loadeddata", E, { once: !0 });
+        }
+      });
+  });
+  o.observe(t, {
+    childList: !0,
+    subtree: !0
+  }), r = window.setTimeout(() => {
+    o.disconnect(), e(null);
+  }, i);
+});
+export {
+  s as DOMElementGetter,
+  c as DOM_SELECTORS,
+  C as EventListenerManager,
+  g as waitForVideoMounted
+};

package/dist/components/{LiveCoreView/i18n/zh-CN → LiveView/i18n/en-US}/index.d.ts

@@ -7,8 +7,8 @@ export declare const resource: {
     'Exit Picture in Picture': string;
     Fullscreen: string;
     'Exit Fullscreen': string;
-    Mute: string;
-    Unmute: string;
+    'Open Speaker': string;
+    'Close Speaker': string;
     'The system does not support picture-in-picture mode': string;
     'co-Hosting': string;
     'In battle': string;
@@ -16,4 +16,5 @@ export declare const resource: {
     '540P': string;
     '720P': string;
     '1080P': string;
+    Connecting: string;
 };

package/dist/components/{LiveCoreView → LiveView}/i18n/en-US/index.js

@@ -7,15 +7,16 @@ const e = {
   "Exit Picture in Picture": "Exit Picture in Picture",
   Fullscreen: "Fullscreen",
   "Exit Fullscreen": "Exit Fullscreen",
-  Mute: "Mute",
-  Unmute: "Unmute",
+  "Open Speaker": "Open Speaker",
+  "Close Speaker": "Close Speaker",
   "The system does not support picture-in-picture mode": "The system does not support picture-in-picture mode",
   "co-Hosting": "co-Hosting",
   "In battle": "In battle",
   "360P": "360P",
   "540P": "540P",
   "720P": "720P",
-  "1080P": "1080P"
+  "1080P": "1080P",
+  Connecting: "Connecting"
 };
 export {
   e as resource

package/dist/components/{LiveCoreView/i18n/en-US → LiveView/i18n/zh-CN}/index.d.ts

@@ -7,8 +7,8 @@ export declare const resource: {
     'Exit Picture in Picture': string;
     Fullscreen: string;
     'Exit Fullscreen': string;
-    Mute: string;
-    Unmute: string;
+    'Open Speaker': string;
+    'Close Speaker': string;
     'The system does not support picture-in-picture mode': string;
     'co-Hosting': string;
     'In battle': string;
@@ -16,4 +16,5 @@ export declare const resource: {
     '540P': string;
     '720P': string;
     '1080P': string;
+    Connecting: string;
 };

package/dist/components/{LiveCoreView → LiveView}/i18n/zh-CN/index.js

@@ -7,15 +7,16 @@ const e = {
   "Exit Picture in Picture": "退出画中画",
   Fullscreen: "全屏",
   "Exit Fullscreen": "退出全屏",
-  Mute: "静音",
-  Unmute: "取消静音",
+  "Open Speaker": "取消静音",
+  "Close Speaker": "静音",
   "The system does not support picture-in-picture mode": "系统不支持画中画模式",
   "co-Hosting": "连线中",
   "In battle": "PK中",
   "360P": "低清",
   "540P": "标清",
   "720P": "高清",
-  "1080P": "超清"
+  "1080P": "超清",
+  Connecting: "连线中"
 };
 export {
   e as resource