tuikit-atomicx-vue3 3.3.4 → 3.4.2

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

@@ -1,129 +0,0 @@
-var DeviceType = /* @__PURE__ */ ((DeviceType2) => {
-  DeviceType2["DESKTOP"] = "desktop";
-  DeviceType2["MOBILE"] = "mobile";
-  DeviceType2["IOS"] = "ios";
-  DeviceType2["ANDROID"] = "android";
-  return DeviceType2;
-})(DeviceType || {});
-const isMobileDevice = () => {
-  return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
-};
-const isIOSDevice = () => {
-  return /iPad|iPhone|iPod/.test(navigator.userAgent);
-};
-const isAndroidDevice = () => {
-  return /Android/i.test(navigator.userAgent);
-};
-const isSafariBrowser = () => {
-  const isSafari = (
-    // Check the vendor feature
-    navigator.vendor && navigator.vendor.includes("Apple") && // Check specific apis or behaviors unique to Safari
-    !navigator.userAgent.includes("CriOS") && // Exclude Chrome iOS
-    !navigator.userAgent.includes("FxiOS") && // Exclude Firefox iOS
-    // Additional feature checks
-    (typeof safari !== "undefined" || !("netscape" in window) || // Firefox has netscape objects
-    document.documentMode === void 0)
-  );
-  return !!isSafari;
-};
-const isFirefoxBrowser = () => {
-  return typeof InstallTrigger !== "undefined" || navigator.userAgent.includes("Firefox") || navigator.userAgent.includes("Gecko/");
-};
-const getDeviceType = () => {
-  if (isIOSDevice()) return "ios";
-  if (isAndroidDevice()) return "android";
-  if (isMobileDevice()) return "mobile";
-  return "desktop";
-};
-const isOrientationSupported = () => {
-  return !!(screen.orientation && screen.orientation.lock);
-};
-const getCurrentOrientation = () => {
-  if (screen.orientation) {
-    const angle = screen.orientation.angle;
-    const type = screen.orientation.type;
-    if (type.includes("portrait")) {
-      return "portrait";
-    } else if (type.includes("landscape")) {
-      return "landscape";
-    }
-    if (angle === 0 || angle === 180) {
-      return "portrait";
-    } else if (angle === 90 || angle === 270) {
-      return "landscape";
-    }
-  }
-  if (window.innerHeight > window.innerWidth) {
-    return "portrait";
-  } else if (window.innerWidth > window.innerHeight) {
-    return "landscape";
-  }
-  return "unknown";
-};
-const isCurrentlyPortrait = () => {
-  return getCurrentOrientation() === "portrait";
-};
-const isCurrentlyLandscape = () => {
-  return getCurrentOrientation() === "landscape";
-};
-const shouldRotateToLandscapeForFullscreen = (deviceType, isLandscapeStream) => {
-  if (deviceType === "desktop") {
-    return false;
-  }
-  if (!isLandscapeStream) {
-    return false;
-  }
-  if (!isCurrentlyPortrait()) {
-    return false;
-  }
-  return true;
-};
-const hadLandscapeRotationToUndo = (deviceType, isLandscapeStream) => {
-  if (deviceType === "desktop") {
-    return false;
-  }
-  if (!isLandscapeStream) {
-    return false;
-  }
-  if (!isCurrentlyLandscape()) {
-    return false;
-  }
-  return true;
-};
-const isFullscreenSupported = (element) => {
-  return !!(element.requestFullscreen || element.webkitRequestFullscreen || element.mozRequestFullScreen || element.msRequestFullscreen);
-};
-const isExitFullscreenSupported = () => {
-  return !!(document.exitFullscreen || document.webkitExitFullscreen || document.mozCancelFullScreen || document.msExitFullscreen);
-};
-const isPictureInPictureSupported = (video) => {
-  if (!video) return false;
-  return typeof video.requestPictureInPicture === "function" && typeof document.exitPictureInPicture === "function";
-};
-const getDeviceCapabilities = (element) => {
-  return {
-    supportsFullscreen: element ? isFullscreenSupported(element) : false,
-    supportsOrientation: isOrientationSupported(),
-    supportsPictureInPicture: isPictureInPictureSupported(),
-    deviceType: getDeviceType()
-  };
-};
-export {
-  DeviceType,
-  getCurrentOrientation,
-  getDeviceCapabilities,
-  getDeviceType,
-  hadLandscapeRotationToUndo,
-  isAndroidDevice,
-  isCurrentlyLandscape,
-  isCurrentlyPortrait,
-  isExitFullscreenSupported,
-  isFirefoxBrowser,
-  isFullscreenSupported,
-  isIOSDevice,
-  isMobileDevice,
-  isOrientationSupported,
-  isPictureInPictureSupported,
-  isSafariBrowser,
-  shouldRotateToLandscapeForFullscreen
-};

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

@@ -1,120 +0,0 @@
-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);
-const DOM_SELECTORS = {
-  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 DOMElementGetter {
-  /**
-   * Get live-core-view-container element
-   */
-  static getLiveCoreViewContainer() {
-    return document.querySelector(DOM_SELECTORS.LIVE_CORE_VIEW_CONTAINER);
-  }
-  /**
-   * Get live-core-view element
-   */
-  static getLiveCoreView() {
-    return document.querySelector(DOM_SELECTORS.LIVE_CORE_VIEW);
-  }
-  /**
-   * Get video element
-   */
-  static getVideoElement() {
-    return document.querySelector(DOM_SELECTORS.VIDEO_ELEMENT);
-  }
-  /**
-   * Get all required DOM elements
-   */
-  static getAllElements() {
-    return {
-      container: DOMElementGetter.getLiveCoreViewContainer(),
-      view: DOMElementGetter.getLiveCoreView(),
-      video: DOMElementGetter.getVideoElement()
-    };
-  }
-  /**
-   * Check if tcplayer element exists in live-core-view-container
-   */
-  static hasTcPlayerElement() {
-    const container = DOMElementGetter.getLiveCoreViewContainer();
-    if (!container) {
-      return false;
-    }
-    return container.querySelector(DOM_SELECTORS.TCPLAYER_ELEMENT) !== null;
-  }
-  /**
-   * Get tcplayer element from live-core-view-container
-   */
-  static getTcPlayerElement() {
-    const container = DOMElementGetter.getLiveCoreViewContainer();
-    if (!container) {
-      return null;
-    }
-    return container.querySelector(DOM_SELECTORS.TCPLAYER_ELEMENT);
-  }
-  /**
-   * Validate if elements exist
-   */
-  static validateElements(elements) {
-    const missingElements = [];
-    if (elements.container === null) {
-      missingElements.push("live-core-view-container");
-    }
-    if (elements.view === null) {
-      missingElements.push("live-core-view");
-    }
-    if (elements.video === null) {
-      missingElements.push("video");
-    }
-    return {
-      isValid: missingElements.length === 0,
-      missingElements
-    };
-  }
-}
-class EventListenerManager {
-  constructor() {
-    __publicField(this, "listeners", /* @__PURE__ */ new Map());
-  }
-  /**
-   * Add event listener
-   */
-  addListener(id, element, event, handler) {
-    this.removeListener(id);
-    element.addEventListener(event, handler);
-    this.listeners.set(id, { element, event, handler });
-  }
-  /**
-   * Remove specified event listener
-   */
-  removeListener(id) {
-    const listener = this.listeners.get(id);
-    if (listener) {
-      listener.element.removeEventListener(listener.event, listener.handler);
-      this.listeners.delete(id);
-    }
-  }
-  /**
-   * Remove all event listeners
-   */
-  removeAllListeners() {
-    for (const [id] of this.listeners) {
-      this.removeListener(id);
-    }
-  }
-  /**
-   * Get current listener count
-   */
-  getListenerCount() {
-    return this.listeners.size;
-  }
-}
-export {
-  DOMElementGetter,
-  DOM_SELECTORS,
-  EventListenerManager
-};

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

@@ -1,311 +0,0 @@
-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 = {
-  FULLSCREEN: "fullscreen-mode",
-  FULLSCREEN_PORTRAIT: "fullscreen-mode-portrait",
-  LANDSCAPE: "landscape-mode"
-};
-class StyleManager {
-  /**
-   * Apply fullscreen styles
-   */
-  static applyFullscreenStyles(element, isPortrait = false) {
-    const className = isPortrait ? CSS_CLASSES.FULLSCREEN_PORTRAIT : CSS_CLASSES.FULLSCREEN;
-    element.classList.add(className);
-  }
-  /**
-   * Remove fullscreen styles
-   */
-  static removeFullscreenStyles(element) {
-    element.classList.remove(CSS_CLASSES.FULLSCREEN);
-    element.classList.remove(CSS_CLASSES.FULLSCREEN_PORTRAIT);
-  }
-  /**
-   * Apply landscape styles
-   */
-  static applyLandscapeStyles(element) {
-    element.classList.add(CSS_CLASSES.LANDSCAPE);
-  }
-  /**
-   * Remove landscape styles
-   */
-  static removeLandscapeStyles(element) {
-    element.classList.remove(CSS_CLASSES.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);
-    }
-  }
-}
-class OrientationManager {
-  /**
-   * Request screen orientation
-   */
-  static async requestOrientation(orientation) {
-    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;
-    }
-  }
-  /**
-   * Unlock screen orientation
-   */
-  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;
-    }
-  }
-  /**
-   * Get current orientation
-   */
-  static getCurrentOrientation() {
-    if (screen.orientation) {
-      const angle = screen.orientation.angle;
-      const type = screen.orientation.type;
-      if (type.includes("portrait")) {
-        return "portrait";
-      } else if (type.includes("landscape")) {
-        return "landscape";
-      }
-      if (angle === 0 || angle === 180) {
-        return "portrait";
-      } else if (angle === 90 || angle === 270) {
-        return "landscape";
-      }
-    }
-    if (window.innerHeight > window.innerWidth) {
-      return "portrait";
-    } else if (window.innerWidth > window.innerHeight) {
-      return "landscape";
-    }
-    return "unknown";
-  }
-  /**
-   * Add orientation change listener
-   */
-  static addOrientationListener(id, callback) {
-    this.orientationListeners.set(id, callback);
-    if (this.orientationListeners.size === 1) {
-      this.setupGlobalOrientationListener();
-    }
-  }
-  /**
-   * Remove orientation change listener
-   */
-  static removeOrientationListener(id) {
-    this.orientationListeners.delete(id);
-    if (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) => {
-        try {
-          callback(currentOrientation);
-        } catch (error) {
-          console.error("Orientation change callback execution failed:", error);
-        }
-      });
-    };
-    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);
-      }
-    };
-  }
-  /**
-   * Cleanup global orientation listening
-   */
-  static cleanupGlobalOrientationListener() {
-    if (this._cleanupOrientationListeners) {
-      this._cleanupOrientationListeners();
-      delete this._cleanupOrientationListeners;
-    }
-  }
-}
-__publicField(OrientationManager, "orientationListeners", /* @__PURE__ */ new Map());
-class FullscreenAPI {
-  /**
-   * Request standard fullscreen
-   */
-  static async requestFullscreen(element) {
-    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;
-    }
-  }
-  /**
-   * Exit standard fullscreen
-   */
-  static async exitFullscreen() {
-    try {
-      if (document.exitFullscreen) {
-        await document.exitFullscreen();
-      } else if (document.webkitExitFullscreen) {
-        await document.webkitExitFullscreen();
-      } else if (document.mozCancelFullScreen) {
-        await document.mozCancelFullScreen();
-      } else if (document.msExitFullscreen) {
-        await document.msExitFullscreen();
-      } else {
-        return false;
-      }
-      return true;
-    } catch (error) {
-      console.error("Exit standard fullscreen failed:", error);
-      return false;
-    }
-  }
-  /**
-   * Check if currently in fullscreen state
-   */
-  static isCurrentlyFullscreen() {
-    return !!document.fullscreenElement;
-  }
-}
-class FullscreenManager {
-  /**
-   * 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);
-  }
-  /**
-   * 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
-    };
-  }
-  /**
-   * CSS simulated fullscreen
-   */
-  static async requestCSSFullscreen(element, isPortraitStream, shouldRotateToLandscape) {
-    try {
-      StyleManager.applyFullscreenStyles(element, isPortraitStream);
-      if (shouldRotateToLandscape) {
-        const orientationSuccess = await OrientationManager.requestOrientation("landscape");
-        if (!orientationSuccess) {
-          const currentOrientation = OrientationManager.getCurrentOrientation();
-          StyleManager.smartApplyLandscapeStyles(element, currentOrientation);
-        }
-      }
-      return { success: true, mode: "simulated", shouldRotateToLandscape };
-    } catch (error) {
-      return {
-        success: false,
-        mode: "simulated",
-        shouldRotateToLandscape,
-        error
-      };
-    }
-  }
-  /**
-   * Standard API fullscreen
-   */
-  static async requestStandardFullscreen(containerElement, viewElement, shouldRotateToLandscape) {
-    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);
-        }
-      }
-      return { success: true, mode: "standard", shouldRotateToLandscape };
-    } catch (error) {
-      return {
-        success: false,
-        mode: "standard",
-        shouldRotateToLandscape,
-        error
-      };
-    }
-  }
-  /**
-   * Check if fullscreen is supported
-   */
-  static isFullscreenSupported(element) {
-    return !!(element.requestFullscreen || element.webkitRequestFullscreen || element.mozRequestFullScreen || element.msRequestFullscreen);
-  }
-}
-export {
-  CSS_CLASSES,
-  FullscreenAPI,
-  FullscreenManager,
-  FullscreenMode,
-  OrientationManager,
-  StyleManager
-};

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

@@ -1,16 +0,0 @@
-const resource = {
-  "No video": "No video",
-  "Waiting for connection": "Waiting for connection",
-  "Play": "Play",
-  "Pause": "Pause",
-  "Picture in Picture": "Picture in Picture",
-  "Exit Picture in Picture": "Exit Picture in Picture",
-  "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"
-};
-export {
-  resource
-};

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

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

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

@@ -1,16 +0,0 @@
-const resource = {
-  "No video": "暂无画面",
-  "Waiting for connection": "等待连线",
-  "Play": "播放",
-  "Pause": "暂停",
-  "Picture in Picture": "画中画",
-  "Exit Picture in Picture": "退出画中画",
-  "Fullscreen": "全屏",
-  "Exit Fullscreen": "退出全屏",
-  "Mute": "静音",
-  "Unmute": "取消静音",
-  "The system does not support picture-in-picture mode": "系统不支持画中画模式"
-};
-export {
-  resource
-};

package/dist/components/LiveCoreView/index.d.ts

@@ -1,4 +0,0 @@
-import { default as DefaultStreamViewUI } from './DefaultStreamViewUI.vue';
-import { default as LiveCoreView } from './index.vue';
-
-export { LiveCoreView, DefaultStreamViewUI };