/**
 * @file redimensionar-manager.js
 * /
importar ventana desde 'global/window';
importar {rebote} desde './utils/fn.js';
importar * como Eventos desde './utils/events.js';
importar mergeOptions desde './utils/merge-options.js';
importar componente desde './component.js';

/**
 * Un administrador de cambio de tamaño. Está a cargo de activar `playerresize` en el reproductor en las condiciones adecuadas.
 *
 * Creará un iframe y usará un controlador de cambio de tamaño sin rebote o usará el nuevo {@link https://wicg.github.io/ResizeObserver/|ResizeObserver}.
 *
 * Si ResizeObserver está disponible de forma nativa, se utilizará. Se puede pasar un polyfill como opción.
 * Si no se necesita un evento `playerresize`, el componente ResizeManager se puede eliminar del reproductor, vea el ejemplo a continuación.
 * @ejemplo < subtítulo> Cómo deshabilitar el administrador de cambio de tamaño< /subtítulo>
 * reproductor constante = videojs('#vid', {
 * resizeManager: falso
 * });
 *
 * @ver {@enlace https://wicg.github.io/ResizeObserver/|ResizeObserver especificación}
 *
 * Componente @extiende
 * /
class ResizeManager extiende Componente {

  /**
   * Crear el ResizeManager.
   *
   * @param {Objeto} reproductor
   * El `Jugador` al que se debe adjuntar esta clase.
   *
   * @param {Objeto} [opciones]
   * El almacén de clave/valor de las opciones de ResizeManager.
   *
   * @param {Objeto} [opciones.ResizeObserver]
   * Aquí se puede pasar un polyfill para ResizeObserver.
   * Si se establece en nulo, ignorará el ResizeObserver nativo y volverá al respaldo de iframe.
   * /
  constructor(jugador, opciones) {
    let RESIZE_OBSERVER_AVAILABLE = opciones.ResizeObserver || ventana.ResizeObserver;

    // si se pasó `null`, queremos deshabilitar el ResizeObserver
    if (opciones.ResizeObserver === null) {
      RESIZE_OBSERVER_AVAILABLE = falso;
    }

    // Solo crea un elemento cuando ResizeObserver no está disponible
    const opciones_ = fusionarOpciones({
      crearEl: !RESIZE_OBSERVER_AVAILABLE,
      reportTouchActivity: falso
    }, opciones);

    super(jugador, opciones_);

    this.ResizeObserver = opciones.ResizeObserver || ventana.ResizeObserver;
    this.loadListener_ = null;
    this.resizeObserver_ = null;
    this.debouncedHandler_ = debounce(() => {
      this.resizeHandler();
    }, 100, falso, esto);

    si (RESIZE_OBSERVER_AVAILABLE) {
      this.resizeObserver_ = new this.ResizeObserver(this.debouncedHandler_);
      this.resizeObserver_.observe(jugador.el());

    } else {
      this.loadListener_ = () => {
        if (!this.el_ || !this.el_.contentWindow) {
          devolver;
        }

        const debouncedHandler_ = this.debouncedHandler_;
        let unloadListener_ = this.unloadListener_ = function() {
          Events.off(this, 'resize', debouncedHandler_);
          Eventos.off(esto, 'descargar', descargarListener_);

          descargarListener_ = nulo;
        };

        // safari y edge pueden descargar el iframe antes de que resizemanager lo deseche
        // tenemos que deshacernos de los controladores de eventos correctamente antes de que eso suceda
        Events.on(this.el_.contentWindow, 'descargar', descargarListener_);
        Events.on(this.el_.contentWindow, 'resize', debouncedHandler_);
      };

      this.one('cargar', this.loadListener_);
    }
  }

  crearEl() {
    volver super.createEl('iframe', {
      nombre de clase: 'vjs-resize-manager',
      índice de tabulación: -1,
      título: this.localize('Sin contenido')
    }, {
      'aria-oculto': 'verdadero'
    });
  }

  /**
   * Llamado cuando se activa un cambio de tamaño en el iframe o se observa un cambio de tamaño a través de ResizeObserver
   *
   * @fires Player#playerresize
   * /
  redimensionarManejador() {
    /**
     * Llamado cuando el tamaño del jugador ha cambiado
     *
     * @event Player#playerresize
     * @type {Objetivo del evento~Evento}
     * /
    // asegúrese de que el jugador todavía esté cerca para activar
    // evita que esto cause un error después de desechar
    if (!este.jugador_ || !este.jugador_.trigger) {
      devolver;
    }

    this.player_.trigger('playerresize');
  }

  disponer () {
    si (this.debouncedHandler_) {
      this.debouncedHandler_.cancel();
    }

    si (este.resizeObserver_) {
      if (este.jugador_.el()) {
        this.resizeObserver_.unobserve(this.player_.el());
      }
      this.resizeObserver_.disconnect();
    }

    si (este.loadListener_) {
      this.off('cargar', this.loadListener_);
    }

    si (esto.el_ && this.el_.contentWindow && esto.unloadListener_) {
      this.unloadListener_.call(this.el_.contentWindow);
    }

    this.ResizeObserver = null;
    this.resizeObserver = null;
    this.debouncedHandler_ = null;
    this.loadListener_ = null;
    super.dispose();
  }

}

Component.registerComponent('ResizeManager', ResizeManager);
exportar ResizeManager predeterminado;