toolshed-8.x-1.x-dev/js/toolshed.js
js/toolshed.js
"use strict";
// Define the Toolshed object scope.
Drupal.Toolshed = {
/**
* Check if this value is a string or not. Helps to encapsulate a safe way to
* test for string.
*
* @param {*} str
* The variable to check if this is a string.
*
* @return {bool}
* TRUE if the parameter is a string, FALSE otherwise.
*/
isString(str) {
return typeof str === 'string' || str instanceof String;
},
/**
* Simple escaping of RegExp strings.
*
* Does not handle advanced regular expressions, but will take care of
* most cases. Meant to be used when concatenating string to create a
* regular expressions.
*
* @param {string} str
* String to escape.
*
* @return {string}
* String with the regular expression special characters escaped.
*/
escapeRegex(str) {
return str.replace(/[\^$+*?[\]{}()\\]/g, '\\$&');
},
/**
* Helper function to uppercase the first letter of a string.
*
* @param {string} str
* String to transform.
*
* @return {string}
* String which has the first letter uppercased.
*/
ucFirst(str) {
return str.charAt(0).toUpperCase() + str.slice(1);
},
/**
* Transform a string into camel case. It will remove spaces, underscores
* and hyphens, and uppercase the letter directly following them.
*
* @param {string} str
* The string to try to transform into camel case.
*
* @return {string}
* The string transformed into camel case.
*/
camelCase(str) {
return str.replace(/(?:[ _-]+)([a-z])/g, (match, p1) => p1.toUpperCase());
},
/**
* Transforms a string into Pascal case. This is basically the same as
* camel case, except that it will upper case the first letter as well.
*
* @param {string} str
* The original string to transform into Pascal case.
*
* @return {string}
* The transformed string.
*/
pascalCase(str) {
return str.replace(/(?:^|[ _-]+)([a-z])/g, (match, p1) => p1.toUpperCase());
},
/**
* Gets the current page Drupal URL (excluding the query or base path).
*
* @return {string}
* The current internal path for Drupal. This would be the path
* without the "base path", however, it can still be a path alias.
*/
getCurrentPath() {
if (!this.getCurrentPath.path) {
this.getCurrentPath.path = null;
if (drupalSettings.path.baseUrl) {
const regex = new RegExp(`^${this.escapeRegex(drupalSettings.path.baseUrl)}`, 'i');
this.getCurrentPath.path = window.location.pathname.replace(regex, '');
} else {
throw Error('Base path is unavailable. This usually occurs if getCurrentPath() is run before the DOM is loaded.');
}
}
return this.getCurrentPath.path;
},
/**
* Parse URL query paramters from a URL.
*
* @param {string} url
* Full URL including the query parameters starting with '?' and
* separated with '&' characters.
*
* @return {Object}
* JSON formatted object which has the property names as the query
* key, and the property value is the query value.
*/
getUrlParams(url) {
const params = {};
const [uri] = (url || window.location.search).split('#', 2);
const [, query = null] = uri.split('?', 2);
if (query) {
query.split('&').forEach(param => {
const matches = /^([^=]+)=(.*)$/.exec(param);
if (matches) {
params[decodeURIComponent(matches[1])] = decodeURIComponent(matches[2]);
}
});
}
return params;
},
/**
* Build a URL based on a Drupal internal path. This function will test
* for the availability of clean URL's and prefer them if available.
* The URL components will be run through URL encoding.
*
* @param {string} rawUrl
* The URL to add the query parameters to. The URL can previously have
* query parameters already include. This will append additional params.
* @param {Object|string} params
* An object containing parameters to use as the URL query. Object
* property keys are the query variable names, and the object property
* value is the value to use for the query.
*
* @return {string}
* The valid Drupal URL based on values passed.
*/
buildUrl(rawUrl, params) {
let url = rawUrl || '';
// leave absolute URL's alone.
if (!/^([a-z]{2,5}:)?\/\//i.test(url)) {
const baseUrl = drupalSettings.path.baseUrl ? drupalSettings.path.baseUrl : '/';
url = url.replace(/^[/,\s]+|<front>|([/,\s]+$)/g, '');
url = `${baseUrl}${drupalSettings.path.pathPrefix}${url}`;
}
if (params) {
const paramConcat = (acc, entry) => `${acc}&${encodeURIComponent(entry[0])}=${encodeURIComponent(entry[1])}`;
const qry = this.isString(params) ? params : Object.entries(params).reduce(paramConcat, '').substring(1);
if (qry.length) {
const [base, fragment] = url.split('#', 2);
url = base + (base.indexOf('?') === -1 ? '?' : '&') + qry + (fragment ? `#${fragment}` : '');
}
}
return url;
},
/**
* Create a lambda that can make requests GET to a specified URI.
*
* The resulting high order function will return a Promise encapsulating a
* HTTP request to the URL with the parameters passed, and the XHR reference
* to allow aborting the request or listening for events.
*
* This allows for aborting the request, which at the time of this writing
* "fetch" does not support.
*
* @param {string} uri
* URI to create a request function for.
* @param {object} opts
* Options for how the request should be sent and the expected data
* results should appear.
*
* The following options are available:
* - method: The HTTP method to use when creating the request.
* - format: The expected response format (JSON, HTML, URL encoded, etc...)
* - encoding(optional): Encoding of content for POST and PUT requests.
*
* @return {function(query:object):Promise|function(content, query:object):Promise}
* A lambda that creates a request to specified URI with
* passed in URL query params.
*
* If the request method is POST or PUT then the resulting lambda expects
* a content and query parameter that contains the request body and
* aditional URI query parameters respectively. GET and other methods are
* not expecting to send data, and therefore exclude the content parameter.
*
* The lamba returns a Promise which can be used to process the
* results or errors.
*/
createRequester(uri, opts = {}) {
const ts = this;
opts = {
method: 'GET',
format: 'json',
encoding: 'urlencoded',
...opts
};
// Only needed for legacy support because IE 11 and older does not handle
// the JSON response type correctly and just returns a text response.
const formatResponse = resp => ts.isString(resp) && opts.format === 'json' ? JSON.parse(resp) : resp;
if (opts.method === 'POST' || opts.method === 'PUT') {
let bodyType;
let bodyFormatter;
// Default to the same data text encoding as the response format.
switch (opts.encoding) {
case 'json':
bodyType = 'application/json';
bodyFormatter = JSON.stringify;
break;
case 'html':
case 'urlencoded':
default:
bodyType = 'application/x-www-form-urlencoded';
bodyFormatter = data => Object.entries(data).reduce((acc, [key, val]) => `${acc}&${encodeURIComponent(key)}=${encodeURIComponent(val)}`, '').substring(1);
}
return (content, query) => {
const xhr = new XMLHttpRequest();
const promise = new Promise((resolve, reject) => {
xhr.open(opts.method, ts.buildUrl(uri, query), true);
xhr.responseType = opts.format;
xhr.onreadystatechange = function onStateChange() {
if (this.readyState === XMLHttpRequest.DONE) {
if (this.status === 200) resolve(formatResponse(this.response));else reject(new Error(`${this.status}: ${this.statusText}`));
}
};
// Unable to contact the server or no response.
xhr.onerror = () => reject(new Error('Unable to connect'));
xhr.onabort = () => reject(new Error('Cancelled'));
xhr.ontimeout = () => reject(new Error('Timeout'));
// Convert parameters into URL encoded values for returning.
if (content instanceof FormData) {
xhr.send(content);
} else {
xhr.setRequestHeader('Content-Type', bodyType);
xhr.send(ts.isString(content) ? content : bodyFormatter(content));
}
});
return {
promise,
xhr
};
};
}
// Basic GET or HEAD HTTP requests.
return query => {
const xhr = new XMLHttpRequest();
const promise = new Promise((resolve, reject) => {
xhr.open(opts.method, ts.buildUrl(uri, query), true);
xhr.responseType = opts.format;
xhr.onload = () => {
if (xhr.status === 200) resolve(formatResponse(xhr.response));else reject(new Error(`${xhr.status}: ${xhr.statusText}`));
};
// Unable to contact the server or no response.
xhr.onerror = () => reject(new Error('Unable to connect'));
xhr.onabort = () => reject(new Error('Cancelled'));
xhr.ontimeout = () => reject(new Error('Timeout'));
xhr.send();
});
return {
promise,
xhr
};
};
},
/**
* Send a Request to URI with provided parameters and return Promise.
*
* @param {string} uri
* URI to build the request for.
* @param {array|null} params
* Parameters to include when making the request.
* @param {object} opts
* Same set of options as for createRequester() function.
*
* @return {Promise}
* Promise wrapping the HTTP request.
*
* @see Drupal.Toolshed.createRequester()
*/
sendRequest(uri, params, opts = {}) {
const {
promise
} = this.createRequester(uri, opts)(params);
return promise;
},
/**
* Utility function used to find an object based on a string name.
*
* @param {string} name
* Fully qualified name of the object to fetch.
*
* @return {Object}
* the object matching the name, or NULL if it cannot be found.
*/
getObject(name) {
if (!(name && name.split)) return null;
const fetchObj = (obj, items) => {
const part = items.shift();
if (obj[part]) return items.length ? fetchObj(obj[part], items) : obj[part];
return null;
};
return fetchObj(window, name.split('.'));
},
/**
* Apply a callback to DOM elements with a specified CSS class name.
*
* @param {Element} context
* The DOM Element which either has the class or should be searched within
* for elements with the class name.
* @param {string} className
* The class name to search for.
* @param {Function} callback
* The callback function to apply to all the matching elements. The
* callback should accept the DOM element as its single parameter.
* @param {string} [once=null]
* If a non-null string then use this string to as a class name to
* indicate if this callback has been called previously on these elemnts.
*/
walkByClass(context, className, callback, once = null) {
const items = context.classList && context.classList.contains(className) ? [context] : context.getElementsByClassName(className);
this._applyToElements(items, callback, once);
},
/**
* Apply a callback to all DOM elements that match a selector query.
*
* @param {Element} context
* The DOM Element which either matches the selector or should be searched
* within for elements which match the selector.
* @param {string} query
* The select query to use in order to locate elements to apply the
* callback function to.
* @param {Function} callback
* The callback function to apply to all the matching elements. The
* callback should accept the DOM element as its single parameter.
* @param {string} [once=null]
* If a non-null string then use this string to as a class name to
* indicate if this callback has been called previously on these elemnts.
*/
walkBySelector(context, query, callback, once = null) {
const items = context.matches && context.matches(query) ? [context] : context.querySelectorAll(query);
this._applyToElements(items, callback, once);
},
/**
* A browser compliant method for applying a function to an iterable object.
*
* NOTE: Though the underlying call to Array.foreach() method supports
* additional parameters such as the index and the iterable object, this
* method could be applying to either a NodeList or a HTMLCollection depending
* on how we got here and it shouldn't be assumed the index is meaningful or
* can be relied on, especially in cases where elements might get removed.
*
* @param {Iterable<Element>} elements
* An iterable list of HTML Elements to apply the callback to. If a value
* is assigned to once, the once class name is checked before applying
* the callback to the element.
* @param {Function} callback
* A callback to apply to each of the DOM elements.
* @param {[type]} [once=null]
* A class name to check for, and apply to the elements to ensure they
* do not get processed multiple times with the same "once" value.
*/
_applyToElements(elements, callback, once = null) {
if (once) {
const origFunc = callback;
callback = item => {
if (!item.classList.contains(once)) {
item.classList.add(once);
return origFunc(item);
}
};
}
Array.prototype.forEach.call(elements, callback);
}
};
//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"file":"toolshed.js","names":["Drupal","Toolshed","isString","str","String","escapeRegex","replace","ucFirst","charAt","toUpperCase","slice","camelCase","match","p1","pascalCase","getCurrentPath","path","drupalSettings","baseUrl","regex","RegExp","window","location","pathname","Error","getUrlParams","url","params","uri","search","split","query","forEach","param","matches","exec","decodeURIComponent","buildUrl","rawUrl","test","pathPrefix","paramConcat","acc","entry","encodeURIComponent","qry","Object","entries","reduce","substring","length","base","fragment","indexOf","createRequester","opts","ts","method","format","encoding","formatResponse","resp","JSON","parse","bodyType","bodyFormatter","stringify","data","key","val","content","xhr","XMLHttpRequest","promise","Promise","resolve","reject","open","responseType","onreadystatechange","onStateChange","readyState","DONE","status","response","statusText","onerror","onabort","ontimeout","FormData","send","setRequestHeader","onload","sendRequest","getObject","name","fetchObj","obj","items","part","shift","walkByClass","context","className","callback","once","classList","contains","getElementsByClassName","_applyToElements","walkBySelector","querySelectorAll","elements","origFunc","item","add","Array","prototype","call"],"sources":["toolshed.es6.js"],"sourcesContent":["// Define the Toolshed object scope.\nDrupal.Toolshed = {\n  /**\n   * Check if this value is a string or not. Helps to encapsulate a safe way to\n   * test for string.\n   *\n   * @param {*} str\n   *   The variable to check if this is a string.\n   *\n   * @return {bool}\n   *   TRUE if the parameter is a string, FALSE otherwise.\n   */\n  isString(str) {\n    return typeof str === 'string' || str instanceof String;\n  },\n\n  /**\n   * Simple escaping of RegExp strings.\n   *\n   * Does not handle advanced regular expressions, but will take care of\n   * most cases. Meant to be used when concatenating string to create a\n   * regular expressions.\n   *\n   * @param  {string} str\n   *  String to escape.\n   *\n   * @return {string}\n   *  String with the regular expression special characters escaped.\n   */\n  escapeRegex(str) {\n    return str.replace(/[\\^$+*?[\\]{}()\\\\]/g, '\\\\$&');\n  },\n\n  /**\n   * Helper function to uppercase the first letter of a string.\n   *\n   * @param {string} str\n   *  String to transform.\n   *\n   * @return {string}\n   *  String which has the first letter uppercased.\n   */\n  ucFirst(str) {\n    return str.charAt(0).toUpperCase() + str.slice(1);\n  },\n\n  /**\n   * Transform a string into camel case. It will remove spaces, underscores\n   * and hyphens, and uppercase the letter directly following them.\n   *\n   * @param {string} str\n   *  The string to try to transform into camel case.\n   *\n   * @return {string}\n   *  The string transformed into camel case.\n   */\n  camelCase(str) {\n    return str.replace(/(?:[ _-]+)([a-z])/g, (match, p1) => p1.toUpperCase());\n  },\n\n  /**\n   * Transforms a string into Pascal case. This is basically the same as\n   * camel case, except that it will upper case the first letter as well.\n   *\n   * @param {string} str\n   *  The original string to transform into Pascal case.\n   *\n   * @return {string}\n   *  The transformed string.\n   */\n  pascalCase(str) {\n    return str.replace(/(?:^|[ _-]+)([a-z])/g, (match, p1) => p1.toUpperCase());\n  },\n\n  /**\n   * Gets the current page Drupal URL (excluding the query or base path).\n   *\n   * @return {string}\n   *  The current internal path for Drupal. This would be the path\n   *  without the \"base path\", however, it can still be a path alias.\n   */\n  getCurrentPath() {\n    if (!this.getCurrentPath.path) {\n      this.getCurrentPath.path = null;\n\n      if (drupalSettings.path.baseUrl) {\n        const regex = new RegExp(`^${this.escapeRegex(drupalSettings.path.baseUrl)}`, 'i');\n        this.getCurrentPath.path = window.location.pathname.replace(regex, '');\n      }\n      else {\n        throw Error('Base path is unavailable. This usually occurs if getCurrentPath() is run before the DOM is loaded.');\n      }\n    }\n\n    return this.getCurrentPath.path;\n  },\n\n  /**\n   * Parse URL query paramters from a URL.\n   *\n   * @param {string} url\n   *  Full URL including the query parameters starting with '?' and\n   *  separated with '&' characters.\n   *\n   * @return {Object}\n   *  JSON formatted object which has the property names as the query\n   *  key, and the property value is the query value.\n   */\n  getUrlParams(url) {\n    const params = {};\n    const [uri] = (url || window.location.search).split('#', 2);\n    const [, query = null] = uri.split('?', 2);\n\n    if (query) {\n      query.split('&').forEach((param) => {\n        const matches = /^([^=]+)=(.*)$/.exec(param);\n\n        if (matches) {\n          params[decodeURIComponent(matches[1])] = decodeURIComponent(matches[2]);\n        }\n      });\n    }\n\n    return params;\n  },\n\n  /**\n   * Build a URL based on a Drupal internal path. This function will test\n   * for the availability of clean URL's and prefer them if available.\n   * The URL components will be run through URL encoding.\n   *\n   * @param {string} rawUrl\n   *  The URL to add the query parameters to. The URL can previously have\n   *  query parameters already include. This will append additional params.\n   * @param {Object|string} params\n   *  An object containing parameters to use as the URL query. Object\n   *  property keys are the query variable names, and the object property\n   *  value is the value to use for the query.\n   *\n   * @return {string}\n   *  The valid Drupal URL based on values passed.\n   */\n  buildUrl(rawUrl, params) {\n    let url = rawUrl || '';\n\n    // leave absolute URL's alone.\n    if (!(/^([a-z]{2,5}:)?\\/\\//i).test(url)) {\n      const baseUrl = (drupalSettings.path.baseUrl ? drupalSettings.path.baseUrl : '/');\n      url = url.replace(/^[/,\\s]+|<front>|([/,\\s]+$)/g, '');\n      url = `${baseUrl}${drupalSettings.path.pathPrefix}${url}`;\n    }\n\n    if (params) {\n      const paramConcat = (acc, entry) => `${acc}&${encodeURIComponent(entry[0])}=${encodeURIComponent(entry[1])}`;\n      const qry = this.isString(params) ? params : Object.entries(params).reduce(paramConcat, '').substring(1);\n\n      if (qry.length) {\n        const [base, fragment] = url.split('#', 2);\n        url = base + (base.indexOf('?') === -1 ? '?' : '&') + qry + (fragment ? `#${fragment}` : '');\n      }\n    }\n\n    return url;\n  },\n\n  /**\n   * Create a lambda that can make requests GET to a specified URI.\n   *\n   * The resulting high order function will return a Promise encapsulating a\n   * HTTP request to the URL with the parameters passed, and the XHR reference\n   * to allow aborting the request or listening for events.\n   *\n   * This allows for aborting the request, which at the time of this writing\n   * \"fetch\" does not support.\n   *\n   * @param {string} uri\n   *   URI to create a request function for.\n   * @param {object} opts\n   *   Options for how the request should be sent and the expected data\n   *   results should appear.\n   *\n   *   The following options are available:\n   *    - method: The HTTP method to use when creating the request.\n   *    - format: The expected response format (JSON, HTML, URL encoded, etc...)\n   *    - encoding(optional): Encoding of content for POST and PUT requests.\n   *\n   * @return {function(query:object):Promise|function(content, query:object):Promise}\n   *   A lambda that creates a request to specified URI with\n   *   passed in URL query params.\n   *\n   *   If the request method is POST or PUT then the resulting lambda expects\n   *   a content and query parameter that contains the request body and\n   *   aditional URI query parameters respectively. GET and other methods are\n   *   not expecting to send data, and therefore exclude the content parameter.\n   *\n   *   The lamba returns a Promise which can be used to process the\n   *   results or errors.\n   */\n  createRequester(uri, opts = {}) {\n    const ts = this;\n\n    opts = {\n      method: 'GET',\n      format: 'json',\n      encoding: 'urlencoded',\n      ...opts,\n    };\n\n    // Only needed for legacy support because IE 11 and older does not handle\n    // the JSON response type correctly and just returns a text response.\n    const formatResponse = (resp) => (ts.isString(resp) && opts.format === 'json') ? JSON.parse(resp) : resp;\n\n    if (opts.method === 'POST' || opts.method === 'PUT') {\n      let bodyType;\n      let bodyFormatter;\n\n      // Default to the same data text encoding as the response format.\n      switch (opts.encoding) {\n        case 'json':\n          bodyType = 'application/json';\n          bodyFormatter = JSON.stringify;\n          break;\n\n        case 'html':\n        case 'urlencoded':\n        default:\n          bodyType = 'application/x-www-form-urlencoded';\n          bodyFormatter = (data) => Object.entries(data).reduce((acc, [key, val]) => `${acc}&${encodeURIComponent(key)}=${encodeURIComponent(val)}`, '').substring(1);\n      }\n\n      return (content, query) => {\n        const xhr = new XMLHttpRequest();\n        const promise = new Promise((resolve, reject) => {\n          xhr.open(opts.method, ts.buildUrl(uri, query), true);\n          xhr.responseType = opts.format;\n          xhr.onreadystatechange = function onStateChange() {\n            if (this.readyState === XMLHttpRequest.DONE) {\n              if (this.status === 200) resolve(formatResponse(this.response));\n              else reject(new Error(`${this.status}: ${this.statusText}`));\n            }\n          };\n\n          // Unable to contact the server or no response.\n          xhr.onerror = () => reject(new Error('Unable to connect'));\n          xhr.onabort = () => reject(new Error('Cancelled'));\n          xhr.ontimeout = () => reject(new Error('Timeout'));\n\n          // Convert parameters into URL encoded values for returning.\n          if (content instanceof FormData) {\n            xhr.send(content);\n          }\n          else {\n            xhr.setRequestHeader('Content-Type', bodyType);\n            xhr.send(ts.isString(content) ? content : bodyFormatter(content));\n          }\n        });\n\n        return { promise, xhr };\n      };\n    }\n\n    // Basic GET or HEAD HTTP requests.\n    return (query) => {\n      const xhr = new XMLHttpRequest();\n      const promise = new Promise((resolve, reject) => {\n        xhr.open(opts.method, ts.buildUrl(uri, query), true);\n        xhr.responseType = opts.format;\n\n        xhr.onload = () => {\n          if (xhr.status === 200) resolve(formatResponse(xhr.response));\n          else reject(new Error(`${xhr.status}: ${xhr.statusText}`));\n        };\n\n        // Unable to contact the server or no response.\n        xhr.onerror = () => reject(new Error('Unable to connect'));\n        xhr.onabort = () => reject(new Error('Cancelled'));\n        xhr.ontimeout = () => reject(new Error('Timeout'));\n        xhr.send();\n      });\n\n      return { promise, xhr };\n    };\n  },\n\n  /**\n   * Send a Request to URI with provided parameters and return Promise.\n   *\n   * @param {string} uri\n   *   URI to build the request for.\n   * @param {array|null} params\n   *   Parameters to include when making the request.\n   * @param {object} opts\n   *  Same set of options as for createRequester() function.\n   *\n   * @return {Promise}\n   *   Promise wrapping the HTTP request.\n   *\n   * @see Drupal.Toolshed.createRequester()\n   */\n  sendRequest(uri, params, opts = { }) {\n    const { promise } = this.createRequester(uri, opts)(params);\n    return promise;\n  },\n\n  /**\n   * Utility function used to find an object based on a string name.\n   *\n   * @param {string} name\n   *  Fully qualified name of the object to fetch.\n   *\n   * @return {Object}\n   *  the object matching the name, or NULL if it cannot be found.\n   */\n  getObject(name) {\n    if (!(name && name.split)) return null;\n\n    const fetchObj = (obj, items) => {\n      const part = items.shift();\n\n      if (obj[part]) return items.length ? fetchObj(obj[part], items) : obj[part];\n      return null;\n    };\n\n    return fetchObj(window, name.split('.'));\n  },\n\n  /**\n   * Apply a callback to DOM elements with a specified CSS class name.\n   *\n   * @param {Element} context\n   *   The DOM Element which either has the class or should be searched within\n   *   for elements with the class name.\n   * @param {string} className\n   *   The class name to search for.\n   * @param {Function} callback\n   *   The callback function to apply to all the matching elements. The\n   *   callback should accept the DOM element as its single parameter.\n   * @param {string} [once=null]\n   *   If a non-null string then use this string to as a class name to\n   *   indicate if this callback has been called previously on these elemnts.\n   */\n  walkByClass(context, className, callback, once = null) {\n    const items = context.classList && context.classList.contains(className)\n      ? [context] : context.getElementsByClassName(className);\n\n    this._applyToElements(items, callback, once);\n  },\n\n  /**\n   * Apply a callback to all DOM elements that match a selector query.\n   *\n   * @param {Element} context\n   *   The DOM Element which either matches the selector or should be searched\n   *   within for elements which match the selector.\n   * @param {string} query\n   *   The select query to use in order to locate elements to apply the\n   *   callback function to.\n   * @param {Function} callback\n   *   The callback function to apply to all the matching elements. The\n   *   callback should accept the DOM element as its single parameter.\n   * @param {string} [once=null]\n   *   If a non-null string then use this string to as a class name to\n   *   indicate if this callback has been called previously on these elemnts.\n   */\n  walkBySelector(context, query, callback, once = null) {\n    const items = context.matches && context.matches(query)\n      ? [context] : context.querySelectorAll(query);\n\n    this._applyToElements(items, callback, once);\n  },\n\n  /**\n   * A browser compliant method for applying a function to an iterable object.\n   *\n   * NOTE: Though the underlying call to Array.foreach() method supports\n   * additional parameters such as the index and the iterable object, this\n   * method could be applying to either a NodeList or a HTMLCollection depending\n   * on how we got here and it shouldn't be assumed the index is meaningful or\n   * can be relied on, especially in cases where elements might get removed.\n   *\n   * @param {Iterable<Element>} elements\n   *   An iterable list of HTML Elements to apply the callback to. If a value\n   *   is assigned to once, the once class name is checked before applying\n   *   the callback to the element.\n   * @param {Function} callback\n   *   A callback to apply to each of the DOM elements.\n   * @param {[type]} [once=null]\n   *   A class name to check for, and apply to the elements to ensure they\n   *   do not get processed multiple times with the same \"once\" value.\n   */\n  _applyToElements(elements, callback, once = null) {\n    if (once) {\n      const origFunc = callback;\n\n      callback = (item) => {\n        if (!item.classList.contains(once)) {\n          item.classList.add(once);\n          return origFunc(item);\n        }\n      };\n    }\n\n    Array.prototype.forEach.call(elements, callback);\n  },\n};\n"],"mappings":"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"}
