toolshed-8.x-1.x-dev/js/EventListener.js
js/EventListener.js
"use strict";
(({
Toolshed: ts,
debounce
}) => {
/**
* Creates a queue of callable functions that can get managed and triggered
* together. The main purpose of this for queuing event listeners or
* registering a series of callbacks.
*
* CallList are orderable, and can be used to insert listeners around a
* specified reference point (before or after another callable).
*/
class CallList {
/**
* Ensure that a listener is a valid handler for the event used by this
* EventListener. This test is for checking the listener before adding it
* to the list of active listeners for this event.
*
* @param {Array|function} callable
* The object to test if it is valid for handling this event.
*
* @return {bool}
* Boolean to indicate if this listener is valid for handling this event.
* _true_ IFF this listener can be added and used with this event object.
*/
static isCallable(callable) {
let obj = null;
let func = callable;
if (callable instanceof Array) {
[obj, func] = callable;
}
return typeof func === 'function' && (!obj || obj instanceof Object);
}
/**
* Execute a callable item, with the parameters passed to the underlying
* function or method. A callable is either a function or an array
* (containing an object to use as the "this" and a method to execute).
*
* @param {function|Array} callable
* A callable is either a function that can be called directly or is an
* array that contains an object (used for "this") and a method to call.
* @param {*[]} ...args
* Additional arguments passed with the called item.
*
* @return {*|null}
* The result of the callabable
*/
static callItem(callable, ...args) {
if (callable instanceof Array) {
const [obj, func] = callable;
return func.apply(obj, args);
}
if (typeof callable === 'function') {
return callable(...args);
}
throw new Error('Unable to execute callable method.');
}
/**
* Create a new instance of a callable list of items.
*/
constructor() {
this.list = [];
}
/**
* Get the current size of the callable list.
*
* @return {int}
* The current size of the callables list array.
*/
size() {
return this.list.length;
}
/**
* Make a call to a list of callables.
*
* @param {Event} param
* argument object to pass to each of the callables as they get
* called respectively.
*/
call(param, ...args) {
this.list.forEach(cb => CallList.callItem(cb, param, ...args));
}
/**
* If there is a valid atPos, place the callable at this position,
* otherwise, just add it to the end of the list. This allows some
* flexibility to place callabbles at the start of the list, or
* before other callables.
*
* @param {Array|function} callable
* A callable object to add to the list.
* @param {int} atPos
* Index to add the callable at. This allows callables to be run in
* a different order than they maybe registered in.
*/
add(callable, atPos) {
if (!CallList.isCallable(callable)) {
throw new Error('Trying to add new callback, but it is not a valid callable.');
}
// Ensure that all existing references to this event are removed.
// Prevents the event from being called more than once unintentionally.
this.remove(callable);
if (atPos !== null && atPos >= 0) this.list.splice(atPos - 1, 0, callable);else this.list.push(callable);
}
/**
* Remove the specified callable from the list of callables.
*
* @param {Array|function} callable
* A listener object that requests to get removed.
*/
remove(callable) {
let pos = this.indexOf(callable);
while (pos >= 0) {
this.list.splice(pos, 1);
pos = this.indexOf(callable, pos);
}
}
/**
* Look for an a matching listener in the objects listener registry.
* Listeners can be stored as either function references, or arrays. If
* an array, the first item in the array is the object calling context,
* and the second parameter is function to call.
*
* Matches can be found by function, array (object and function) or just
* by matching the object contexts.
*
* @param {Array|Object|function} needle
* The matching listener to locate in the listeners array. If the param
* is an array, look for the matching object and function. If an object
* is passed in, find the first occurance of the object as the object
* context in the arrays. If a function, just search for the function.
* @param {int} start
* The starting position in the listener array to search for the callback.
*
* @return {int}
* The index where the matching listener was found. If a matching listener
* was not found, return -1 to indicate no match is available.
*/
indexOf(needle, start = 0) {
if (typeof needle === 'function') {
// For functions, matching is direct and straightforward.
return this.list.indexOf(needle, start);
}
const [obj, func] = needle instanceof Array ? needle : [null, needle];
for (; start < this.list.length; ++start) {
const item = this.list[start];
const [context, callback] = item instanceof Array ? item : [null, item];
if (obj === context && (!func || func === callback)) {
return start;
}
}
return -1;
}
}
/**
* Attach DOM and element events, which allow global registration and utilize
* a CallList for event calling and management. These event listeners
* have options for handling debounce, callables (@see CallList) and
* auto registration (only adding the event listener to the DOM when listener
* is added).
*
* Toolshed.EventListener.{eventName} namespace. Some of the events in that
* namespace may have customized event callback. An example of this is defined
* in ./screen-events.es6.js which are used by the Toolshed.Dock.
*/
ts.EventListener = class {
/**
* Constructor for creating of event listeners.
*
* @param {DOMElement} elem
* DOM element that will be the target of the event.
* @param {string} eventName
* The event.
* @param {null|object} options
* method:
* Name of the method to call on all listeners (special cases). Will call
* the default "on[this.eventName]" method if left blank.
* useCapture:
* Use capture instead of bubbling for event propagation.
* passive:
* Event handlers will not call preventDefault() which can enable browser
* optimatization that no longer need to wait for all handlers to complete
* before triggering other events like scrolling.
* debounce:
* Determine if the event only triggers using debounce handling. This means
* that events will only fire off after a short delay.
*
* If null or FALSE, no debounce will be used, and the event registered
* fires off as soon as the event is raised.
*
* If TRUE then use the default debounce delay. If an integer, than use the
* value as the delay in milliseconds.
*/
constructor(elem, eventName, options) {
options = options || {}; // options can be left blank.
this.elem = elem;
this.event = eventName;
this.autoListen = options.autoListen || false;
this.listeners = new CallList();
// Check and properly organize the event options to be used later.
if (options.debounce) {
this.debounce = typeof options.debounce === 'boolean' ? 100 : options.debounce;
}
// Allow for addEventListener options as described here
// https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener
// I am also employing the https://github.com/WICG/EventListenerOptions
// as a polyfill, but support will not be available for IE8 and earlier.
this.eventOpts = {
capture: options.capture || false,
passive: options.passive || false
};
}
/**
* Trigger the event for all the registered listeners. Custom
* EventListeners are most likely to override this function in order
* to create implement special functionality, triggered by events.
*
* @param {Object} event
* The event object that was generated and passed to the event handler.
*/
_run(event, ...args) {
this.listners.call(event, ...args);
}
/**
* Trigger the event manaully.
*
* @param {Event|null} event
* Event data to use with this event.
*
* @return {Drupal.Toolshed.EventListener}
* Return this instance of this EventListener for the purpose of chaining.
*/
trigger(event, ...args) {
this._run(event || new Event(this.event), args);
return this;
}
/**
* Register the event, and keep track of the callback so it can be removed
* later if we need to disable / remove the listener at a later time.
*
* @return {Drupal.Toolshed.EventListener}
* Return this instance of this EventListener for the purpose of chaining.
*/
listen() {
if (!this.callback && (!this.autoListen || this.listeners.size())) {
this.callback = this.debounce && this.debounce > 0 && debounce ? debounce(this._run.bind(this), this.debounce) : this._run.bind(this);
this.elem.addEventListener(this.event, this.callback, this.eventOpts);
}
return this;
}
/**
* Stop listening for this event, and unregister from any event listeners.
*
* @return {Drupal.Toolshed.EventListener}
* Return this instance of this EventListener for the purpose of chaining.
*/
ignore() {
if (this.callback) {
this.elem.removeEventListener(this.event, this.callback);
delete this.callback;
}
return this;
}
/**
* If there is a valid atPos, place the listener at this position,
* otherwise, just add it to the end of the list. This allows some
* flexibility to place listeners at the start of the list, or
* before other listeners.
*
* @param {Object} listener
* A listener object that contains the a method 'on' + [this.eventName].
* @param {int} atPos
* Index to add the listener at. This allows listeners to be run in
* a different order than they maybe registered in.
*
* @return {Drupal.Toolshed.EventListener}
* Return this instance of this EventListener for the purpose of chaining.
*/
add(listener, atPos) {
this.listeners.add(listener, atPos);
if (this.autoListen) this.listen();
return this;
}
/**
* Add a new listener before an existing listener already in the list.
* If [before] is null, then insert at the start of the list.
*
* @param {Array|function} listener
* A listener object that contains the a method 'on' + [this.eventName].
* @param {Array|function} before
* Listener object that is used to position the new listener.
*
* @return {Drupal.Toolshed.EventListener}
* Return this instance of this EventListener for the purpose of chaining.
*/
addBefore(listener, before) {
const pos = before ? this.listeners.indexOf(before) : 0;
return this.add(listener, pos < 0 ? 0 : pos);
}
/**
* Add a new listener after an existing listener already in the list.
* If [after] is null, then insert at the end of the list.
*
* @param {Array|function} listener
* A listener object that represents a callable.
* @param {Array|function} after
* Listener object that is used to position the new listener.
*
* @return {Drupal.Toolshed.EventListener}
* Return this instance of this EventListener for the purpose of chaining.
*/
addAfter(listener, after) {
let pos = null;
if (after) {
pos = this.listeners.indexOf(after);
pos = pos >= 0 ? pos + 1 : -1;
}
return this.add(listener, pos);
}
/**
* Remove the specified listener from the list of event listeners.
* This assume there should only be one entry pert callback.
*
* @param {Array|function} listener
* A listener object that requests to get removed.
*
* @return {Drupal.Toolshed.EventListener}
* Return this instance of this EventListener for the purpose of chaining.
*/
remove(listener) {
this.listeners.remove(listener);
// If there are no listeners and the autoListen option is on, turn off
// listening. This prevents the event from being called for no reason.
if (this.autoListen && !this.listeners.size()) this.ignore();
return this;
}
/**
* Clean-up events and data.
*/
destroy() {
this.ignore();
}
};
/**
* Event listener for media query listeners.
*/
ts.MediaQueryListener = class {
/**
* Constructs a new Media Query listener instance.
*
* @param {Object[]} breakpoints
* An array of breakpoints in the order they should be checked. Each
* breakpoint object is expected to have an `mq`, `inverted` and `event`
* property which help determine what event to call when a Media Query
* listener triggers.
*/
constructor(breakpoints) {
this.mode = null;
this.curBp = null;
this.bps = new Map();
this.aliases = new Map();
breakpoints.forEach(bp => {
const mql = window.matchMedia(bp.mediaQuery);
if (bp.event && !this.aliases.has(bp.event)) {
this.aliases.set(bp.event, {
on: new CallList(),
off: new CallList()
});
}
this.bps.set(bp.id, {
query: mql,
mode: bp.event || null,
inverted: bp.inverted || false
});
});
}
/**
* Alter the current breakpoint, and trigger the related events.
*
* @param {string} newBp
* The ID of the breakpoint to trigger.
*/
_changeMode(newBp) {
let newMode = null;
// If the mode changed, trigger the appropriate action.
if (newBp === this.curBp) return;
if (this.curBp) {
const offList = this.bps.get(this.curBp);
if (offList && offList.off) offList.off.call(this.curBp, 'off');
}
this.curBp = newBp;
if (newBp) {
const onList = this.bps.get(newBp);
if (onList) {
newMode = onList.mode;
if (onList.on) onList.on.call(this.curBp, 'on');
}
}
if (newMode !== this.mode) {
if (this.mode) {
const offMode = this.aliases.get(this.mode);
if (offMode) offMode.off.call(this.mode, 'off');
}
this.mode = newMode;
if (newMode) {
const onMode = this.aliases.get(newMode);
if (onMode) onMode.on.call(this.mode, 'on');
}
}
}
/**
* Check the registered breakpoints in order to see which one is active.
*
* @return {string|null}
* The query mapped event if a matching breakpoint is found, otherwise
* return null to mean no event.
*/
checkBreakpoints() {
const bps = Array.from(this.bps.entries());
for (let i = 0; i < bps.length; ++i) {
const [id, bp] = bps[i];
if (!bp.query.matches !== !bp.inverted) {
return id;
}
}
return null;
}
/**
* Add a new listener to a breakpoint or mode.
*
* @param {string} bpId
* The ID of the breakpoint to watch for, or the media query event to
* attach the listener callable to.
* @param {[type]} listener
* The callable callback to get called when the breakpoint matches the
* action specified (either on or off).
* @param {string} action
* Either 'on' or 'off' to indicated of the callback should be called
* when the media query is active or deactivated respectively.
*
* @return {Object}
* The current instance of the MediaQueryListener, and the "this" object.
*/
add(bpId, listener, action = 'on') {
if (action === 'on' || action === 'off') {
let target;
let curState;
if (this.aliases.has(bpId)) {
target = this.aliases.get(bpId);
curState = this.mode;
} else if (this.bps.has(bpId)) {
target = this.bps.get(bpId);
curState = this.curBp;
if (!target[action]) target[action] = new CallList();
} else {
throw new Error(`Error adding ${bpId} with action ${action}`);
}
target[action].add(listener);
// Trigger 'on' event when listener is added if current state matches
// screen sizes targeted by added listener.
if (curState === bpId && action === 'on') {
CallList.callItem(listener, bpId, 'on');
}
// Trigger 'off' event when listener is added if current state does not
// match screen sizes targeted by added listener.
else if (curState !== bpId && action === 'off') {
CallList.callItem(listener, bpId, 'off');
}
}
return this;
}
/**
* Listen for changes of the registered breakpoints.
*/
listen() {
let current;
this.bps.forEach((bp, id) => {
if (!bp.callback) {
bp.callback = mql => {
const mode = !mql.matches !== !bp.inverted ? id : this.checkBreakpoints();
this._changeMode(mode);
};
bp.query.addListener(bp.callback);
}
// Stop updating this after the first breakpoint to trigger.
if (!current && !bp.query.matches !== !bp.inverted) {
current = id;
}
});
this._changeMode(current);
}
/**
* Unregister all media query listeners, and ignore all breakpoint events.
*/
ignore() {
this.bps.forEach((id, bp) => {
if (bp.callback) {
bp.query.removeListener(bp.callback);
delete bp.callback;
}
});
}
};
})(Drupal);
//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"file":"EventListener.js","names":["Toolshed","ts","debounce","CallList","isCallable","callable","obj","func","Array","Object","callItem","args","apply","Error","constructor","list","size","length","call","param","forEach","cb","add","atPos","remove","splice","push","pos","indexOf","needle","start","item","context","callback","EventListener","elem","eventName","options","event","autoListen","listeners","eventOpts","capture","passive","_run","listners","trigger","Event","listen","bind","addEventListener","ignore","removeEventListener","listener","addBefore","before","addAfter","after","destroy","MediaQueryListener","breakpoints","mode","curBp","bps","Map","aliases","bp","mql","window","matchMedia","mediaQuery","has","set","on","off","id","query","inverted","_changeMode","newBp","newMode","offList","get","onList","offMode","onMode","checkBreakpoints","from","entries","i","matches","bpId","action","target","curState","current","addListener","removeListener","Drupal"],"sources":["EventListener.es6.js"],"sourcesContent":["(({ Toolshed: ts, debounce }) => {\n  /**\n   * Creates a queue of callable functions that can get managed and triggered\n   * together. The main purpose of this for queuing event listeners or\n   * registering a series of callbacks.\n   *\n   * CallList are orderable, and can be used to insert listeners around a\n   * specified reference point (before or after another callable).\n   */\n  class CallList {\n    /**\n     * Ensure that a listener is a valid handler for the event used by this\n     * EventListener. This test is for checking the listener before adding it\n     * to the list of active listeners for this event.\n     *\n     * @param {Array|function} callable\n     *   The object to test if it is valid for handling this event.\n     *\n     * @return {bool}\n     *   Boolean to indicate if this listener is valid for handling this event.\n     *   _true_ IFF this listener can be added and used with this event object.\n     */\n    static isCallable(callable) {\n      let obj = null;\n      let func = callable;\n\n      if (callable instanceof Array) {\n        [obj, func] = callable;\n      }\n\n      return (typeof func === 'function') && (!obj || obj instanceof Object);\n    }\n\n    /**\n     * Execute a callable item, with the parameters passed to the underlying\n     * function or method. A callable is either a function or an array\n     * (containing an object to use as the \"this\" and a method to execute).\n     *\n     * @param {function|Array} callable\n     *   A callable is either a function that can be called directly or is an\n     *   array that contains an object (used for \"this\") and a method to call.\n     * @param {*[]} ...args\n     *   Additional arguments passed with the called item.\n     *\n     * @return {*|null}\n     *   The result of the callabable\n     */\n    static callItem(callable, ...args) {\n      if (callable instanceof Array) {\n        const [obj, func] = callable;\n        return func.apply(obj, args);\n      }\n\n      if (typeof callable === 'function') {\n        return callable(...args);\n      }\n\n      throw new Error('Unable to execute callable method.');\n    }\n\n    /**\n     * Create a new instance of a callable list of items.\n     */\n    constructor() {\n      this.list = [];\n    }\n\n    /**\n     * Get the current size of the callable list.\n     *\n     * @return {int}\n     *   The current size of the callables list array.\n     */\n    size() {\n      return this.list.length;\n    }\n\n    /**\n     * Make a call to a list of callables.\n     *\n     * @param {Event} param\n     *   argument object to pass to each of the callables as they get\n     *   called respectively.\n     */\n    call(param, ...args) {\n      this.list.forEach((cb) => CallList.callItem(cb, param, ...args));\n    }\n\n    /**\n     * If there is a valid atPos, place the callable at this position,\n     * otherwise, just add it to the end of the list. This allows some\n     * flexibility to place callabbles at the start of the list, or\n     * before other callables.\n     *\n     * @param {Array|function} callable\n     *   A callable object to add to the list.\n     * @param {int} atPos\n     *   Index to add the callable at. This allows callables to be run in\n     *   a different order than they maybe registered in.\n     */\n    add(callable, atPos) {\n      if (!CallList.isCallable(callable)) {\n        throw new Error('Trying to add new callback, but it is not a valid callable.');\n      }\n\n      // Ensure that all existing references to this event are removed.\n      // Prevents the event from being called more than once unintentionally.\n      this.remove(callable);\n\n      if (atPos !== null && atPos >= 0) this.list.splice(atPos - 1, 0, callable);\n      else this.list.push(callable);\n    }\n\n    /**\n     * Remove the specified callable from the list of callables.\n     *\n     * @param {Array|function} callable\n     *  A listener object that requests to get removed.\n     */\n    remove(callable) {\n      let pos = this.indexOf(callable);\n\n      while (pos >= 0) {\n        this.list.splice(pos, 1);\n        pos = this.indexOf(callable, pos);\n      }\n    }\n\n    /**\n     * Look for an a matching listener in the objects listener registry.\n     * Listeners can be stored as either function references, or arrays. If\n     * an array, the first item in the array is the object calling context,\n     * and the second parameter is function to call.\n     *\n     * Matches can be found by function, array (object and function) or just\n     * by matching the object contexts.\n     *\n     * @param {Array|Object|function} needle\n     *   The matching listener to locate in the listeners array. If the param\n     *   is an array, look for the matching object and function. If an object\n     *   is passed in, find the first occurance of the object as the object\n     *   context in the arrays. If a function, just search for the function.\n     * @param {int} start\n     *   The starting position in the listener array to search for the callback.\n     *\n     * @return {int}\n     *   The index where the matching listener was found. If a matching listener\n     *   was not found, return -1 to indicate no match is available.\n     */\n    indexOf(needle, start = 0) {\n      if (typeof needle === 'function') {\n        // For functions, matching is direct and straightforward.\n        return this.list.indexOf(needle, start);\n      }\n\n      const [obj, func] = (needle instanceof Array) ? needle : [null, needle];\n      for (; start < this.list.length; ++start) {\n        const item = this.list[start];\n        const [context, callback] = (item instanceof Array) ? item : [null, item];\n\n        if (obj === context && (!func || func === callback)) {\n          return start;\n        }\n      }\n      return -1;\n    }\n  }\n\n  /**\n   * Attach DOM and element events, which allow global registration and utilize\n   * a CallList for event calling and management. These event listeners\n   * have options for handling debounce, callables (@see CallList) and\n   * auto registration (only adding the event listener to the DOM when listener\n   * is added).\n   *\n   * Toolshed.EventListener.{eventName} namespace. Some of the events in that\n   * namespace may have customized event callback. An example of this is defined\n   * in ./screen-events.es6.js which are used by the Toolshed.Dock.\n   */\n  ts.EventListener = class {\n    /**\n     * Constructor for creating of event listeners.\n     *\n     * @param {DOMElement} elem\n     *   DOM element that will be the target of the event.\n     * @param {string} eventName\n     *   The event.\n     * @param {null|object} options\n     *   method:\n     *     Name of the method to call on all listeners (special cases). Will call\n     *     the default \"on[this.eventName]\" method if left blank.\n     *   useCapture:\n     *     Use capture instead of bubbling for event propagation.\n     *   passive:\n     *     Event handlers will not call preventDefault() which can enable browser\n     *     optimatization that no longer need to wait for all handlers to complete\n     *     before triggering other events like scrolling.\n     *   debounce:\n     *     Determine if the event only triggers using debounce handling. This means\n     *     that events will only fire off after a short delay.\n     *\n     *     If null or FALSE, no debounce will be used, and the event registered\n     *     fires off as soon as the event is raised.\n     *\n     *     If TRUE then use the default debounce delay. If an integer, than use the\n     *     value as the delay in milliseconds.\n     */\n    constructor(elem, eventName, options) {\n      options = options || {}; // options can be left blank.\n\n      this.elem = elem;\n      this.event = eventName;\n      this.autoListen = options.autoListen || false;\n      this.listeners = new CallList();\n\n      // Check and properly organize the event options to be used later.\n      if (options.debounce) {\n        this.debounce = (typeof options.debounce === 'boolean') ? 100 : options.debounce;\n      }\n\n      // Allow for addEventListener options as described here\n      // https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener\n      // I am also employing the https://github.com/WICG/EventListenerOptions\n      // as a polyfill, but support will not be available for IE8 and earlier.\n      this.eventOpts = {\n        capture: options.capture || false,\n        passive: options.passive || false,\n      };\n    }\n\n    /**\n     * Trigger the event for all the registered listeners. Custom\n     * EventListeners are most likely to override this function in order\n     * to create implement special functionality, triggered by events.\n     *\n     * @param {Object} event\n     *   The event object that was generated and passed to the event handler.\n     */\n    _run(event, ...args) {\n      this.listners.call(event, ...args);\n    }\n\n    /**\n     * Trigger the event manaully.\n     *\n     * @param {Event|null} event\n     *   Event data to use with this event.\n     *\n     * @return {Drupal.Toolshed.EventListener}\n     *   Return this instance of this EventListener for the purpose of chaining.\n     */\n    trigger(event, ...args) {\n      this._run(event || new Event(this.event), args);\n      return this;\n    }\n\n    /**\n     * Register the event, and keep track of the callback so it can be removed\n     * later if we need to disable / remove the listener at a later time.\n     *\n     * @return {Drupal.Toolshed.EventListener}\n     *   Return this instance of this EventListener for the purpose of chaining.\n     */\n    listen() {\n      if (!this.callback && (!this.autoListen || this.listeners.size())) {\n        this.callback = (this.debounce && this.debounce > 0 && debounce)\n          ? debounce(this._run.bind(this), this.debounce) : this._run.bind(this);\n\n        this.elem.addEventListener(this.event, this.callback, this.eventOpts);\n      }\n      return this;\n    }\n\n    /**\n     * Stop listening for this event, and unregister from any event listeners.\n     *\n     * @return {Drupal.Toolshed.EventListener}\n     *   Return this instance of this EventListener for the purpose of chaining.\n     */\n    ignore() {\n      if (this.callback) {\n        this.elem.removeEventListener(this.event, this.callback);\n        delete this.callback;\n      }\n      return this;\n    }\n\n    /**\n     * If there is a valid atPos, place the listener at this position,\n     * otherwise, just add it to the end of the list. This allows some\n     * flexibility to place listeners at the start of the list, or\n     * before other listeners.\n     *\n     * @param {Object} listener\n     *   A listener object that contains the a method 'on' + [this.eventName].\n     * @param {int} atPos\n     *   Index to add the listener at. This allows listeners to be run in\n     *   a different order than they maybe registered in.\n     *\n     * @return {Drupal.Toolshed.EventListener}\n     *   Return this instance of this EventListener for the purpose of chaining.\n     */\n    add(listener, atPos) {\n      this.listeners.add(listener, atPos);\n\n      if (this.autoListen) this.listen();\n      return this;\n    }\n\n    /**\n     * Add a new listener before an existing listener already in the list.\n     * If [before] is null, then insert at the start of the list.\n     *\n     * @param {Array|function} listener\n     *   A listener object that contains the a method 'on' + [this.eventName].\n     * @param {Array|function} before\n     *   Listener object that is used to position the new listener.\n     *\n     * @return {Drupal.Toolshed.EventListener}\n     *   Return this instance of this EventListener for the purpose of chaining.\n     */\n    addBefore(listener, before) {\n      const pos = (before) ? this.listeners.indexOf(before) : 0;\n      return this.add(listener, pos < 0 ? 0 : pos);\n    }\n\n    /**\n     * Add a new listener after an existing listener already in the list.\n     * If [after] is null, then insert at the end of the list.\n     *\n     * @param {Array|function} listener\n     *  A listener object that represents a callable.\n     * @param {Array|function} after\n     *  Listener object that is used to position the new listener.\n     *\n     * @return {Drupal.Toolshed.EventListener}\n     *   Return this instance of this EventListener for the purpose of chaining.\n     */\n    addAfter(listener, after) {\n      let pos = null;\n\n      if (after) {\n        pos = this.listeners.indexOf(after);\n        pos = pos >= 0 ? pos + 1 : -1;\n      }\n      return this.add(listener, pos);\n    }\n\n    /**\n     * Remove the specified listener from the list of event listeners.\n     * This assume there should only be one entry pert callback.\n     *\n     * @param {Array|function} listener\n     *  A listener object that requests to get removed.\n     *\n     * @return {Drupal.Toolshed.EventListener}\n     *   Return this instance of this EventListener for the purpose of chaining.\n     */\n    remove(listener) {\n      this.listeners.remove(listener);\n\n      // If there are no listeners and the autoListen option is on, turn off\n      // listening. This prevents the event from being called for no reason.\n      if (this.autoListen && !this.listeners.size()) this.ignore();\n      return this;\n    }\n\n    /**\n     * Clean-up events and data.\n     */\n    destroy() {\n      this.ignore();\n    }\n  };\n\n  /**\n   * Event listener for media query listeners.\n   */\n  ts.MediaQueryListener = class {\n    /**\n     * Constructs a new Media Query listener instance.\n     *\n     * @param {Object[]} breakpoints\n     *   An array of breakpoints in the order they should be checked. Each\n     *   breakpoint object is expected to have an `mq`, `inverted` and `event`\n     *   property which help determine what event to call when a Media Query\n     *   listener triggers.\n     */\n    constructor(breakpoints) {\n      this.mode = null;\n      this.curBp = null;\n      this.bps = new Map();\n      this.aliases = new Map();\n\n      breakpoints.forEach((bp) => {\n        const mql = window.matchMedia(bp.mediaQuery);\n\n        if (bp.event && !this.aliases.has(bp.event)) {\n          this.aliases.set(bp.event, {\n            on: new CallList(),\n            off: new CallList(),\n          });\n        }\n\n        this.bps.set(bp.id, {\n          query: mql,\n          mode: bp.event || null,\n          inverted: bp.inverted || false,\n        });\n      });\n    }\n\n    /**\n     * Alter the current breakpoint, and trigger the related events.\n     *\n     * @param {string} newBp\n     *   The ID of the breakpoint to trigger.\n     */\n    _changeMode(newBp) {\n      let newMode = null;\n\n      // If the mode changed, trigger the appropriate action.\n      if (newBp === this.curBp) return;\n\n      if (this.curBp) {\n        const offList = this.bps.get(this.curBp);\n        if (offList && offList.off) offList.off.call(this.curBp, 'off');\n      }\n\n      this.curBp = newBp;\n      if (newBp) {\n        const onList = this.bps.get(newBp);\n\n        if (onList) {\n          newMode = onList.mode;\n          if (onList.on) onList.on.call(this.curBp, 'on');\n        }\n      }\n\n      if (newMode !== this.mode) {\n        if (this.mode) {\n          const offMode = this.aliases.get(this.mode);\n          if (offMode) offMode.off.call(this.mode, 'off');\n        }\n\n        this.mode = newMode;\n        if (newMode) {\n          const onMode = this.aliases.get(newMode);\n          if (onMode) onMode.on.call(this.mode, 'on');\n        }\n      }\n    }\n\n    /**\n     * Check the registered breakpoints in order to see which one is active.\n     *\n     * @return {string|null}\n     *   The query mapped event if a matching breakpoint is found, otherwise\n     *   return null to mean no event.\n     */\n    checkBreakpoints() {\n      const bps = Array.from(this.bps.entries());\n\n      for (let i = 0; i < bps.length; ++i) {\n        const [id, bp] = bps[i];\n\n        if (!bp.query.matches !== !bp.inverted) {\n          return id;\n        }\n      }\n\n      return null;\n    }\n\n    /**\n     * Add a new listener to a breakpoint or mode.\n     *\n     * @param {string} bpId\n     *   The ID of the breakpoint to watch for, or the media query event to\n     *   attach the listener callable to.\n     * @param {[type]} listener\n     *   The callable callback to get called when the breakpoint matches the\n     *   action specified (either on or off).\n     * @param {string} action\n     *   Either 'on' or 'off' to indicated of the callback should be called\n     *   when the media query is active or deactivated respectively.\n     *\n     * @return {Object}\n     *   The current instance of the MediaQueryListener, and the \"this\" object.\n     */\n    add(bpId, listener, action = 'on') {\n      if (action === 'on' || action === 'off') {\n        let target;\n        let curState;\n\n        if (this.aliases.has(bpId)) {\n          target = this.aliases.get(bpId);\n          curState = this.mode;\n        }\n        else if (this.bps.has(bpId)) {\n          target = this.bps.get(bpId);\n          curState = this.curBp;\n\n          if (!target[action]) target[action] = new CallList();\n        }\n        else {\n          throw new Error(`Error adding ${bpId} with action ${action}`);\n        }\n\n        target[action].add(listener);\n        // Trigger 'on' event when listener is added if current state matches\n        // screen sizes targeted by added listener.\n        if (curState === bpId && action === 'on') {\n          CallList.callItem(listener, bpId, 'on');\n        }\n        // Trigger 'off' event when listener is added if current state does not\n        // match screen sizes targeted by added listener.\n        else if (curState !== bpId && action === 'off') {\n          CallList.callItem(listener, bpId, 'off');\n        }\n      }\n\n      return this;\n    }\n\n    /**\n     * Listen for changes of the registered breakpoints.\n     */\n    listen() {\n      let current;\n\n      this.bps.forEach((bp, id) => {\n        if (!bp.callback) {\n          bp.callback = ((mql) => {\n            const mode = (!mql.matches !== !bp.inverted) ? id : this.checkBreakpoints();\n            this._changeMode(mode);\n          });\n\n          bp.query.addListener(bp.callback);\n        }\n\n        // Stop updating this after the first breakpoint to trigger.\n        if (!current && (!bp.query.matches !== !bp.inverted)) {\n          current = id;\n        }\n      });\n\n      this._changeMode(current);\n    }\n\n    /**\n     * Unregister all media query listeners, and ignore all breakpoint events.\n     */\n    ignore() {\n      this.bps.forEach((id, bp) => {\n        if (bp.callback) {\n          bp.query.removeListener(bp.callback);\n          delete bp.callback;\n        }\n      });\n    }\n  };\n})(Drupal);\n"],"mappings":"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"}
