Update website

admin/phpMyAdmin/js/dist/microhistory.js

@@ -0,0 +1,355 @@
+"use strict";
+
+/**
+ * An implementation of a client-side page cache.
+ * This object also uses the cache to provide a simple microhistory,
+ * that is the ability to use the back and forward buttons in the browser
+ */
+var MicroHistory = {
+  /**
+   * @var int The maximum number of pages to keep in the cache
+   */
+  MAX: 6,
+
+  /**
+   * @var object A hash used to prime the cache with data about the initially
+   *             loaded page. This is set in the footer, and then loaded
+   *             by a double-queued event further down this file.
+   */
+  primer: {},
+
+  /**
+   * @var array Stores the content of the cached pages
+   */
+  pages: [],
+
+  /**
+   * @var int The index of the currently loaded page
+   *          This is used to know at which point in the history we are
+   */
+  current: 0,
+
+  /**
+   * Saves a new page in the cache
+   *
+   * @param string hash    The hash part of the url that is being loaded
+   * @param array  scripts A list of scripts that is required for the page
+   * @param string menu    A hash that links to a menu stored
+   *                       in a dedicated menu cache
+   * @param array  params  A list of parameters used by CommonParams()
+   * @param string rel     A relationship to the current page:
+   *                       'samepage': Forces the response to be treated as
+   *                                   the same page as the current one
+   *                       'newpage':  Forces the response to be treated as
+   *                                   a new page
+   *                       undefined:  Default behaviour, 'samepage' if the
+   *                                   selflinks of the two pages are the same.
+   *                                   'newpage' otherwise
+   *
+   * @return void
+   */
+  add: function add(hash, scripts, menu, params, rel) {
+    if (this.pages.length > MicroHistory.MAX) {
+      // Trim the cache, to the maximum number of allowed entries
+      // This way we will have a cached menu for every page
+      for (var i = 0; i < this.pages.length - this.MAX; i++) {
+        delete this.pages[i];
+      }
+    }
+
+    while (this.current < this.pages.length) {
+      // trim the cache if we went back in the history
+      // and are now going forward again
+      this.pages.pop();
+    }
+
+    if (rel === 'newpage' || typeof rel === 'undefined' && (typeof this.pages[this.current - 1] === 'undefined' || this.pages[this.current - 1].hash !== hash)) {
+      this.pages.push({
+        hash: hash,
+        content: $('#page_content').html(),
+        scripts: scripts,
+        selflink: $('#selflink').html(),
+        menu: menu,
+        params: params
+      });
+      MicroHistory.setUrlHash(this.current, hash);
+      this.current++;
+    }
+  },
+
+  /**
+   * Restores a page from the cache. This is called when the hash
+   * part of the url changes and it's structure appears to be valid
+   *
+   * @param string index Which page from the history to load
+   *
+   * @return void
+   */
+  navigate: function navigate(index) {
+    var localIndex = index;
+
+    if (typeof this.pages[localIndex] === 'undefined' || typeof this.pages[localIndex].content === 'undefined' || typeof this.pages[localIndex].menu === 'undefined' || !MicroHistory.menus.get(this.pages[localIndex].menu)) {
+      Functions.ajaxShowMessage('<div class="alert alert-danger" role="alert">' + Messages.strInvalidPage + '</div>', false);
+    } else {
+      AJAX.active = true;
+      var record = this.pages[localIndex];
+      AJAX.scriptHandler.reset(function () {
+        $('#page_content').html(record.content);
+        $('#selflink').html(record.selflink);
+        MicroHistory.menus.replace(MicroHistory.menus.get(record.menu));
+        CommonParams.setAll(record.params);
+        AJAX.scriptHandler.load(record.scripts);
+        MicroHistory.current = ++localIndex;
+      });
+    }
+  },
+
+  /**
+   * Resaves the content of the current page in the cache.
+   * Necessary in order not to show the user some outdated version of the page
+   *
+   * @return void
+   */
+  update: function update() {
+    var page = this.pages[this.current - 1];
+
+    if (page) {
+      page.content = $('#page_content').html();
+    }
+  },
+
+  /**
+   * @var object Dedicated menu cache
+   */
+  menus: {
+    /**
+     * Returns the number of items in an associative array
+     *
+     * @return int
+     */
+    size: function size(obj) {
+      var size = 0;
+      var key;
+
+      for (key in obj) {
+        if (obj.hasOwnProperty(key)) {
+          size++;
+        }
+      }
+
+      return size;
+    },
+
+    /**
+     * @var hash Stores the content of the cached menus
+     */
+    data: {},
+
+    /**
+     * Saves a new menu in the cache
+     *
+     * @param string hash    The hash (trimmed md5) of the menu to be saved
+     * @param string content The HTML code of the menu to be saved
+     *
+     * @return void
+     */
+    add: function add(hash, content) {
+      if (this.size(this.data) > MicroHistory.MAX) {
+        // when the cache grows, we remove the oldest entry
+        var oldest;
+        var key;
+        var init = 0;
+
+        for (var i in this.data) {
+          if (this.data[i]) {
+            if (!init || this.data[i].timestamp.getTime() < oldest.getTime()) {
+              oldest = this.data[i].timestamp;
+              key = i;
+              init = 1;
+            }
+          }
+        }
+
+        delete this.data[key];
+      }
+
+      this.data[hash] = {
+        content: content,
+        timestamp: new Date()
+      };
+    },
+
+    /**
+     * Retrieves a menu given its hash
+     *
+     * @param string hash The hash of the menu to be retrieved
+     *
+     * @return string
+     */
+    get: function get(hash) {
+      if (this.data[hash]) {
+        return this.data[hash].content;
+      } else {
+        // This should never happen as long as the number of stored menus
+        // is larger or equal to the number of pages in the page cache
+        return '';
+      }
+    },
+
+    /**
+     * Prepares part of the parameter string used during page requests,
+     * this is necessary to tell the server which menus we have in the cache
+     *
+     * @return string
+     */
+    getRequestParam: function getRequestParam() {
+      var param = '';
+      var menuHashes = [];
+
+      for (var i in this.data) {
+        menuHashes.push(i);
+      }
+
+      var menuHashesParam = menuHashes.join('-');
+
+      if (menuHashesParam) {
+        param = CommonParams.get('arg_separator') + 'menuHashes=' + menuHashesParam;
+      }
+
+      return param;
+    },
+
+    /**
+     * Replaces the menu with new content
+     *
+     * @return void
+     */
+    replace: function replace(content) {
+      $('#floating_menubar').html(content) // Remove duplicate wrapper
+      // TODO: don't send it in the response
+      .children().first().remove();
+      $('#topmenu').menuResizer(Functions.mainMenuResizerCallback);
+    }
+  }
+};
+/**
+ * URL hash management module.
+ * Allows direct bookmarking and microhistory.
+ */
+
+MicroHistory.setUrlHash = function (jQuery, window) {
+  'use strict';
+  /**
+   * Indicates whether we have already completed
+   * the initialization of the hash
+   *
+   * @access private
+   */
+
+  var ready = false;
+  /**
+   * Stores a hash that needed to be set when we were not ready
+   *
+   * @access private
+   */
+
+  var savedHash = '';
+  /**
+   * Flag to indicate if the change of hash was triggered
+   * by a user pressing the back/forward button or if
+   * the change was triggered internally
+   *
+   * @access private
+   */
+
+  var userChange = true; // Fix favicon disappearing in Firefox when setting location.hash
+
+  function resetFavicon() {
+    if (navigator.userAgent.indexOf('Firefox') > -1) {
+      // Move the link tags for the favicon to the bottom
+      // of the head element to force a reload of the favicon
+      $('head > link[href="favicon\\.ico"]').appendTo('head');
+    }
+  }
+  /**
+   * Sets the hash part of the URL
+   *
+   * @access public
+   */
+
+
+  function setUrlHash(index, hash) {
+    /*
+     * Known problem:
+     * Setting hash leads to reload in webkit:
+     * https://www.quirksmode.org/bugreports/archives/2005/05/Safari_13_visual_anomaly_with_windowlocationhref.html
+     *
+     * so we expect that users are not running an ancient Safari version
+     */
+    userChange = false;
+
+    if (ready) {
+      window.location.hash = 'PMAURL-' + index + ':' + hash;
+      resetFavicon();
+    } else {
+      savedHash = 'PMAURL-' + index + ':' + hash;
+    }
+  }
+  /**
+   * Start initialization
+   */
+
+
+  var urlHash = window.location.hash;
+
+  if (urlHash.substring(0, 8) === '#PMAURL-') {
+    // We have a valid hash, let's redirect the user
+    // to the page that it's pointing to
+    var colonPosition = urlHash.indexOf(':');
+    var questionMarkPosition = urlHash.indexOf('?');
+
+    if (colonPosition !== -1 && questionMarkPosition !== -1 && colonPosition < questionMarkPosition) {
+      var hashUrl = urlHash.substring(colonPosition + 1, questionMarkPosition);
+
+      if (hashUrl === 'index.php') {
+        window.location = urlHash.substring(colonPosition + 1);
+      }
+    }
+  } else {
+    // We don't have a valid hash, so we'll set it up
+    // when the page finishes loading
+    jQuery(function () {
+      /* Check if we should set URL */
+      if (savedHash !== '') {
+        window.location.hash = savedHash;
+        savedHash = '';
+        resetFavicon();
+      } // Indicate that we're done initializing
+
+
+      ready = true;
+    });
+  }
+  /**
+   * Register an event handler for when the url hash changes
+   */
+
+
+  jQuery(function () {
+    jQuery(window).hashchange(function () {
+      if (userChange === false) {
+        // Ignore internally triggered hash changes
+        userChange = true;
+      } else if (/^#PMAURL-\d+:/.test(window.location.hash)) {
+        // Change page if the hash changed was triggered by a user action
+        var index = window.location.hash.substring(8, window.location.hash.indexOf(':'));
+        MicroHistory.navigate(index);
+      }
+    });
+  });
+  /**
+   * Publicly exposes a reference to the otherwise private setUrlHash function
+   */
+
+  return setUrlHash;
+}(jQuery, window);