/**
 * @Datei fn.js
 * @modul fn
 * /
importiere { newGUID } von './guid.js';
import window from 'global/window';

export const UPDATE_REFRESH_INTERVAL = 30;

/**
 * Bindung (auch als Proxy oder Kontext bezeichnet). Eine einfache Methode zur Änderung des Kontexts von
 * eine Funktion.
 *
 * Außerdem wird eine eindeutige Kennung für die Funktion gespeichert, so dass sie leicht aus der Datenbank entfernt werden kann
 * veranstaltungen.
 *
 * @Funktion
 * @param {Mixed} context
 *           Das Objekt, das als Bereich gebunden werden soll.
 *
 * @param {Funktion} fn
 *           Die Funktion, die an einen Bereich gebunden werden soll.
 *
 * @param {Nummer} [uid]
 *           Eine optionale eindeutige ID für die zu setzende Funktion
 *
 * @return {Funktion}
 *           Die neue Funktion, die in den angegebenen Kontext eingebunden wird
 * /
export const bind = function(context, fn, uid) {
  // Stellen Sie sicher, dass die Funktion eine eindeutige ID hat
  if (!fn.guid) {
    fn.guid = newGUID();
  }

  // Erstellen Sie die neue Funktion, die den Kontext ändert
  const bound = fn.bind(context);

  // Ermöglichen Sie die Individualisierung dieser Funktion
  // Erforderlich für den Fall, dass mehrere Objekte denselben Prototyp verwenden können
  // WENN beide Elemente einen Ereignis-Listener mit der gleichen Funktion hinzufügen, versuchen Sie, nur einen zu entfernen
  // werden beide entfernt, da sie beide dieselbe Guid haben.
  // Wenn Sie dies verwenden, müssen Sie die Bindungsmethode auch beim Entfernen des Hörers verwenden.
  // derzeit in Textspuren verwendet
  bound.guid = (uid) ? uid + '_' + fn.guid : fn.guid;

  rückgabepflicht;
};

/**
 * Umhüllt die angegebene Funktion "fn" mit einer neuen Funktion, die nur "fn" aufruft
 * höchstens einmal pro `wait` Millisekunden.
 *
 * @Funktion
 * @param {Funktion} fn
 *           Die zu drosselnde Funktion.
 *
 * @param {Nummer} wait
 *           Die Anzahl der Millisekunden, um die gedrosselt werden soll.
 *
 * @return {Funktion}
 * /
export const throttle = function(fn, wait) {
  let last = window.performance.now();

  const throttled = function(...args) {
    const now = window.performance.now();

    if (now - last >= wait) {
      fn(...args);
      zuletzt = jetzt;
    }
  };

  rückkehr gedrosselt;
};

/**
 * Erzeugt eine entprellte Funktion, die den Aufruf von `func` bis nach `wait` verzögert
 * millisekunden seit dem letzten Mal verstrichen sind, als die entprellte Funktion
 * aufgerufen werden.
 *
 * Inspiriert von lodash und underscore Implementierungen.
 *
 * @Funktion
 * @param {Funktion} func
 *           Die Funktion, die mit dem Entprellungsverhalten verpackt werden soll.
 *
 * @param {Nummer} wait
 *           Die Anzahl der Millisekunden, die nach dem letzten Aufruf gewartet werden soll.
 *
 * @param {boolean} [sofort]
 *           Ob die Funktion sofort nach der Erstellung aufgerufen werden soll oder nicht.
 *
 * @param {Object} [context=window]
 *           Der "Kontext", in dem die entprellte Funktion entprellt werden soll. Für
 *           beispiel, wenn diese Funktion mit einem Video.js-Player verknüpft werden soll,
 *           kann der Spieler hier übergeben werden. Alternativ wird standardmäßig die Option
 *           globales `Fenster`-Objekt.
 *
 * @return {Funktion}
 *           Eine entprellte Funktion.
 * /
export const debounce = function(func, wait, immediate, context = window) {
  timeout lassen;

  const cancel = () => {
    context.clearTimeout(timeout);
    timeout = null;
  };

  /* eslint-disable consistent-this */
  const entprellt = function() {
    const self = this;
    const args = arguments;

    let later = function() {
      timeout = null;
      später = null;
      if (!immediate) {
        func.apply(self, args);
      }
    };

    if (!timeout && immediate) {
      func.apply(self, args);
    }

    context.clearTimeout(timeout);
    timeout = context.setTimeout(later, wait);
  };
  /* eslint-enable consistent-this */

  debounced.cancel = cancel;

  rückkehr entprellt;
};