mirror of
https://github.com/S2-/gitlit
synced 2025-08-03 04:40:05 +02:00
545 lines
24 KiB
JavaScript
545 lines
24 KiB
JavaScript
;
|
|
|
|
(function () {
|
|
/**
|
|
* NonBlock.js
|
|
*
|
|
* Copyright (c) 2017-2018 Hunter Perrin
|
|
*
|
|
* @author Hunter Perrin <hperrin@gmail.com>
|
|
*/
|
|
'use strict';
|
|
|
|
function _toConsumableArray(arr) {
|
|
if (Array.isArray(arr)) {
|
|
for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
|
|
arr2[i] = arr[i];
|
|
}
|
|
|
|
return arr2;
|
|
} else {
|
|
return Array.from(arr);
|
|
}
|
|
}
|
|
|
|
function _classCallCheck(instance, Constructor) {
|
|
if (!(instance instanceof Constructor)) {
|
|
throw new TypeError("Cannot call a class as a function");
|
|
}
|
|
}
|
|
|
|
var _createClass = function () {
|
|
function defineProperties(target, props) {
|
|
for (var i = 0; i < props.length; i++) {
|
|
var descriptor = props[i];
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
|
descriptor.configurable = true;
|
|
if ("value" in descriptor) descriptor.writable = true;
|
|
Object.defineProperty(target, descriptor.key, descriptor);
|
|
}
|
|
}
|
|
|
|
return function (Constructor, protoProps, staticProps) {
|
|
if (protoProps) defineProperties(Constructor.prototype, protoProps);
|
|
if (staticProps) defineProperties(Constructor, staticProps);
|
|
return Constructor;
|
|
};
|
|
}();
|
|
|
|
(function (NonBlock) {
|
|
window.NonBlockJs = {
|
|
NonBlock: NonBlock
|
|
};
|
|
if (document.body) {
|
|
window.NonBlockJs.nonBlock = new NonBlock(document.body);
|
|
} else {
|
|
document.addEventListener('DOMContentLoaded', function () {
|
|
window.NonBlockJs.nonBlock = new NonBlock(document.body);
|
|
});
|
|
}
|
|
})(function () {
|
|
var NonBlock = function () {
|
|
function NonBlock(root, mode) {
|
|
_classCallCheck(this, NonBlock);
|
|
|
|
this.root = root;
|
|
|
|
// Detect if we can use "pointer-events".
|
|
// Can't use document.documentElement.style because IE9/IE10 report true,
|
|
// but only support it on SVG elements, not HTML elements.
|
|
var windowStyle = window.getComputedStyle(document.body);
|
|
this.pointerEventsSupport = windowStyle.pointerEvents && windowStyle.pointerEvents === 'auto';
|
|
|
|
// Some useful regexes.
|
|
this.regexOn = /^on/;
|
|
this.regexMouseEvents = /^(dbl)?click$|^mouse(move|down|up|over|out|enter|leave)$|^contextmenu$/;
|
|
this.regexUiEvents = /^(focus|blur|select|change|reset)$|^key(press|down|up)$/;
|
|
this.regexHtmlEvents = /^(scroll|resize|(un)?load|abort|error)$/;
|
|
// Whether to use event constructors.
|
|
this.useEventConstructors = true;
|
|
try {
|
|
var e = new MouseEvent('click');
|
|
} catch (e) {
|
|
this.useEventConstructors = false;
|
|
}
|
|
|
|
// If mode is not provided, use PointerEvents, if it's supported.
|
|
if (typeof mode === 'undefined') {
|
|
this.mode = this.pointerEventsSupport ? 'PointerEvents' : 'EventForwarding';
|
|
} else {
|
|
this.mode = mode;
|
|
}
|
|
|
|
// Init the current mode.
|
|
if (this['init' + this.mode]) {
|
|
this['init' + this.mode]();
|
|
}
|
|
}
|
|
|
|
_createClass(NonBlock, [{
|
|
key: 'initPointerEvents',
|
|
value: function initPointerEvents() {
|
|
var _this = this;
|
|
|
|
// Using pointer-events, we can just detect whether an element is being
|
|
// hovered over. No event forwarding necessary.
|
|
|
|
this.addCSS('.nonblock{transition:opacity .3s ease; pointer-events: none;}.nonblock:hover,.nonblock-hover{opacity:.1 !important;}');
|
|
|
|
this.onmousemove = function (ev) {
|
|
var nonblocks = document.querySelectorAll('.nonblock');
|
|
|
|
var _iteratorNormalCompletion = true;
|
|
var _didIteratorError = false;
|
|
var _iteratorError = undefined;
|
|
|
|
try {
|
|
for (var _iterator = nonblocks[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
var nonblock = _step.value;
|
|
|
|
var rect = nonblock.getBoundingClientRect();
|
|
if (ev.clientX >= rect.left && ev.clientX <= rect.right && ev.clientY >= rect.top && ev.clientY <= rect.bottom) {
|
|
if (!nonblock.classList.contains('nonblock-hover')) {
|
|
nonblock.classList.add('nonblock-hover');
|
|
if (_this.isSimulateMouse(nonblock) && ev.isTrusted) {
|
|
_this.domEvent(nonblock, 'onmouseenter', ev, false);
|
|
_this.domEvent(nonblock, 'onmouseover', ev, true);
|
|
}
|
|
} else if (_this.isSimulateMouse(nonblock) && ev.isTrusted) {
|
|
_this.domEvent(nonblock, 'onmousemove', ev, true);
|
|
}
|
|
} else {
|
|
if (nonblock.classList.contains('nonblock-hover')) {
|
|
if (_this.isSimulateMouse(nonblock) && ev.isTrusted) {
|
|
_this.domEvent(nonblock, 'onmouseout', ev, true);
|
|
_this.domEvent(nonblock, 'onmouseleave', ev, false);
|
|
}
|
|
nonblock.classList.remove('nonblock-hover');
|
|
}
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError = true;
|
|
_iteratorError = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion && _iterator.return) {
|
|
_iterator.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError) {
|
|
throw _iteratorError;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
this.root.addEventListener('mousemove', this.onmousemove);
|
|
}
|
|
}, {
|
|
key: 'initEventForwarding',
|
|
value: function initEventForwarding() {
|
|
var _this2 = this;
|
|
|
|
// No pointer-events means we have to fall back to using event forwarding.
|
|
|
|
this.addCSS('.nonblock{transition:opacity .3s ease;}\n.nonblock:hover{opacity:.1 !important;}\n.nonblock-hide{position:absolute !important;left:-10000000px !important;right:10000000px !important;}\n.nonblock-cursor-auto{cursor:auto !important;}\n.nonblock-cursor-default{cursor:default !important;}\n.nonblock-cursor-none{cursor:none !important;}\n.nonblock-cursor-context-menu{cursor:context-menu !important;}\n.nonblock-cursor-help{cursor:help !important;}\n.nonblock-cursor-pointer{cursor:pointer !important;}\n.nonblock-cursor-progress{cursor:progress !important;}\n.nonblock-cursor-wait{cursor:wait !important;}\n.nonblock-cursor-cell{cursor:cell !important;}\n.nonblock-cursor-crosshair{cursor:crosshair !important;}\n.nonblock-cursor-text{cursor:text !important;}\n.nonblock-cursor-vertical-text{cursor:vertical-text !important;}\n.nonblock-cursor-alias{cursor:alias !important;}\n.nonblock-cursor-copy{cursor:copy !important;}\n.nonblock-cursor-move{cursor:move !important;}\n.nonblock-cursor-no-drop{cursor:no-drop !important;}\n.nonblock-cursor-not-allowed{cursor:not-allowed !important;}\n.nonblock-cursor-all-scroll{cursor:all-scroll !important;}\n.nonblock-cursor-col-resize{cursor:col-resize !important;}\n.nonblock-cursor-row-resize{cursor:row-resize !important;}\n.nonblock-cursor-n-resize{cursor:n-resize !important;}\n.nonblock-cursor-e-resize{cursor:e-resize !important;}\n.nonblock-cursor-s-resize{cursor:s-resize !important;}\n.nonblock-cursor-w-resize{cursor:w-resize !important;}\n.nonblock-cursor-ne-resize{cursor:ne-resize !important;}\n.nonblock-cursor-nw-resize{cursor:nw-resize !important;}\n.nonblock-cursor-se-resize{cursor:se-resize !important;}\n.nonblock-cursor-sw-resize{cursor:sw-resize !important;}\n.nonblock-cursor-ew-resize{cursor:ew-resize !important;}\n.nonblock-cursor-ns-resize{cursor:ns-resize !important;}\n.nonblock-cursor-nesw-resize{cursor:nesw-resize !important;}\n.nonblock-cursor-nwse-resize{cursor:nwse-resize !important;}\n.nonblock-cursor-zoom-in{cursor:zoom-in !important;}\n.nonblock-cursor-zoom-out{cursor:zoom-out !important;}\n.nonblock-cursor-grab{cursor:grab !important;}\n.nonblock-cursor-grabbing{cursor:grabbing !important;}');
|
|
|
|
// This keeps track of the last element the mouse was over, so
|
|
// mouseleave, mouseenter, etc can be called.
|
|
this.nonBlockLastElem = null;
|
|
// These are used for selecting text under a nonblock element.
|
|
this.isOverTextNode = false;
|
|
this.selectingText = false;
|
|
|
|
this.onmouseenter = function (ev) {
|
|
var nonblock = void 0;
|
|
if (ev.isTrusted && (nonblock = _this2.getNonBlocking(ev.target))) {
|
|
_this2.nonBlockLastElem = false;
|
|
if (!_this2.isPropagating(nonblock)) {
|
|
ev.stopPropagation();
|
|
}
|
|
}
|
|
};
|
|
this.onmouseleave = function (ev) {
|
|
var nonblock = void 0;
|
|
if (ev.isTrusted && (nonblock = _this2.getNonBlocking(ev.target))) {
|
|
_this2.remCursor(nonblock);
|
|
_this2.nonBlockLastElem = null;
|
|
_this2.selectingText = false;
|
|
if (!_this2.isPropagating(nonblock)) {
|
|
ev.stopPropagation();
|
|
}
|
|
}
|
|
};
|
|
this.onmouseover = function (ev) {
|
|
var nonblock = void 0;
|
|
if (ev.isTrusted && (nonblock = _this2.getNonBlocking(ev.target)) && !_this2.isPropagating(nonblock)) {
|
|
ev.stopPropagation();
|
|
}
|
|
};
|
|
this.onmouseout = function (ev) {
|
|
var nonblock = void 0;
|
|
if (ev.isTrusted && (nonblock = _this2.getNonBlocking(ev.target)) && !_this2.isPropagating(nonblock)) {
|
|
ev.stopPropagation();
|
|
}
|
|
};
|
|
this.onmousemove = function (ev) {
|
|
var nonblock = void 0;
|
|
if (ev.isTrusted && (nonblock = _this2.getNonBlocking(ev.target))) {
|
|
_this2.nonblockPass(nonblock, ev, 'onmousemove');
|
|
// If the user just clicks somewhere, we don't want to select text, so this
|
|
// detects that the user moved their mouse.
|
|
if (_this2.selectingText === null) {
|
|
window.getSelection().removeAllRanges();
|
|
_this2.selectingText = true;
|
|
} else if (_this2.selectingText) {
|
|
// Stop the default action, which would be selecting text.
|
|
ev.preventDefault();
|
|
}
|
|
if (!_this2.isPropagating(nonblock)) {
|
|
ev.stopPropagation();
|
|
}
|
|
}
|
|
};
|
|
this.onmousedown = function (ev) {
|
|
var nonblock = void 0;
|
|
if (ev.isTrusted && (nonblock = _this2.getNonBlocking(ev.target))) {
|
|
_this2.nonblockPass(nonblock, ev, 'onmousedown');
|
|
_this2.selectingText = null;
|
|
if (!_this2.isFocusable(nonblock)) {
|
|
// Stop the default action, which would focus the element.
|
|
ev.preventDefault();
|
|
}
|
|
if (!_this2.isPropagating(nonblock) || !_this2.isActionPropagating(nonblock)) {
|
|
ev.stopPropagation();
|
|
}
|
|
}
|
|
};
|
|
this.onmouseup = function (ev) {
|
|
var nonblock = void 0;
|
|
if (ev.isTrusted && (nonblock = _this2.getNonBlocking(ev.target))) {
|
|
_this2.nonblockPass(nonblock, ev, 'onmouseup');
|
|
if (_this2.selectingText === null) {
|
|
window.getSelection().removeAllRanges();
|
|
}
|
|
_this2.selectingText = false;
|
|
if (!_this2.isPropagating(nonblock) || !_this2.isActionPropagating(nonblock)) {
|
|
ev.stopPropagation();
|
|
}
|
|
}
|
|
};
|
|
this.onclick = function (ev) {
|
|
var nonblock = void 0;
|
|
if (ev.isTrusted && (nonblock = _this2.getNonBlocking(ev.target))) {
|
|
_this2.nonblockPass(nonblock, ev, 'onclick');
|
|
if (!_this2.isPropagating(nonblock) || !_this2.isActionPropagating(nonblock)) {
|
|
ev.stopPropagation();
|
|
}
|
|
}
|
|
};
|
|
this.ondblclick = function (ev) {
|
|
var nonblock = void 0;
|
|
if (ev.isTrusted && (nonblock = _this2.getNonBlocking(ev.target))) {
|
|
_this2.nonblockPass(nonblock, ev, 'ondblclick');
|
|
if (!_this2.isPropagating(nonblock) || !_this2.isActionPropagating(nonblock)) {
|
|
ev.stopPropagation();
|
|
}
|
|
}
|
|
};
|
|
|
|
this.root.addEventListener('mouseenter', this.onmouseenter, true);
|
|
this.root.addEventListener('mouseleave', this.onmouseleave, true);
|
|
this.root.addEventListener('mouseover', this.onmouseover, true);
|
|
this.root.addEventListener('mouseout', this.onmouseout, true);
|
|
this.root.addEventListener('mousemove', this.onmousemove, true);
|
|
this.root.addEventListener('mousedown', this.onmousedown, true);
|
|
this.root.addEventListener('mouseup', this.onmouseup, true);
|
|
this.root.addEventListener('click', this.onclick, true);
|
|
this.root.addEventListener('dblclick', this.ondblclick, true);
|
|
}
|
|
}, {
|
|
key: 'destroy',
|
|
value: function destroy() {
|
|
var _arr = ['mouseenter', 'mouseleave', 'mouseover', 'mouseout', 'mousemove', 'mousedown', 'mouseup', 'click', 'dblclick'];
|
|
|
|
for (var _i = 0; _i < _arr.length; _i++) {
|
|
var event = _arr[_i];
|
|
if (this['on' + event]) {
|
|
this.root.removeEventListener(event, this['on' + event], true);
|
|
delete this['on' + event];
|
|
}
|
|
}
|
|
this.styling.parentNode.removeChild(this.styling);
|
|
delete this.styling;
|
|
}
|
|
}, {
|
|
key: 'addCSS',
|
|
value: function addCSS(css) {
|
|
this.styling = document.createElement('style');
|
|
this.styling.setAttribute('type', 'text/css');
|
|
if (this.styling.styleSheet) {
|
|
this.styling.styleSheet.cssText = css; // IE
|
|
} else {
|
|
this.styling.appendChild(document.createTextNode(css));
|
|
}
|
|
document.getElementsByTagName('head')[0].appendChild(this.styling);
|
|
}
|
|
}, {
|
|
key: 'domEvent',
|
|
value: function domEvent(elem, event, origEvent, bubbles) {
|
|
var eventObject = void 0;
|
|
event = event.toLowerCase();
|
|
if (this.useEventConstructors) {
|
|
// New browsers
|
|
event = event.replace(this.regexOn, '');
|
|
if (event.match(this.regexMouseEvents)) {
|
|
eventObject = new MouseEvent(event, {
|
|
screenX: origEvent.screenX,
|
|
screenY: origEvent.screenY,
|
|
clientX: origEvent.clientX,
|
|
clientY: origEvent.clientY,
|
|
ctrlKey: origEvent.ctrlKey,
|
|
shiftKey: origEvent.shiftKey,
|
|
altKey: origEvent.altKey,
|
|
metaKey: origEvent.metaKey,
|
|
button: origEvent.button,
|
|
buttons: origEvent.buttons,
|
|
relatedTarget: origEvent.relatedTarget,
|
|
region: origEvent.region,
|
|
|
|
detail: origEvent.detail,
|
|
view: origEvent.view,
|
|
|
|
bubbles: bubbles === undefined ? origEvent.bubbles : bubbles,
|
|
cancelable: origEvent.cancelable,
|
|
composed: origEvent.composed
|
|
});
|
|
} else if (event.match(this.regexUiEvents)) {
|
|
eventObject = new UIEvent(event, {
|
|
detail: origEvent.detail,
|
|
view: origEvent.view,
|
|
|
|
bubbles: bubbles === undefined ? origEvent.bubbles : bubbles,
|
|
cancelable: origEvent.cancelable,
|
|
composed: origEvent.composed
|
|
});
|
|
} else if (event.match(this.regexHtmlEvents)) {
|
|
eventObject = new Event(event, {
|
|
bubbles: bubbles === undefined ? origEvent.bubbles : bubbles,
|
|
cancelable: origEvent.cancelable,
|
|
composed: origEvent.composed
|
|
});
|
|
}
|
|
if (!eventObject) {
|
|
return;
|
|
}
|
|
elem.dispatchEvent(eventObject);
|
|
} else if (document.createEvent && elem.dispatchEvent) {
|
|
// Old method for FireFox, Opera, Safari, Chrome
|
|
event = event.replace(this.regexOn, '');
|
|
if (event.match(this.regexMouseEvents)) {
|
|
// This allows the click event to fire on the notice. There is
|
|
// probably a much better way to do it.
|
|
elem.getBoundingClientRect();
|
|
eventObject = document.createEvent("MouseEvents");
|
|
eventObject.initMouseEvent(event, bubbles === undefined ? origEvent.bubbles : bubbles, origEvent.cancelable, origEvent.view, origEvent.detail, origEvent.screenX, origEvent.screenY, origEvent.clientX, origEvent.clientY, origEvent.ctrlKey, origEvent.altKey, origEvent.shiftKey, origEvent.metaKey, origEvent.button, origEvent.relatedTarget);
|
|
} else if (event.match(this.regexUiEvents)) {
|
|
eventObject = document.createEvent("UIEvents");
|
|
eventObject.initUIEvent(event, bubbles === undefined ? origEvent.bubbles : bubbles, origEvent.cancelable, origEvent.view, origEvent.detail);
|
|
} else if (event.match(this.regexHtmlEvents)) {
|
|
eventObject = document.createEvent("HTMLEvents");
|
|
eventObject.initEvent(event, bubbles === undefined ? origEvent.bubbles : bubbles, origEvent.cancelable);
|
|
}
|
|
if (!eventObject) {
|
|
return;
|
|
}
|
|
elem.dispatchEvent(eventObject);
|
|
} else {
|
|
// Internet Explorer
|
|
if (!event.match(this.regexOn)) {
|
|
event = "on" + event;
|
|
};
|
|
eventObject = document.createEventObject(origEvent);
|
|
elem.fireEvent(event, eventObject);
|
|
}
|
|
}
|
|
}, {
|
|
key: 'nonblockPass',
|
|
value: function nonblockPass(elem, event, eventName) {
|
|
elem.classList.add('nonblock-hide');
|
|
var elBelow = document.elementFromPoint(event.clientX, event.clientY);
|
|
if (this.nonBlockLastElem === false) {
|
|
this.nonBlockLastElem = elBelow;
|
|
}
|
|
var range = void 0,
|
|
textNode = void 0,
|
|
whitespaceBefore = void 0,
|
|
text = void 0,
|
|
offset = void 0;
|
|
if (document.caretPositionFromPoint) {
|
|
range = document.caretPositionFromPoint(event.clientX, event.clientY);
|
|
textNode = range ? range.offsetNode : null;
|
|
offset = range ? range.offset : null;
|
|
} else if (document.caretRangeFromPoint) {
|
|
range = document.caretRangeFromPoint(event.clientX, event.clientY);
|
|
textNode = range ? range.endContainer : null;
|
|
offset = range ? range.endOffset : null;
|
|
}
|
|
if (range) {
|
|
whitespaceBefore = range.startContainer.textContent.match(/^[\s\n]*/)[0];
|
|
text = range.startContainer.textContent.replace(/[\s\n]+$/g, '');
|
|
}
|
|
|
|
elem.classList.remove('nonblock-hide');
|
|
var cursorStyle = this.getCursor(elBelow);
|
|
this.isOverTextNode = false;
|
|
if (cursorStyle === 'auto' && elBelow.tagName === 'A') {
|
|
cursorStyle = 'pointer';
|
|
} else if (range && (!whitespaceBefore.length || offset > whitespaceBefore.length) && offset < text.length) {
|
|
if (cursorStyle === 'auto') {
|
|
cursorStyle = 'text';
|
|
}
|
|
this.isOverTextNode = true;
|
|
}
|
|
|
|
if (range && this.selectingText && offset > 0) {
|
|
var selection = window.getSelection();
|
|
var selectionRange = void 0;
|
|
if (selection.rangeCount === 0) {
|
|
this.selectingText = {
|
|
originContainer: range.startContainer ? range.startContainer : textNode,
|
|
originOffset: offset - 1
|
|
};
|
|
selectionRange = document.createRange();
|
|
selection.addRange(selectionRange);
|
|
} else {
|
|
selectionRange = selection.getRangeAt(0);
|
|
}
|
|
|
|
if (textNode === this.selectingText.originContainer && offset < this.selectingText.originOffset || textNode.compareDocumentPosition(this.selectingText.originContainer) & Node.DOCUMENT_POSITION_FOLLOWING) {
|
|
selectionRange.setEnd(this.selectingText.originContainer, this.selectingText.originOffset);
|
|
selectionRange.setStart(textNode, offset);
|
|
} else {
|
|
selectionRange.setStart(this.selectingText.originContainer, this.selectingText.originOffset);
|
|
selectionRange.setEnd(textNode, offset);
|
|
}
|
|
}
|
|
|
|
this.setCursor(elem, cursorStyle !== 'auto' ? cursorStyle : 'default');
|
|
// If the element changed, call mouseenter, mouseleave, etc.
|
|
if (!this.nonBlockLastElem || this.nonBlockLastElem !== elBelow) {
|
|
if (this.nonBlockLastElem) {
|
|
var lastElem = this.nonBlockLastElem;
|
|
if (!lastElem.contains(elBelow)) {
|
|
this.domEvent(lastElem, 'mouseleave', event, false);
|
|
}
|
|
this.domEvent(lastElem, 'mouseout', event, true);
|
|
if (!elBelow.contains(lastElem)) {
|
|
this.domEvent(elBelow, 'mouseenter', event, false);
|
|
}
|
|
} else if (!elBelow.contains(elem)) {
|
|
this.domEvent(elBelow, 'mouseenter', event, false);
|
|
}
|
|
this.domEvent(elBelow, 'mouseover', event, true);
|
|
}
|
|
|
|
// If the event is mousedown, then we need to focus the element.
|
|
if (eventName === 'onmousedown') {
|
|
document.activeElement && document.activeElement.blur();
|
|
elBelow.focus({ preventScroll: true });
|
|
}
|
|
|
|
// Forward the event.
|
|
this.domEvent(elBelow, eventName, event);
|
|
// Remember the latest element the mouse was over.
|
|
this.nonBlockLastElem = elBelow;
|
|
}
|
|
}, {
|
|
key: 'getNonBlocking',
|
|
value: function getNonBlocking(el) {
|
|
var nonblock = el;
|
|
while (nonblock) {
|
|
if (nonblock.classList && nonblock.classList.contains('nonblock')) {
|
|
return nonblock;
|
|
}
|
|
nonblock = nonblock.parentNode;
|
|
}
|
|
return false;
|
|
}
|
|
}, {
|
|
key: 'isPropagating',
|
|
value: function isPropagating(el) {
|
|
return !el.classList.contains('nonblock-stop-propagation');
|
|
}
|
|
}, {
|
|
key: 'isActionPropagating',
|
|
value: function isActionPropagating(el) {
|
|
return el.classList.contains('nonblock-allow-action-propagation');
|
|
}
|
|
}, {
|
|
key: 'isFocusable',
|
|
value: function isFocusable(el) {
|
|
return el.classList.contains('nonblock-allow-focus');
|
|
}
|
|
}, {
|
|
key: 'isSimulateMouse',
|
|
value: function isSimulateMouse(el) {
|
|
return !el.classList.contains('nonblock-stop-mouse-simulation');
|
|
}
|
|
}, {
|
|
key: 'getCursor',
|
|
value: function getCursor(el) {
|
|
var style = window.getComputedStyle(el);
|
|
return style.getPropertyValue('cursor');
|
|
}
|
|
}, {
|
|
key: 'setCursor',
|
|
value: function setCursor(el, value) {
|
|
if (el.classList.contains('nonblock-cursor-' + value)) {
|
|
return;
|
|
}
|
|
this.remCursor(el);
|
|
el.classList.add('nonblock-cursor-' + value);
|
|
}
|
|
}, {
|
|
key: 'remCursor',
|
|
value: function remCursor(el) {
|
|
var values = Object.keys(el.classList).map(function (e) {
|
|
return el.classList[e];
|
|
});
|
|
[].concat(_toConsumableArray(values)).forEach(function (className) {
|
|
if (className.indexOf('nonblock-cursor-') === 0) {
|
|
el.classList.remove(className);
|
|
}
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return NonBlock;
|
|
}();
|
|
|
|
return NonBlock;
|
|
}());
|
|
})();
|