tuikit-atomicx-vue3 3.3.3 → 3.4.1

package/dist/components/LiveCoreView/PlayerControl/utils/fullscreenManager.js

@@ -1,72 +1,54 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var FullscreenMode = /* @__PURE__ */ ((FullscreenMode2) => {
-  FullscreenMode2["STANDARD"] = "standard";
-  FullscreenMode2["CSS_SIMULATED"] = "simulated";
-  return FullscreenMode2;
-})(FullscreenMode || {});
-const CSS_CLASSES = {
+var f = Object.defineProperty;
+var S = (r, e, t) => e in r ? f(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var o = (r, e, t) => S(r, typeof e != "symbol" ? e + "" : e, t);
+var L = /* @__PURE__ */ ((r) => (r.STANDARD = "standard", r.CSS_SIMULATED = "simulated", r))(L || {});
+const i = {
   FULLSCREEN: "fullscreen-mode",
   FULLSCREEN_PORTRAIT: "fullscreen-mode-portrait",
   LANDSCAPE: "landscape-mode"
 };
-class StyleManager {
+class l {
   /**
    * Apply fullscreen styles
    */
-  static applyFullscreenStyles(element, isPortrait = false) {
-    const className = isPortrait ? CSS_CLASSES.FULLSCREEN_PORTRAIT : CSS_CLASSES.FULLSCREEN;
-    element.classList.add(className);
+  static applyFullscreenStyles(e, t = !1) {
+    const n = t ? i.FULLSCREEN_PORTRAIT : i.FULLSCREEN;
+    e.classList.add(n);
   }
   /**
    * Remove fullscreen styles
    */
-  static removeFullscreenStyles(element) {
-    element.classList.remove(CSS_CLASSES.FULLSCREEN);
-    element.classList.remove(CSS_CLASSES.FULLSCREEN_PORTRAIT);
+  static removeFullscreenStyles(e) {
+    e.classList.remove(i.FULLSCREEN), e.classList.remove(i.FULLSCREEN_PORTRAIT);
   }
   /**
    * Apply landscape styles
    */
-  static applyLandscapeStyles(element) {
-    element.classList.add(CSS_CLASSES.LANDSCAPE);
+  static applyLandscapeStyles(e) {
+    e.classList.add(i.LANDSCAPE);
   }
   /**
    * Remove landscape styles
    */
-  static removeLandscapeStyles(element) {
-    element.classList.remove(CSS_CLASSES.LANDSCAPE);
+  static removeLandscapeStyles(e) {
+    e.classList.remove(i.LANDSCAPE);
   }
   /**
    * Smart landscape style adjustment - determine if CSS rotation is needed based on current device orientation
    */
-  static smartApplyLandscapeStyles(element, currentOrientation) {
-    if (currentOrientation === "landscape") {
-      this.removeLandscapeStyles(element);
-    } else {
-      this.applyLandscapeStyles(element);
-    }
+  static smartApplyLandscapeStyles(e, t) {
+    t === "landscape" ? this.removeLandscapeStyles(e) : this.applyLandscapeStyles(e);
   }
 }
-class OrientationManager {
+class a {
   /**
    * Request screen orientation
    */
-  static async requestOrientation(orientation) {
+  static async requestOrientation(e) {
     try {
-      if (screen.orientation && screen.orientation.lock) {
-        await screen.orientation.lock(orientation);
-        return true;
-      }
-      if (screen.orientation.webkitLockOrientation) {
-        const result = screen.orientation.webkitLockOrientation(orientation);
-        return !!result;
-      }
-      return false;
-    } catch (error) {
-      console.warn(`Screen orientation setting failed (${orientation}):`, error);
-      return false;
+      return screen.orientation && screen.orientation.lock ? (await screen.orientation.lock(e), !0) : screen.orientation.webkitLockOrientation ? !!screen.orientation.webkitLockOrientation(e) : !1;
+    } catch (t) {
+      return console.warn(`Screen orientation setting failed (${e}):`, t), !1;
     }
   }
   /**
@@ -74,14 +56,9 @@ class OrientationManager {
    */
   static async unlockOrientation() {
     try {
-      if (screen.orientation && screen.orientation.unlock) {
-        screen.orientation.unlock();
-        return true;
-      }
-      return false;
-    } catch (error) {
-      console.warn("Failed to unlock screen orientation:", error);
-      return false;
+      return screen.orientation && screen.orientation.unlock ? (screen.orientation.unlock(), !0) : !1;
+    } catch (e) {
+      return console.warn("Failed to unlock screen orientation:", e), !1;
     }
   }
   /**
@@ -89,104 +66,75 @@ class OrientationManager {
    */
   static getCurrentOrientation() {
     if (screen.orientation) {
-      const angle = screen.orientation.angle;
-      const type = screen.orientation.type;
-      if (type.includes("portrait")) {
+      const e = screen.orientation.angle, t = screen.orientation.type;
+      if (t.includes("portrait"))
         return "portrait";
-      } else if (type.includes("landscape")) {
+      if (t.includes("landscape"))
         return "landscape";
-      }
-      if (angle === 0 || angle === 180) {
+      if (e === 0 || e === 180)
         return "portrait";
-      } else if (angle === 90 || angle === 270) {
+      if (e === 90 || e === 270)
         return "landscape";
-      }
-    }
-    if (window.innerHeight > window.innerWidth) {
-      return "portrait";
-    } else if (window.innerWidth > window.innerHeight) {
-      return "landscape";
     }
-    return "unknown";
+    return window.innerHeight > window.innerWidth ? "portrait" : window.innerWidth > window.innerHeight ? "landscape" : "unknown";
   }
   /**
    * Add orientation change listener
    */
-  static addOrientationListener(id, callback) {
-    this.orientationListeners.set(id, callback);
-    if (this.orientationListeners.size === 1) {
-      this.setupGlobalOrientationListener();
-    }
+  static addOrientationListener(e, t) {
+    this.orientationListeners.set(e, t), this.orientationListeners.size === 1 && this.setupGlobalOrientationListener();
   }
   /**
    * Remove orientation change listener
    */
-  static removeOrientationListener(id) {
-    this.orientationListeners.delete(id);
-    if (this.orientationListeners.size === 0) {
-      this.cleanupGlobalOrientationListener();
-    }
+  static removeOrientationListener(e) {
+    this.orientationListeners.delete(e), this.orientationListeners.size === 0 && this.cleanupGlobalOrientationListener();
   }
   /**
    * Setup global orientation listening
    */
   static setupGlobalOrientationListener() {
-    const handleOrientationChange = () => {
-      const currentOrientation = this.getCurrentOrientation();
-      console.log("Orientation change detected:", currentOrientation);
-      this.orientationListeners.forEach((callback) => {
+    const e = () => {
+      const t = this.getCurrentOrientation();
+      console.log("Orientation change detected:", t), this.orientationListeners.forEach((n) => {
         try {
-          callback(currentOrientation);
-        } catch (error) {
-          console.error("Orientation change callback execution failed:", error);
+          n(t);
+        } catch (s) {
+          console.error("Orientation change callback execution failed:", s);
         }
       });
     };
-    window.addEventListener("orientationchange", handleOrientationChange);
-    window.addEventListener("resize", handleOrientationChange);
-    if (screen.orientation) {
-      screen.orientation.addEventListener("change", handleOrientationChange);
-    }
-    this._cleanupOrientationListeners = () => {
-      window.removeEventListener("orientationchange", handleOrientationChange);
-      window.removeEventListener("resize", handleOrientationChange);
-      if (screen.orientation) {
-        screen.orientation.removeEventListener("change", handleOrientationChange);
-      }
+    window.addEventListener("orientationchange", e), window.addEventListener("resize", e), screen.orientation && screen.orientation.addEventListener("change", e), this._cleanupOrientationListeners = () => {
+      window.removeEventListener("orientationchange", e), window.removeEventListener("resize", e), screen.orientation && screen.orientation.removeEventListener("change", e);
     };
   }
   /**
    * Cleanup global orientation listening
    */
   static cleanupGlobalOrientationListener() {
-    if (this._cleanupOrientationListeners) {
-      this._cleanupOrientationListeners();
-      delete this._cleanupOrientationListeners;
-    }
+    this._cleanupOrientationListeners && (this._cleanupOrientationListeners(), delete this._cleanupOrientationListeners);
   }
 }
-__publicField(OrientationManager, "orientationListeners", /* @__PURE__ */ new Map());
-class FullscreenAPI {
+o(a, "orientationListeners", /* @__PURE__ */ new Map());
+class u {
   /**
    * Request standard fullscreen
    */
-  static async requestFullscreen(element) {
+  static async requestFullscreen(e) {
     try {
-      if (element.requestFullscreen) {
-        await element.requestFullscreen();
-      } else if (element.webkitRequestFullscreen) {
-        await element.webkitRequestFullscreen();
-      } else if (element.mozRequestFullScreen) {
-        await element.mozRequestFullScreen();
-      } else if (element.msRequestFullscreen) {
-        await element.msRequestFullscreen();
-      } else {
-        return false;
-      }
-      return true;
-    } catch (error) {
-      console.error("Standard fullscreen request failed:", error);
-      return false;
+      if (e.requestFullscreen)
+        await e.requestFullscreen();
+      else if (e.webkitRequestFullscreen)
+        await e.webkitRequestFullscreen();
+      else if (e.mozRequestFullScreen)
+        await e.mozRequestFullScreen();
+      else if (e.msRequestFullscreen)
+        await e.msRequestFullscreen();
+      else
+        return !1;
+      return !0;
+    } catch (t) {
+      return console.error("Standard fullscreen request failed:", t), !1;
     }
   }
   /**
@@ -194,21 +142,19 @@ class FullscreenAPI {
    */
   static async exitFullscreen() {
     try {
-      if (document.exitFullscreen) {
+      if (document.exitFullscreen)
         await document.exitFullscreen();
-      } else if (document.webkitExitFullscreen) {
+      else if (document.webkitExitFullscreen)
         await document.webkitExitFullscreen();
-      } else if (document.mozCancelFullScreen) {
+      else if (document.mozCancelFullScreen)
         await document.mozCancelFullScreen();
-      } else if (document.msExitFullscreen) {
+      else if (document.msExitFullscreen)
         await document.msExitFullscreen();
-      } else {
-        return false;
-      }
-      return true;
-    } catch (error) {
-      console.error("Exit standard fullscreen failed:", error);
-      return false;
+      else
+        return !1;
+      return !0;
+    } catch (e) {
+      return console.error("Exit standard fullscreen failed:", e), !1;
     }
   }
   /**
@@ -218,94 +164,78 @@ class FullscreenAPI {
     return !!document.fullscreenElement;
   }
 }
-class FullscreenManager {
+class F {
   /**
    * Smart fullscreen request
    * Choose the best fullscreen method based on device type and support
    */
-  static async requestFullscreen(containerElement, viewElement, deviceType, isPortraitStream, shouldRotateToLandscape) {
-    if (!this.isFullscreenSupported(containerElement)) {
-      return this.requestCSSFullscreen(viewElement, isPortraitStream, shouldRotateToLandscape);
-    }
-    return this.requestStandardFullscreen(containerElement, viewElement, shouldRotateToLandscape);
+  static async requestFullscreen(e, t, n, s, c) {
+    return this.isFullscreenSupported(e) ? this.requestStandardFullscreen(e, t, c) : this.requestCSSFullscreen(t, s, c);
   }
   /**
    * Smart fullscreen exit
    */
-  static async exitFullscreen(viewElement, deviceType, hadLandscapeRotation) {
-    StyleManager.removeFullscreenStyles(viewElement);
-    StyleManager.removeLandscapeStyles(viewElement);
-    const success = await FullscreenAPI.exitFullscreen();
-    if (hadLandscapeRotation) {
-      await OrientationManager.unlockOrientation();
-    }
-    return {
-      success,
-      mode: success ? "standard" : "simulated",
-      shouldRotateToLandscape: hadLandscapeRotation
+  static async exitFullscreen(e, t, n) {
+    l.removeFullscreenStyles(e), l.removeLandscapeStyles(e);
+    const s = await u.exitFullscreen();
+    return n && await a.unlockOrientation(), {
+      success: s,
+      mode: s ? "standard" : "simulated",
+      shouldRotateToLandscape: n
     };
   }
   /**
    * CSS simulated fullscreen
    */
-  static async requestCSSFullscreen(element, isPortraitStream, shouldRotateToLandscape) {
+  static async requestCSSFullscreen(e, t, n) {
     try {
-      StyleManager.applyFullscreenStyles(element, isPortraitStream);
-      if (shouldRotateToLandscape) {
-        const orientationSuccess = await OrientationManager.requestOrientation("landscape");
-        if (!orientationSuccess) {
-          const currentOrientation = OrientationManager.getCurrentOrientation();
-          StyleManager.smartApplyLandscapeStyles(element, currentOrientation);
-        }
+      if (l.applyFullscreenStyles(e, t), n && !await a.requestOrientation("landscape")) {
+        const c = a.getCurrentOrientation();
+        l.smartApplyLandscapeStyles(e, c);
       }
-      return { success: true, mode: "simulated", shouldRotateToLandscape };
-    } catch (error) {
+      return { success: !0, mode: "simulated", shouldRotateToLandscape: n };
+    } catch (s) {
       return {
-        success: false,
+        success: !1,
         mode: "simulated",
-        shouldRotateToLandscape,
-        error
+        shouldRotateToLandscape: n,
+        error: s
       };
     }
   }
   /**
    * Standard API fullscreen
    */
-  static async requestStandardFullscreen(containerElement, viewElement, shouldRotateToLandscape) {
+  static async requestStandardFullscreen(e, t, n) {
     try {
-      const success = await FullscreenAPI.requestFullscreen(containerElement);
-      if (!success) {
-        return { success: false, mode: "standard", shouldRotateToLandscape };
-      }
-      if (shouldRotateToLandscape) {
-        const orientationSuccess = await OrientationManager.requestOrientation("landscape");
-        if (!orientationSuccess) {
-          const currentOrientation = OrientationManager.getCurrentOrientation();
-          StyleManager.smartApplyLandscapeStyles(viewElement, currentOrientation);
-        }
+      if (!await u.requestFullscreen(e))
+        return { success: !1, mode: "standard", shouldRotateToLandscape: n };
+      if (n && !await a.requestOrientation("landscape")) {
+        const d = a.getCurrentOrientation();
+        l.smartApplyLandscapeStyles(t, d);
       }
-      return { success: true, mode: "standard", shouldRotateToLandscape };
-    } catch (error) {
+      return { success: !0, mode: "standard", shouldRotateToLandscape: n };
+    } catch (s) {
       return {
-        success: false,
+        success: !1,
         mode: "standard",
-        shouldRotateToLandscape,
-        error
+        shouldRotateToLandscape: n,
+        error: s
       };
     }
   }
   /**
    * Check if fullscreen is supported
    */
-  static isFullscreenSupported(element) {
-    return !!(element.requestFullscreen || element.webkitRequestFullscreen || element.mozRequestFullScreen || element.msRequestFullscreen);
+  static isFullscreenSupported(e) {
+    return !!(e.requestFullscreen || e.webkitRequestFullscreen || e.mozRequestFullScreen || e.msRequestFullscreen);
   }
 }
 export {
-  CSS_CLASSES,
-  FullscreenAPI,
-  FullscreenManager,
-  FullscreenMode,
-  OrientationManager,
-  StyleManager
+  i as CSS_CLASSES,
+  u as FullscreenAPI,
+  F as FullscreenManager,
+  L as FullscreenMode,
+  a as OrientationManager,
+  l as StyleManager
 };

package/dist/components/LiveCoreView/i18n/en-US/index.d.ts

@@ -10,4 +10,10 @@ export declare const resource: {
     Mute: string;
     Unmute: string;
     'The system does not support picture-in-picture mode': string;
+    'co-Hosting': string;
+    'In battle': string;
+    '360P': string;
+    '540P': string;
+    '720P': string;
+    '1080P': string;
 };

package/dist/components/LiveCoreView/i18n/en-US/index.js

@@ -1,16 +1,22 @@
-const resource = {
+const e = {
   "No video": "No video",
   "Waiting for connection": "Waiting for connection",
-  "Play": "Play",
-  "Pause": "Pause",
+  Play: "Play",
+  Pause: "Pause",
   "Picture in Picture": "Picture in Picture",
   "Exit Picture in Picture": "Exit Picture in Picture",
-  "Fullscreen": "Fullscreen",
+  Fullscreen: "Fullscreen",
   "Exit Fullscreen": "Exit Fullscreen",
-  "Mute": "Mute",
-  "Unmute": "Unmute",
-  "The system does not support picture-in-picture mode": "The system does not support picture-in-picture mode"
+  Mute: "Mute",
+  Unmute: "Unmute",
+  "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"
 };
 export {
-  resource
+  e as resource
 };

package/dist/components/LiveCoreView/i18n/index.js

@@ -1,6 +1,6 @@
-import { resource } from "./zh-CN/index.js";
-import { resource as resource2 } from "./en-US/index.js";
+import { resource as o } from "./zh-CN/index.js";
+import { resource as c } from "./en-US/index.js";
 export {
-  resource2 as enUSResource,
-  resource as zhCNResource
+  c as enUSResource,
+  o as zhCNResource
 };

package/dist/components/LiveCoreView/i18n/zh-CN/index.d.ts

@@ -10,4 +10,10 @@ export declare const resource: {
     Mute: string;
     Unmute: string;
     'The system does not support picture-in-picture mode': string;
+    'co-Hosting': string;
+    'In battle': string;
+    '360P': string;
+    '540P': string;
+    '720P': string;
+    '1080P': string;
 };

package/dist/components/LiveCoreView/i18n/zh-CN/index.js

@@ -1,16 +1,22 @@
-const resource = {
+const e = {
   "No video": "暂无画面",
   "Waiting for connection": "等待连线",
-  "Play": "播放",
-  "Pause": "暂停",
+  Play: "播放",
+  Pause: "暂停",
   "Picture in Picture": "画中画",
   "Exit Picture in Picture": "退出画中画",
-  "Fullscreen": "全屏",
+  Fullscreen: "全屏",
   "Exit Fullscreen": "退出全屏",
-  "Mute": "静音",
-  "Unmute": "取消静音",
-  "The system does not support picture-in-picture mode": "系统不支持画中画模式"
+  Mute: "静音",
+  Unmute: "取消静音",
+  "The system does not support picture-in-picture mode": "系统不支持画中画模式",
+  "co-Hosting": "连线中",
+  "In battle": "PK中",
+  "360P": "低清",
+  "540P": "标清",
+  "720P": "高清",
+  "1080P": "超清"
 };
 export {
-  resource
+  e as resource
 };