FM / dist

/usr/share/phpmyadmin/js/dist

Name	Size	Mode	Actions
codemirror/	-	0755	rm
database/	-	0755	rm
designer/	-	0755	rm
jqplot/	-	0755	rm
server/	-	0755	rm
setup/	-	0755	rm
table/	-	0755	rm
transformations/	-	0755	rm
ajax.js	31313	0644	edit dl rm
chart.js	17840	0644	edit dl rm
common.js	4367	0644	edit dl rm
config.js	24956	0644	edit dl rm
console.js	49656	0644	edit dl rm
cross_framing_protection.js	419	0644	edit dl rm
doclinks.js	18275	0644	edit dl rm
drag_drop_import.js	12308	0644	edit dl rm
error_report.js	9621	0644	edit dl rm
export.js	33524	0644	edit dl rm
export_output.js	379	0644	edit dl rm
functions.js	160991	0644	edit dl rm
gis_data_editor.js	13822	0644	edit dl rm
import.js	6161	0644	edit dl rm
indexes.js	26344	0644	edit dl rm
jquery.sortable-table.js	9951	0644	edit dl rm
keyhandler.js	3003	0644	edit dl rm
makegrid.js	78860	0644	edit dl rm
menu_resizer.js	5644	0644	edit dl rm
microhistory.js	10074	0644	edit dl rm
multi_column_sort.js	1296	0644	edit dl rm
navigation.js	54678	0644	edit dl rm
normalization.js	24237	0644	edit dl rm
page_settings.js	1568	0644	edit dl rm
replication.js	3517	0644	edit dl rm
rte.js	40074	0644	edit dl rm
shortcuts_handler.js	3326	0644	edit dl rm
sql.js	35495	0644	edit dl rm
u2f.js	2953	0644	edit dl rm

Edit: /usr/share/phpmyadmin/js/dist/microhistory.js (10074B)

"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);

cmd: