Source: helpers.js

  1. 'use strict'
  3. /**
  4.  * @module helpers
  5.  */
  6. export const helpers = {};
  8. /**
  9.  * Converts a Javascript value to a base-64 encoded string.
  10.  *
  11.  * @param {*} obj a Javascript value, usually an object or array, to be converted.
  12.  * @return {string} a base-64 encoded string.
  13.  * @memberOf module:helpers
  14.  */
  15. helpers.toBase64 = function (obj) {
  16.   return btoa(JSON.stringify(obj));
  17. }
  19. /**
  20.  * Converts a base-64 encoded string to a Javascript value.
  21.  *
  22.  * @param {string} str a base-64 encoded string.
  23.  * @return {*} a Javascript value.
  24.  * @memberOf module:helpers
  25.  */
  26. helpers.fromBase64 = function (str) {
  27.   return JSON.parse(atob(str));
  28. }
  30. /**
  31.  * A version of {@link JSON.stringify} that returns a canonical JSON format.
  32.  *
  33.  * 'Canonical JSON' means that the same object should always be stringified to the exact same string.
  34.  * JavaScripts native {@link JSON.stringify} does not guarantee any order for object keys when serializing.
  35.  *
  36.  * @param value the value to stringify.
  37.  * @returns {string} the stringified value.
  38.  * @memberOf module:helpers
  39.  * @preserve The code is extracted from https://github.com/mirkokiefer/canonical-json.
  40.  */
  41. helpers.stringify = function (value) {
  43.   function isObject(object) {
  44.     return Object.prototype.toString.call(object) === '[object Object]'
  45.   }
  47.   function copyObjectWithSortedKeys(object) {
  48.     if (isObject(object)) {
  49.       const newObj = {}
  50.       const keysSorted = Object.keys(object).sort()
  51.       let key
  52.       for (let i = 0, len = keysSorted.length; i < len; i++) {
  53.         key = keysSorted[i]
  54.         newObj[key] = copyObjectWithSortedKeys(object[key])
  55.       }
  56.       return newObj
  57.     } else if (Array.isArray(object)) {
  58.       return object.map(copyObjectWithSortedKeys)
  59.     } else {
  60.       return object
  61.     }
  62.   }
  64.   return JSON.stringify(copyObjectWithSortedKeys(value))
  65. }
  67. /**
  68.  * A simple 53-bits hashing algorithm with good enough distribution.
  69.  *
  70.  * @param {*} obj the value to hash.
  71.  * @param {number} seed a seed.
  72.  * @return {number} the hashed value.
  73.  * @memberOf module:helpers
  74.  * @preserve The code is extracted from https://stackoverflow.com/a/52171480.
  75.  */
  76. helpers.goodFastHash = function (obj, seed) {
  78.   const newStr = obj ? helpers.stringify(obj) : '';
  79.   const newSeed = seed ? seed : 0;
  80.   let h1 = 0xdeadbeef ^ newSeed;
  81.   let h2 = 0x41c6ce57 ^ newSeed;
  83.   for (let i = 0, ch; i < newStr.length; i++) {
  84.     ch = newStr.charCodeAt(i);
  85.     h1 = Math.imul(h1 ^ ch, 2654435761);
  86.     h2 = Math.imul(h2 ^ ch, 1597334677);
  87.   }
  89.   h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
  90.   h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
  92.   return 4294967296 * (2097151 & h2) + (h1 >>> 0);
  93. }
  95. /**
  96.  * Inject multiple scripts.
  97.  *
  98.  * @param {Element} el the root node where the scripts will be injected.
  99.  * @param {Array<string>} urls the scripts URL.
  100.  * @return a {Promise<*>}.
  101.  */
  102. helpers.injectScripts = function (el, urls) {
  104.   let promise = null;
  106.   for (let i = 0; i < urls.length; i++) {
  107.     if (promise) {
  108.       promise = promise.then(() => this.injectScript(el, urls[i]));
  109.     } else {
  110.       promise = this.injectScript(el, urls[i]);
  111.     }
  112.   }
  113.   return promise;
  114. }
  116. /**
  117.  * Inject a single script.
  118.  *
  119.  * @param {Element} el the root node where the script will be injected.
  120.  * @param {string} url the script URL.
  121.  * @return a {Promise<*>}.
  122.  * @preserve The code is extracted from https://gist.github.com/james2doyle/28a59f8692cec6f334773007b31a1523.
  123.  */
  124. helpers.injectScript = function (el, url) {
  125.   return el ? new Promise((resolve, reject) => {
  126.     const script = document.createElement('script');
  127.     script.src = url;
  128.     script.async = true;
  129.     script.onerror = function (err) {
  130.       console.log('Script failed : ' + url, err);
  131.       reject(url, script, err);
  132.     }
  133.     script.onload = function () {
  134.       console.log('Script loaded : ' + url);
  135.       resolve(url, script)
  136.     }
  137.     el.appendChild(script);
  138.   }) : Promise.reject('invalid node');
  139. }
  141. /**
  142.  * Inject multiple stylesheets.
  143.  *
  144.  * @param {Element} el the root node where the scripts will be injected.
  145.  * @param {Array<String>} urls the stylesheets URL.
  146.  * @return a {Promise<*>}.
  147.  */
  148. helpers.injectStyles = function (el, urls) {
  150.   let promise = null;
  152.   for (let i = 0; i < urls.length; i++) {
  153.     if (promise) {
  154.       promise = promise.then(() => this.injectStyle(el, urls[i]));
  155.     } else {
  156.       promise = this.injectStyle(el, urls[i]);
  157.     }
  158.   }
  159.   return promise;
  160. }
  162. /**
  163.  * Inject a single stylesheet.
  164.  *
  165.  * @param {Element} el the root node where the script will be injected.
  166.  * @param {string} url the stylesheet URL.
  167.  * @return a {Promise<*>}.
  168.  * @preserve The code is extracted from https://gist.github.com/james2doyle/28a59f8692cec6f334773007b31a1523.
  169.  */
  170. helpers.injectStyle = function (el, url) {
  171.   return el ? new Promise((resolve, reject) => {
  172.     const link = document.createElement('link');
  173.     link.href = url;
  174.     link.rel = 'stylesheet';
  175.     el.appendChild(link);
  176.     console.log('Stylesheet loaded : ' + url);
  177.     resolve(url, link);
  178.   }) : Promise.reject('invalid node');
  179. }
  181. /**
  182.  * Chunk a list and gives the UI thread a chance to process any pending UI events between each chunk (keeps the UI active).
  183.  *
  184.  * @param {Array<Object>} array the array to chunk and process.
  185.  * @param {function(Object, Object): void} callback the callback to call for each array element.
  186.  * @param {Object} context misc. contextual information (optional).
  187.  * @param {number} maxTimePerChunk the maximum time to spend (guidance) in the callback for each chunk (optional).
  188.  *
  189.  * @preserve The code is extracted from https://stackoverflow.com/a/10344560.
  190.  */
  191. helpers.forEach = function (array, callback, context, maxTimePerChunk) {
  193.   array = array || [];
  194.   context = context || {};
  195.   callback = callback || function (item, context) {
  196.   };
  197.   maxTimePerChunk = maxTimePerChunk || 200;
  198.   let index = 0;
  200.   function now() {
  201.     return new Date().getTime();
  202.   }
  204.   function doChunk() {
  206.     const startTime = now();
  208.     while (index < array.length && (now() - startTime) <= maxTimePerChunk) {
  209.       callback(array[index], context);
  210.       ++index;
  211.     }
  212.     if (index < array.length) {
  213.       setTimeout(doChunk, 1);
  214.     }
  215.   }
  217.   doChunk();
  218. }
  220. /**
  221.  * Delay a javascript function call. Executes only the last call.
  222.  *
  223.  * @param func the function to execute.
  224.  * @param timeout the delay before the function can be called.
  225.  * @returns {function}
  226.  */
  227. helpers.debounceLast = function (func, timeout = 300) {
  228.   let timer;
  229.   return (...args) => {
  230.     clearTimeout(timer);
  231.     timer = setTimeout(() => {
  232.       func.apply(this, args);
  233.     }, timeout);
  234.   };
  235. }
  237. /**
  238.  * Delay a javascript function call. Executes only the first call.
  239.  *
  240.  * @param func the function to execute.
  241.  * @param timeout the delay before the function can be called again.
  242.  * @returns {function}
  243.  */
  244. helpers.debounceFirst = function (func, timeout = 300) {
  245.   let timer;
  246.   return (...args) => {
  247.     if (!timer) {
  248.       func.apply(this, args);
  249.     }
  250.     clearTimeout(timer);
  251.     timer = setTimeout(() => {
  252.       timer = undefined;
  253.     }, timeout);
  254.   };
  255. }
  257. /**
  258.  * Download a JSON object or an array of JSON objects.
  259.  *
  260.  * @param filename the name of the downloaded file.
  261.  * @param data the data to download.
  262.  */
  263. helpers.download = function (filename, data) {
  265.   const blob = new Blob([JSON.stringify(data)], {type: "application/json;charset=utf-8"});
  266.   const isIE = false || !!document.documentMode;
  268.   if (isIE) {
  269.     window.navigator.msSaveBlob(blob, filename);
  270.   } else {
  271.     const url = window.URL || window.webkitURL;
  272.     const link = url.createObjectURL(blob);
  273.     const a = document.createElement("a");
  274.     a.download = filename;
  275.     a.href = link;
  276.     document.body.appendChild(a);
  277.     a.click();
  278.     document.body.removeChild(a);
  279.   }
  280. }