demarches-normaliennes/app/javascript/shared/utils.js

123 lines
2.9 KiB
JavaScript
Raw Normal View History

import Rails from '@rails/ujs';
2018-10-09 11:32:27 +02:00
import $ from 'jquery';
import debounce from 'debounce';
export { debounce };
export const { fire } = Rails;
2018-10-09 11:32:27 +02:00
export function show(el) {
el && el.classList.remove('hidden');
2018-09-06 19:23:27 +02:00
}
export function hide(el) {
el && el.classList.add('hidden');
2018-09-06 19:23:27 +02:00
}
export function toggle(el, force) {
if (force == undefined) {
el & el.classList.toggle('hidden');
} else if (force) {
el && el.classList.remove('hidden');
} else {
el && el.classList.add('hidden');
}
2018-09-06 19:23:27 +02:00
}
2018-10-09 11:32:27 +02:00
2019-11-19 17:55:30 +01:00
export function enable(el) {
el && (el.disabled = false);
}
export function disable(el) {
el && (el.disabled = true);
}
export function hasClass(el, cssClass) {
return el && el.classList.contains(cssClass);
}
export function addClass(el, cssClass) {
el && el.classList.add(cssClass);
}
export function removeClass(el, cssClass) {
el && el.classList.remove(cssClass);
}
2018-10-09 11:32:27 +02:00
export function delegate(eventNames, selector, callback) {
eventNames
.split(' ')
2020-04-30 15:42:29 +02:00
.forEach((eventName) =>
2018-10-09 11:32:27 +02:00
Rails.delegate(document, selector, eventName, callback)
);
}
export function ajax(options) {
return new Promise((resolve, reject) => {
Object.assign(options, {
success: (response, statusText, xhr) => {
resolve({ response, statusText, xhr });
},
error: (response, statusText, xhr) => {
let error = new Error(`Erreur ${xhr.status} : ${statusText}`);
Object.assign(error, { response, statusText, xhr });
reject(error);
}
});
Rails.ajax(options);
});
}
2018-10-09 11:32:27 +02:00
export function getJSON(url, data, method = 'get') {
data = method !== 'get' && data ? JSON.stringify(data) : data;
return Promise.resolve(
$.ajax({
method,
url,
data,
contentType: 'application/json',
dataType: 'json'
})
);
2018-10-09 11:32:27 +02:00
}
export function scrollTo(container, scrollTo) {
2018-10-09 11:43:38 +02:00
container.scrollTop =
offset(scrollTo).top - offset(container).top + container.scrollTop;
2018-10-09 11:32:27 +02:00
}
export function scrollToBottom(container) {
2018-10-09 11:43:38 +02:00
container.scrollTop = container.scrollHeight;
2018-10-09 11:32:27 +02:00
}
export function on(selector, eventName, fn) {
2020-04-30 15:42:29 +02:00
[...document.querySelectorAll(selector)].forEach((element) =>
element.addEventListener(eventName, (event) => fn(event, event.detail))
2018-10-09 11:32:27 +02:00
);
}
2018-10-09 11:43:38 +02:00
export function to(promise) {
2020-04-30 15:42:29 +02:00
return promise.then((result) => [result]).catch((error) => [null, error]);
}
2020-01-23 15:12:19 +01:00
export function isNumeric(n) {
return !isNaN(parseFloat(n)) && isFinite(n);
}
2018-10-09 11:43:38 +02:00
function offset(element) {
const rect = element.getBoundingClientRect();
return {
top: rect.top + document.body.scrollTop,
left: rect.left + document.body.scrollLeft
};
}
// Takes a promise, and return a promise that times out after the given delay.
export function timeoutable(promise, timeoutDelay) {
let timeoutPromise = new Promise((resolve, reject) => {
setTimeout(() => {
reject(new Error(`Promise timed out after ${timeoutDelay}ms`));
}, timeoutDelay);
});
return Promise.race([promise, timeoutPromise]);
}