2026 lines
62 KiB
JavaScript
2026 lines
62 KiB
JavaScript
|
import React from 'react';
|
||
|
|
|
||
|
|
function _arrayWithHoles(arr) {
|
||
|
|
if (Array.isArray(arr)) return arr;
|
||
|
|
}
|
||
|
|
|
||
|
|
function _iterableToArrayLimit(arr, i) {
|
||
|
|
var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
|
||
|
|
|
||
|
|
if (_i == null) return;
|
||
|
|
var _arr = [];
|
||
|
|
var _n = true;
|
||
|
|
var _d = false;
|
||
|
|
|
||
|
|
var _s, _e;
|
||
|
|
|
||
|
|
try {
|
||
|
|
for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
|
||
|
|
_arr.push(_s.value);
|
||
|
|
|
||
|
|
if (i && _arr.length === i) break;
|
||
|
|
}
|
||
|
|
} catch (err) {
|
||
|
|
_d = true;
|
||
|
|
_e = err;
|
||
|
|
} finally {
|
||
|
|
try {
|
||
|
|
if (!_n && _i["return"] != null) _i["return"]();
|
||
|
|
} finally {
|
||
|
|
if (_d) throw _e;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return _arr;
|
||
|
|
}
|
||
|
|
|
||
|
|
function _arrayLikeToArray$1(arr, len) {
|
||
|
|
if (len == null || len > arr.length) len = arr.length;
|
||
|
|
|
||
|
|
for (var i = 0, arr2 = new Array(len); i < len; i++) {
|
||
|
|
arr2[i] = arr[i];
|
||
|
|
}
|
||
|
|
|
||
|
|
return arr2;
|
||
|
|
}
|
||
|
|
|
||
|
|
function _unsupportedIterableToArray$1(o, minLen) {
|
||
|
|
if (!o) return;
|
||
|
|
if (typeof o === "string") return _arrayLikeToArray$1(o, minLen);
|
||
|
|
var n = Object.prototype.toString.call(o).slice(8, -1);
|
||
|
|
if (n === "Object" && o.constructor) n = o.constructor.name;
|
||
|
|
if (n === "Map" || n === "Set") return Array.from(o);
|
||
|
|
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen);
|
||
|
|
}
|
||
|
|
|
||
|
|
function _nonIterableRest() {
|
||
|
|
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
||
|
|
}
|
||
|
|
|
||
|
|
function _slicedToArray(arr, i) {
|
||
|
|
return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray$1(arr, i) || _nonIterableRest();
|
||
|
|
}
|
||
|
|
|
||
|
|
function _typeof(obj) {
|
||
|
|
"@babel/helpers - typeof";
|
||
|
|
|
||
|
|
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
|
||
|
|
return typeof obj;
|
||
|
|
} : function (obj) {
|
||
|
|
return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
|
||
|
|
}, _typeof(obj);
|
||
|
|
}
|
||
|
|
|
||
|
|
function classNames() {
|
||
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
||
|
|
args[_key] = arguments[_key];
|
||
|
|
}
|
||
|
|
|
||
|
|
if (args) {
|
||
|
|
var classes = [];
|
||
|
|
|
||
|
|
for (var i = 0; i < args.length; i++) {
|
||
|
|
var className = args[i];
|
||
|
|
if (!className) continue;
|
||
|
|
|
||
|
|
var type = _typeof(className);
|
||
|
|
|
||
|
|
if (type === 'string' || type === 'number') {
|
||
|
|
classes.push(className);
|
||
|
|
} else if (type === 'object') {
|
||
|
|
var _classes = Array.isArray(className) ? className : Object.entries(className).map(function (_ref) {
|
||
|
|
var _ref2 = _slicedToArray(_ref, 2),
|
||
|
|
key = _ref2[0],
|
||
|
|
value = _ref2[1];
|
||
|
|
|
||
|
|
return !!value ? key : null;
|
||
|
|
});
|
||
|
|
|
||
|
|
classes = _classes.length ? classes.concat(_classes.filter(function (c) {
|
||
|
|
return !!c;
|
||
|
|
})) : classes;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return classes.join(' ');
|
||
|
|
}
|
||
|
|
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
function _classCallCheck(instance, Constructor) {
|
||
|
|
if (!(instance instanceof Constructor)) {
|
||
|
|
throw new TypeError("Cannot call a class as a 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);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function _createClass(Constructor, protoProps, staticProps) {
|
||
|
|
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
|
||
|
|
if (staticProps) _defineProperties(Constructor, staticProps);
|
||
|
|
Object.defineProperty(Constructor, "prototype", {
|
||
|
|
writable: false
|
||
|
|
});
|
||
|
|
return Constructor;
|
||
|
|
}
|
||
|
|
|
||
|
|
function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
|
||
|
|
|
||
|
|
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
|
||
|
|
|
||
|
|
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
|
||
|
|
|
||
|
|
var DomHandler = /*#__PURE__*/function () {
|
||
|
|
function DomHandler() {
|
||
|
|
_classCallCheck(this, DomHandler);
|
||
|
|
}
|
||
|
|
|
||
|
|
_createClass(DomHandler, null, [{
|
||
|
|
key: "innerWidth",
|
||
|
|
value: function innerWidth(el) {
|
||
|
|
if (el) {
|
||
|
|
var width = el.offsetWidth;
|
||
|
|
var style = getComputedStyle(el);
|
||
|
|
width += parseFloat(style.paddingLeft) + parseFloat(style.paddingRight);
|
||
|
|
return width;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "width",
|
||
|
|
value: function width(el) {
|
||
|
|
if (el) {
|
||
|
|
var width = el.offsetWidth;
|
||
|
|
var style = getComputedStyle(el);
|
||
|
|
width -= parseFloat(style.paddingLeft) + parseFloat(style.paddingRight);
|
||
|
|
return width;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getWindowScrollTop",
|
||
|
|
value: function getWindowScrollTop() {
|
||
|
|
var doc = document.documentElement;
|
||
|
|
return (window.pageYOffset || doc.scrollTop) - (doc.clientTop || 0);
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getWindowScrollLeft",
|
||
|
|
value: function getWindowScrollLeft() {
|
||
|
|
var doc = document.documentElement;
|
||
|
|
return (window.pageXOffset || doc.scrollLeft) - (doc.clientLeft || 0);
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getOuterWidth",
|
||
|
|
value: function getOuterWidth(el, margin) {
|
||
|
|
if (el) {
|
||
|
|
var width = el.offsetWidth || el.getBoundingClientRect().width;
|
||
|
|
|
||
|
|
if (margin) {
|
||
|
|
var style = getComputedStyle(el);
|
||
|
|
width += parseFloat(style.marginLeft) + parseFloat(style.marginRight);
|
||
|
|
}
|
||
|
|
|
||
|
|
return width;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getOuterHeight",
|
||
|
|
value: function getOuterHeight(el, margin) {
|
||
|
|
if (el) {
|
||
|
|
var height = el.offsetHeight || el.getBoundingClientRect().height;
|
||
|
|
|
||
|
|
if (margin) {
|
||
|
|
var style = getComputedStyle(el);
|
||
|
|
height += parseFloat(style.marginTop) + parseFloat(style.marginBottom);
|
||
|
|
}
|
||
|
|
|
||
|
|
return height;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getClientHeight",
|
||
|
|
value: function getClientHeight(el, margin) {
|
||
|
|
if (el) {
|
||
|
|
var height = el.clientHeight;
|
||
|
|
|
||
|
|
if (margin) {
|
||
|
|
var style = getComputedStyle(el);
|
||
|
|
height += parseFloat(style.marginTop) + parseFloat(style.marginBottom);
|
||
|
|
}
|
||
|
|
|
||
|
|
return height;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getClientWidth",
|
||
|
|
value: function getClientWidth(el, margin) {
|
||
|
|
if (el) {
|
||
|
|
var width = el.clientWidth;
|
||
|
|
|
||
|
|
if (margin) {
|
||
|
|
var style = getComputedStyle(el);
|
||
|
|
width += parseFloat(style.marginLeft) + parseFloat(style.marginRight);
|
||
|
|
}
|
||
|
|
|
||
|
|
return width;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getViewport",
|
||
|
|
value: function getViewport() {
|
||
|
|
var win = window,
|
||
|
|
d = document,
|
||
|
|
e = d.documentElement,
|
||
|
|
g = d.getElementsByTagName('body')[0],
|
||
|
|
w = win.innerWidth || e.clientWidth || g.clientWidth,
|
||
|
|
h = win.innerHeight || e.clientHeight || g.clientHeight;
|
||
|
|
return {
|
||
|
|
width: w,
|
||
|
|
height: h
|
||
|
|
};
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getOffset",
|
||
|
|
value: function getOffset(el) {
|
||
|
|
if (el) {
|
||
|
|
var rect = el.getBoundingClientRect();
|
||
|
|
return {
|
||
|
|
top: rect.top + (window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0),
|
||
|
|
left: rect.left + (window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft || 0)
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
return {
|
||
|
|
top: 'auto',
|
||
|
|
left: 'auto'
|
||
|
|
};
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "index",
|
||
|
|
value: function index(element) {
|
||
|
|
if (element) {
|
||
|
|
var children = element.parentNode.childNodes;
|
||
|
|
var num = 0;
|
||
|
|
|
||
|
|
for (var i = 0; i < children.length; i++) {
|
||
|
|
if (children[i] === element) return num;
|
||
|
|
if (children[i].nodeType === 1) num++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "addMultipleClasses",
|
||
|
|
value: function addMultipleClasses(element, className) {
|
||
|
|
if (element && className) {
|
||
|
|
if (element.classList) {
|
||
|
|
var styles = className.split(' ');
|
||
|
|
|
||
|
|
for (var i = 0; i < styles.length; i++) {
|
||
|
|
element.classList.add(styles[i]);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
var _styles = className.split(' ');
|
||
|
|
|
||
|
|
for (var _i = 0; _i < _styles.length; _i++) {
|
||
|
|
element.className += ' ' + _styles[_i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "removeMultipleClasses",
|
||
|
|
value: function removeMultipleClasses(element, className) {
|
||
|
|
if (element && className) {
|
||
|
|
if (element.classList) {
|
||
|
|
var styles = className.split(' ');
|
||
|
|
|
||
|
|
for (var i = 0; i < styles.length; i++) {
|
||
|
|
element.classList.remove(styles[i]);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
var _styles2 = className.split(' ');
|
||
|
|
|
||
|
|
for (var _i2 = 0; _i2 < _styles2.length; _i2++) {
|
||
|
|
element.className = element.className.replace(new RegExp('(^|\\b)' + _styles2[_i2].split(' ').join('|') + '(\\b|$)', 'gi'), ' ');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "addClass",
|
||
|
|
value: function addClass(element, className) {
|
||
|
|
if (element && className) {
|
||
|
|
if (element.classList) element.classList.add(className);else element.className += ' ' + className;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "removeClass",
|
||
|
|
value: function removeClass(element, className) {
|
||
|
|
if (element && className) {
|
||
|
|
if (element.classList) element.classList.remove(className);else element.className = element.className.replace(new RegExp('(^|\\b)' + className.split(' ').join('|') + '(\\b|$)', 'gi'), ' ');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "hasClass",
|
||
|
|
value: function hasClass(element, className) {
|
||
|
|
if (element) {
|
||
|
|
if (element.classList) return element.classList.contains(className);else return new RegExp('(^| )' + className + '( |$)', 'gi').test(element.className);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "find",
|
||
|
|
value: function find(element, selector) {
|
||
|
|
return element ? Array.from(element.querySelectorAll(selector)) : [];
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "findSingle",
|
||
|
|
value: function findSingle(element, selector) {
|
||
|
|
if (element) {
|
||
|
|
return element.querySelector(selector);
|
||
|
|
}
|
||
|
|
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getHeight",
|
||
|
|
value: function getHeight(el) {
|
||
|
|
if (el) {
|
||
|
|
var height = el.offsetHeight;
|
||
|
|
var style = getComputedStyle(el);
|
||
|
|
height -= parseFloat(style.paddingTop) + parseFloat(style.paddingBottom) + parseFloat(style.borderTopWidth) + parseFloat(style.borderBottomWidth);
|
||
|
|
return height;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getWidth",
|
||
|
|
value: function getWidth(el) {
|
||
|
|
if (el) {
|
||
|
|
var width = el.offsetWidth;
|
||
|
|
var style = getComputedStyle(el);
|
||
|
|
width -= parseFloat(style.paddingLeft) + parseFloat(style.paddingRight) + parseFloat(style.borderLeftWidth) + parseFloat(style.borderRightWidth);
|
||
|
|
return width;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "alignOverlay",
|
||
|
|
value: function alignOverlay(overlay, target, appendTo) {
|
||
|
|
var calculateMinWidth = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
|
||
|
|
|
||
|
|
if (overlay && target) {
|
||
|
|
if (appendTo === 'self') {
|
||
|
|
this.relativePosition(overlay, target);
|
||
|
|
} else {
|
||
|
|
calculateMinWidth && (overlay.style.minWidth = DomHandler.getOuterWidth(target) + 'px');
|
||
|
|
this.absolutePosition(overlay, target);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "absolutePosition",
|
||
|
|
value: function absolutePosition(element, target) {
|
||
|
|
if (element) {
|
||
|
|
var elementDimensions = element.offsetParent ? {
|
||
|
|
width: element.offsetWidth,
|
||
|
|
height: element.offsetHeight
|
||
|
|
} : this.getHiddenElementDimensions(element);
|
||
|
|
var elementOuterHeight = elementDimensions.height;
|
||
|
|
var elementOuterWidth = elementDimensions.width;
|
||
|
|
var targetOuterHeight = target.offsetHeight;
|
||
|
|
var targetOuterWidth = target.offsetWidth;
|
||
|
|
var targetOffset = target.getBoundingClientRect();
|
||
|
|
var windowScrollTop = this.getWindowScrollTop();
|
||
|
|
var windowScrollLeft = this.getWindowScrollLeft();
|
||
|
|
var viewport = this.getViewport();
|
||
|
|
var top, left;
|
||
|
|
|
||
|
|
if (targetOffset.top + targetOuterHeight + elementOuterHeight > viewport.height) {
|
||
|
|
top = targetOffset.top + windowScrollTop - elementOuterHeight;
|
||
|
|
|
||
|
|
if (top < 0) {
|
||
|
|
top = windowScrollTop;
|
||
|
|
}
|
||
|
|
|
||
|
|
element.style.transformOrigin = 'bottom';
|
||
|
|
} else {
|
||
|
|
top = targetOuterHeight + targetOffset.top + windowScrollTop;
|
||
|
|
element.style.transformOrigin = 'top';
|
||
|
|
}
|
||
|
|
|
||
|
|
if (targetOffset.left + targetOuterWidth + elementOuterWidth > viewport.width) left = Math.max(0, targetOffset.left + windowScrollLeft + targetOuterWidth - elementOuterWidth);else left = targetOffset.left + windowScrollLeft;
|
||
|
|
element.style.top = top + 'px';
|
||
|
|
element.style.left = left + 'px';
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "relativePosition",
|
||
|
|
value: function relativePosition(element, target) {
|
||
|
|
if (element) {
|
||
|
|
var elementDimensions = element.offsetParent ? {
|
||
|
|
width: element.offsetWidth,
|
||
|
|
height: element.offsetHeight
|
||
|
|
} : this.getHiddenElementDimensions(element);
|
||
|
|
var targetHeight = target.offsetHeight;
|
||
|
|
var targetOffset = target.getBoundingClientRect();
|
||
|
|
var viewport = this.getViewport();
|
||
|
|
var top, left;
|
||
|
|
|
||
|
|
if (targetOffset.top + targetHeight + elementDimensions.height > viewport.height) {
|
||
|
|
top = -1 * elementDimensions.height;
|
||
|
|
|
||
|
|
if (targetOffset.top + top < 0) {
|
||
|
|
top = -1 * targetOffset.top;
|
||
|
|
}
|
||
|
|
|
||
|
|
element.style.transformOrigin = 'bottom';
|
||
|
|
} else {
|
||
|
|
top = targetHeight;
|
||
|
|
element.style.transformOrigin = 'top';
|
||
|
|
}
|
||
|
|
|
||
|
|
if (elementDimensions.width > viewport.width) {
|
||
|
|
// element wider then viewport and cannot fit on screen (align at left side of viewport)
|
||
|
|
left = targetOffset.left * -1;
|
||
|
|
} else if (targetOffset.left + elementDimensions.width > viewport.width) {
|
||
|
|
// element wider then viewport but can be fit on screen (align at right side of viewport)
|
||
|
|
left = (targetOffset.left + elementDimensions.width - viewport.width) * -1;
|
||
|
|
} else {
|
||
|
|
// element fits on screen (align with target)
|
||
|
|
left = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
element.style.top = top + 'px';
|
||
|
|
element.style.left = left + 'px';
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "flipfitCollision",
|
||
|
|
value: function flipfitCollision(element, target) {
|
||
|
|
var _this = this;
|
||
|
|
|
||
|
|
var my = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'left top';
|
||
|
|
var at = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'left bottom';
|
||
|
|
var callback = arguments.length > 4 ? arguments[4] : undefined;
|
||
|
|
var targetOffset = target.getBoundingClientRect();
|
||
|
|
var viewport = this.getViewport();
|
||
|
|
var myArr = my.split(' ');
|
||
|
|
var atArr = at.split(' ');
|
||
|
|
|
||
|
|
var getPositionValue = function getPositionValue(arr, isOffset) {
|
||
|
|
return isOffset ? +arr.substring(arr.search(/(\+|-)/g)) || 0 : arr.substring(0, arr.search(/(\+|-)/g)) || arr;
|
||
|
|
};
|
||
|
|
|
||
|
|
var position = {
|
||
|
|
my: {
|
||
|
|
x: getPositionValue(myArr[0]),
|
||
|
|
y: getPositionValue(myArr[1] || myArr[0]),
|
||
|
|
offsetX: getPositionValue(myArr[0], true),
|
||
|
|
offsetY: getPositionValue(myArr[1] || myArr[0], true)
|
||
|
|
},
|
||
|
|
at: {
|
||
|
|
x: getPositionValue(atArr[0]),
|
||
|
|
y: getPositionValue(atArr[1] || atArr[0]),
|
||
|
|
offsetX: getPositionValue(atArr[0], true),
|
||
|
|
offsetY: getPositionValue(atArr[1] || atArr[0], true)
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var myOffset = {
|
||
|
|
left: function left() {
|
||
|
|
var totalOffset = position.my.offsetX + position.at.offsetX;
|
||
|
|
return totalOffset + targetOffset.left + (position.my.x === 'left' ? 0 : -1 * (position.my.x === 'center' ? _this.getOuterWidth(element) / 2 : _this.getOuterWidth(element)));
|
||
|
|
},
|
||
|
|
top: function top() {
|
||
|
|
var totalOffset = position.my.offsetY + position.at.offsetY;
|
||
|
|
return totalOffset + targetOffset.top + (position.my.y === 'top' ? 0 : -1 * (position.my.y === 'center' ? _this.getOuterHeight(element) / 2 : _this.getOuterHeight(element)));
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var alignWithAt = {
|
||
|
|
count: {
|
||
|
|
x: 0,
|
||
|
|
y: 0
|
||
|
|
},
|
||
|
|
left: function left() {
|
||
|
|
var left = myOffset.left();
|
||
|
|
var scrollLeft = DomHandler.getWindowScrollLeft();
|
||
|
|
element.style.left = left + scrollLeft + 'px';
|
||
|
|
|
||
|
|
if (this.count.x === 2) {
|
||
|
|
element.style.left = scrollLeft + 'px';
|
||
|
|
this.count.x = 0;
|
||
|
|
} else if (left < 0) {
|
||
|
|
this.count.x++;
|
||
|
|
position.my.x = 'left';
|
||
|
|
position.at.x = 'right';
|
||
|
|
position.my.offsetX *= -1;
|
||
|
|
position.at.offsetX *= -1;
|
||
|
|
this.right();
|
||
|
|
}
|
||
|
|
},
|
||
|
|
right: function right() {
|
||
|
|
var left = myOffset.left() + DomHandler.getOuterWidth(target);
|
||
|
|
var scrollLeft = DomHandler.getWindowScrollLeft();
|
||
|
|
element.style.left = left + scrollLeft + 'px';
|
||
|
|
|
||
|
|
if (this.count.x === 2) {
|
||
|
|
element.style.left = viewport.width - DomHandler.getOuterWidth(element) + scrollLeft + 'px';
|
||
|
|
this.count.x = 0;
|
||
|
|
} else if (left + DomHandler.getOuterWidth(element) > viewport.width) {
|
||
|
|
this.count.x++;
|
||
|
|
position.my.x = 'right';
|
||
|
|
position.at.x = 'left';
|
||
|
|
position.my.offsetX *= -1;
|
||
|
|
position.at.offsetX *= -1;
|
||
|
|
this.left();
|
||
|
|
}
|
||
|
|
},
|
||
|
|
top: function top() {
|
||
|
|
var top = myOffset.top();
|
||
|
|
var scrollTop = DomHandler.getWindowScrollTop();
|
||
|
|
element.style.top = top + scrollTop + 'px';
|
||
|
|
|
||
|
|
if (this.count.y === 2) {
|
||
|
|
element.style.left = scrollTop + 'px';
|
||
|
|
this.count.y = 0;
|
||
|
|
} else if (top < 0) {
|
||
|
|
this.count.y++;
|
||
|
|
position.my.y = 'top';
|
||
|
|
position.at.y = 'bottom';
|
||
|
|
position.my.offsetY *= -1;
|
||
|
|
position.at.offsetY *= -1;
|
||
|
|
this.bottom();
|
||
|
|
}
|
||
|
|
},
|
||
|
|
bottom: function bottom() {
|
||
|
|
var top = myOffset.top() + DomHandler.getOuterHeight(target);
|
||
|
|
var scrollTop = DomHandler.getWindowScrollTop();
|
||
|
|
element.style.top = top + scrollTop + 'px';
|
||
|
|
|
||
|
|
if (this.count.y === 2) {
|
||
|
|
element.style.left = viewport.height - DomHandler.getOuterHeight(element) + scrollTop + 'px';
|
||
|
|
this.count.y = 0;
|
||
|
|
} else if (top + DomHandler.getOuterHeight(target) > viewport.height) {
|
||
|
|
this.count.y++;
|
||
|
|
position.my.y = 'bottom';
|
||
|
|
position.at.y = 'top';
|
||
|
|
position.my.offsetY *= -1;
|
||
|
|
position.at.offsetY *= -1;
|
||
|
|
this.top();
|
||
|
|
}
|
||
|
|
},
|
||
|
|
center: function center(axis) {
|
||
|
|
if (axis === 'y') {
|
||
|
|
var top = myOffset.top() + DomHandler.getOuterHeight(target) / 2;
|
||
|
|
element.style.top = top + DomHandler.getWindowScrollTop() + 'px';
|
||
|
|
|
||
|
|
if (top < 0) {
|
||
|
|
this.bottom();
|
||
|
|
} else if (top + DomHandler.getOuterHeight(target) > viewport.height) {
|
||
|
|
this.top();
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
var left = myOffset.left() + DomHandler.getOuterWidth(target) / 2;
|
||
|
|
element.style.left = left + DomHandler.getWindowScrollLeft() + 'px';
|
||
|
|
|
||
|
|
if (left < 0) {
|
||
|
|
this.left();
|
||
|
|
} else if (left + DomHandler.getOuterWidth(element) > viewport.width) {
|
||
|
|
this.right();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
alignWithAt[position.at.x]('x');
|
||
|
|
alignWithAt[position.at.y]('y');
|
||
|
|
|
||
|
|
if (this.isFunction(callback)) {
|
||
|
|
callback(position);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "findCollisionPosition",
|
||
|
|
value: function findCollisionPosition(position) {
|
||
|
|
if (position) {
|
||
|
|
var isAxisY = position === 'top' || position === 'bottom';
|
||
|
|
var myXPosition = position === 'left' ? 'right' : 'left';
|
||
|
|
var myYPosition = position === 'top' ? 'bottom' : 'top';
|
||
|
|
|
||
|
|
if (isAxisY) {
|
||
|
|
return {
|
||
|
|
axis: 'y',
|
||
|
|
my: "center ".concat(myYPosition),
|
||
|
|
at: "center ".concat(position)
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
return {
|
||
|
|
axis: 'x',
|
||
|
|
my: "".concat(myXPosition, " center"),
|
||
|
|
at: "".concat(position, " center")
|
||
|
|
};
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getParents",
|
||
|
|
value: function getParents(element) {
|
||
|
|
var parents = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
|
||
|
|
return element['parentNode'] === null ? parents : this.getParents(element.parentNode, parents.concat([element.parentNode]));
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getScrollableParents",
|
||
|
|
value: function getScrollableParents(element) {
|
||
|
|
var scrollableParents = [];
|
||
|
|
|
||
|
|
if (element) {
|
||
|
|
var parents = this.getParents(element);
|
||
|
|
var overflowRegex = /(auto|scroll)/;
|
||
|
|
|
||
|
|
var overflowCheck = function overflowCheck(node) {
|
||
|
|
var styleDeclaration = node ? getComputedStyle(node) : null;
|
||
|
|
return styleDeclaration && (overflowRegex.test(styleDeclaration.getPropertyValue('overflow')) || overflowRegex.test(styleDeclaration.getPropertyValue('overflowX')) || overflowRegex.test(styleDeclaration.getPropertyValue('overflowY')));
|
||
|
|
};
|
||
|
|
|
||
|
|
var _iterator = _createForOfIteratorHelper(parents),
|
||
|
|
_step;
|
||
|
|
|
||
|
|
try {
|
||
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
||
|
|
var parent = _step.value;
|
||
|
|
var scrollSelectors = parent.nodeType === 1 && parent.dataset['scrollselectors'];
|
||
|
|
|
||
|
|
if (scrollSelectors) {
|
||
|
|
var selectors = scrollSelectors.split(',');
|
||
|
|
|
||
|
|
var _iterator2 = _createForOfIteratorHelper(selectors),
|
||
|
|
_step2;
|
||
|
|
|
||
|
|
try {
|
||
|
|
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
|
||
|
|
var selector = _step2.value;
|
||
|
|
var el = this.findSingle(parent, selector);
|
||
|
|
|
||
|
|
if (el && overflowCheck(el)) {
|
||
|
|
scrollableParents.push(el);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} catch (err) {
|
||
|
|
_iterator2.e(err);
|
||
|
|
} finally {
|
||
|
|
_iterator2.f();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (parent.nodeType !== 9 && overflowCheck(parent)) {
|
||
|
|
scrollableParents.push(parent);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} catch (err) {
|
||
|
|
_iterator.e(err);
|
||
|
|
} finally {
|
||
|
|
_iterator.f();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return scrollableParents;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getHiddenElementOuterHeight",
|
||
|
|
value: function getHiddenElementOuterHeight(element) {
|
||
|
|
if (element) {
|
||
|
|
element.style.visibility = 'hidden';
|
||
|
|
element.style.display = 'block';
|
||
|
|
var elementHeight = element.offsetHeight;
|
||
|
|
element.style.display = 'none';
|
||
|
|
element.style.visibility = 'visible';
|
||
|
|
return elementHeight;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getHiddenElementOuterWidth",
|
||
|
|
value: function getHiddenElementOuterWidth(element) {
|
||
|
|
if (element) {
|
||
|
|
element.style.visibility = 'hidden';
|
||
|
|
element.style.display = 'block';
|
||
|
|
var elementWidth = element.offsetWidth;
|
||
|
|
element.style.display = 'none';
|
||
|
|
element.style.visibility = 'visible';
|
||
|
|
return elementWidth;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getHiddenElementDimensions",
|
||
|
|
value: function getHiddenElementDimensions(element) {
|
||
|
|
var dimensions = {};
|
||
|
|
|
||
|
|
if (element) {
|
||
|
|
element.style.visibility = 'hidden';
|
||
|
|
element.style.display = 'block';
|
||
|
|
dimensions.width = element.offsetWidth;
|
||
|
|
dimensions.height = element.offsetHeight;
|
||
|
|
element.style.display = 'none';
|
||
|
|
element.style.visibility = 'visible';
|
||
|
|
}
|
||
|
|
|
||
|
|
return dimensions;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "fadeIn",
|
||
|
|
value: function fadeIn(element, duration) {
|
||
|
|
if (element) {
|
||
|
|
element.style.opacity = 0;
|
||
|
|
var last = +new Date();
|
||
|
|
var opacity = 0;
|
||
|
|
|
||
|
|
var tick = function tick() {
|
||
|
|
opacity = +element.style.opacity + (new Date().getTime() - last) / duration;
|
||
|
|
element.style.opacity = opacity;
|
||
|
|
last = +new Date();
|
||
|
|
|
||
|
|
if (+opacity < 1) {
|
||
|
|
window.requestAnimationFrame && requestAnimationFrame(tick) || setTimeout(tick, 16);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
tick();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "fadeOut",
|
||
|
|
value: function fadeOut(element, duration) {
|
||
|
|
if (element) {
|
||
|
|
var opacity = 1,
|
||
|
|
interval = 50,
|
||
|
|
gap = interval / duration;
|
||
|
|
var fading = setInterval(function () {
|
||
|
|
opacity -= gap;
|
||
|
|
|
||
|
|
if (opacity <= 0) {
|
||
|
|
opacity = 0;
|
||
|
|
clearInterval(fading);
|
||
|
|
}
|
||
|
|
|
||
|
|
element.style.opacity = opacity;
|
||
|
|
}, interval);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getUserAgent",
|
||
|
|
value: function getUserAgent() {
|
||
|
|
return navigator.userAgent;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "isIOS",
|
||
|
|
value: function isIOS() {
|
||
|
|
return /iPad|iPhone|iPod/.test(navigator.userAgent) && !window['MSStream'];
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "isAndroid",
|
||
|
|
value: function isAndroid() {
|
||
|
|
return /(android)/i.test(navigator.userAgent);
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "isTouchDevice",
|
||
|
|
value: function isTouchDevice() {
|
||
|
|
return 'ontouchstart' in window || navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "isFunction",
|
||
|
|
value: function isFunction(obj) {
|
||
|
|
return !!(obj && obj.constructor && obj.call && obj.apply);
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "appendChild",
|
||
|
|
value: function appendChild(element, target) {
|
||
|
|
if (this.isElement(target)) target.appendChild(element);else if (target.el && target.el.nativeElement) target.el.nativeElement.appendChild(element);else throw new Error('Cannot append ' + target + ' to ' + element);
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "removeChild",
|
||
|
|
value: function removeChild(element, target) {
|
||
|
|
if (this.isElement(target)) target.removeChild(element);else if (target.el && target.el.nativeElement) target.el.nativeElement.removeChild(element);else throw new Error('Cannot remove ' + element + ' from ' + target);
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "isElement",
|
||
|
|
value: function isElement(obj) {
|
||
|
|
return (typeof HTMLElement === "undefined" ? "undefined" : _typeof(HTMLElement)) === "object" ? obj instanceof HTMLElement : obj && _typeof(obj) === "object" && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === "string";
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "scrollInView",
|
||
|
|
value: function scrollInView(container, item) {
|
||
|
|
var borderTopValue = getComputedStyle(container).getPropertyValue('borderTopWidth');
|
||
|
|
var borderTop = borderTopValue ? parseFloat(borderTopValue) : 0;
|
||
|
|
var paddingTopValue = getComputedStyle(container).getPropertyValue('paddingTop');
|
||
|
|
var paddingTop = paddingTopValue ? parseFloat(paddingTopValue) : 0;
|
||
|
|
var containerRect = container.getBoundingClientRect();
|
||
|
|
var itemRect = item.getBoundingClientRect();
|
||
|
|
var offset = itemRect.top + document.body.scrollTop - (containerRect.top + document.body.scrollTop) - borderTop - paddingTop;
|
||
|
|
var scroll = container.scrollTop;
|
||
|
|
var elementHeight = container.clientHeight;
|
||
|
|
var itemHeight = this.getOuterHeight(item);
|
||
|
|
|
||
|
|
if (offset < 0) {
|
||
|
|
container.scrollTop = scroll + offset;
|
||
|
|
} else if (offset + itemHeight > elementHeight) {
|
||
|
|
container.scrollTop = scroll + offset - elementHeight + itemHeight;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "clearSelection",
|
||
|
|
value: function clearSelection() {
|
||
|
|
if (window.getSelection) {
|
||
|
|
if (window.getSelection().empty) {
|
||
|
|
window.getSelection().empty();
|
||
|
|
} else if (window.getSelection().removeAllRanges && window.getSelection().rangeCount > 0 && window.getSelection().getRangeAt(0).getClientRects().length > 0) {
|
||
|
|
window.getSelection().removeAllRanges();
|
||
|
|
}
|
||
|
|
} else if (document['selection'] && document['selection'].empty) {
|
||
|
|
try {
|
||
|
|
document['selection'].empty();
|
||
|
|
} catch (error) {//ignore IE bug
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "calculateScrollbarWidth",
|
||
|
|
value: function calculateScrollbarWidth(el) {
|
||
|
|
if (el) {
|
||
|
|
var style = getComputedStyle(el);
|
||
|
|
return el.offsetWidth - el.clientWidth - parseFloat(style.borderLeftWidth) - parseFloat(style.borderRightWidth);
|
||
|
|
} else {
|
||
|
|
if (this.calculatedScrollbarWidth != null) return this.calculatedScrollbarWidth;
|
||
|
|
var scrollDiv = document.createElement("div");
|
||
|
|
scrollDiv.className = "p-scrollbar-measure";
|
||
|
|
document.body.appendChild(scrollDiv);
|
||
|
|
var scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth;
|
||
|
|
document.body.removeChild(scrollDiv);
|
||
|
|
this.calculatedScrollbarWidth = scrollbarWidth;
|
||
|
|
return scrollbarWidth;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getBrowser",
|
||
|
|
value: function getBrowser() {
|
||
|
|
if (!this.browser) {
|
||
|
|
var matched = this.resolveUserAgent();
|
||
|
|
this.browser = {};
|
||
|
|
|
||
|
|
if (matched.browser) {
|
||
|
|
this.browser[matched.browser] = true;
|
||
|
|
this.browser['version'] = matched.version;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (this.browser['chrome']) {
|
||
|
|
this.browser['webkit'] = true;
|
||
|
|
} else if (this.browser['webkit']) {
|
||
|
|
this.browser['safari'] = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return this.browser;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "resolveUserAgent",
|
||
|
|
value: function resolveUserAgent() {
|
||
|
|
var ua = navigator.userAgent.toLowerCase();
|
||
|
|
var match = /(chrome)[ ]([\w.]+)/.exec(ua) || /(webkit)[ ]([\w.]+)/.exec(ua) || /(opera)(?:.*version|)[ ]([\w.]+)/.exec(ua) || /(msie) ([\w.]+)/.exec(ua) || ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) || [];
|
||
|
|
return {
|
||
|
|
browser: match[1] || "",
|
||
|
|
version: match[2] || "0"
|
||
|
|
};
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "isVisible",
|
||
|
|
value: function isVisible(element) {
|
||
|
|
return element && element.offsetParent != null;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "isExist",
|
||
|
|
value: function isExist(element) {
|
||
|
|
return element !== null && typeof element !== 'undefined' && element.nodeName && element.parentNode;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "hasDOM",
|
||
|
|
value: function hasDOM() {
|
||
|
|
return !!(typeof window !== 'undefined' && window.document && window.document.createElement);
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getFocusableElements",
|
||
|
|
value: function getFocusableElements(element) {
|
||
|
|
var selector = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
|
||
|
|
var focusableElements = DomHandler.find(element, "button:not([tabindex = \"-1\"]):not([disabled]):not([style*=\"display:none\"]):not([hidden])".concat(selector, ",\n [href][clientHeight][clientWidth]:not([tabindex = \"-1\"]):not([disabled]):not([style*=\"display:none\"]):not([hidden])").concat(selector, ",\n input:not([tabindex = \"-1\"]):not([disabled]):not([style*=\"display:none\"]):not([hidden])").concat(selector, ",\n select:not([tabindex = \"-1\"]):not([disabled]):not([style*=\"display:none\"]):not([hidden])").concat(selector, ",\n textarea:not([tabindex = \"-1\"]):not([disabled]):not([style*=\"display:none\"]):not([hidden])").concat(selector, ",\n [tabIndex]:not([tabIndex = \"-1\"]):not([disabled]):not([style*=\"display:none\"]):not([hidden])").concat(selector, ",\n [contenteditable]:not([tabIndex = \"-1\"]):not([disabled]):not([style*=\"display:none\"]):not([hidden])").concat(selector));
|
||
|
|
var visibleFocusableElements = [];
|
||
|
|
|
||
|
|
var _iterator3 = _createForOfIteratorHelper(focusableElements),
|
||
|
|
_step3;
|
||
|
|
|
||
|
|
try {
|
||
|
|
for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
|
||
|
|
var focusableElement = _step3.value;
|
||
|
|
if (getComputedStyle(focusableElement).display !== "none" && getComputedStyle(focusableElement).visibility !== "hidden") visibleFocusableElements.push(focusableElement);
|
||
|
|
}
|
||
|
|
} catch (err) {
|
||
|
|
_iterator3.e(err);
|
||
|
|
} finally {
|
||
|
|
_iterator3.f();
|
||
|
|
}
|
||
|
|
|
||
|
|
return visibleFocusableElements;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getFirstFocusableElement",
|
||
|
|
value: function getFirstFocusableElement(element, selector) {
|
||
|
|
var focusableElements = DomHandler.getFocusableElements(element, selector);
|
||
|
|
return focusableElements.length > 0 ? focusableElements[0] : null;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getLastFocusableElement",
|
||
|
|
value: function getLastFocusableElement(element, selector) {
|
||
|
|
var focusableElements = DomHandler.getFocusableElements(element, selector);
|
||
|
|
return focusableElements.length > 0 ? focusableElements[focusableElements.length - 1] : null;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getCursorOffset",
|
||
|
|
value: function getCursorOffset(el, prevText, nextText, currentText) {
|
||
|
|
if (el) {
|
||
|
|
var style = getComputedStyle(el);
|
||
|
|
var ghostDiv = document.createElement('div');
|
||
|
|
ghostDiv.style.position = 'absolute';
|
||
|
|
ghostDiv.style.top = '0px';
|
||
|
|
ghostDiv.style.left = '0px';
|
||
|
|
ghostDiv.style.visibility = 'hidden';
|
||
|
|
ghostDiv.style.pointerEvents = 'none';
|
||
|
|
ghostDiv.style.overflow = style.overflow;
|
||
|
|
ghostDiv.style.width = style.width;
|
||
|
|
ghostDiv.style.height = style.height;
|
||
|
|
ghostDiv.style.padding = style.padding;
|
||
|
|
ghostDiv.style.border = style.border;
|
||
|
|
ghostDiv.style.overflowWrap = style.overflowWrap;
|
||
|
|
ghostDiv.style.whiteSpace = style.whiteSpace;
|
||
|
|
ghostDiv.style.lineHeight = style.lineHeight;
|
||
|
|
ghostDiv.innerHTML = prevText.replace(/\r\n|\r|\n/g, '<br />');
|
||
|
|
var ghostSpan = document.createElement('span');
|
||
|
|
ghostSpan.textContent = currentText;
|
||
|
|
ghostDiv.appendChild(ghostSpan);
|
||
|
|
var text = document.createTextNode(nextText);
|
||
|
|
ghostDiv.appendChild(text);
|
||
|
|
document.body.appendChild(ghostDiv);
|
||
|
|
var offsetLeft = ghostSpan.offsetLeft,
|
||
|
|
offsetTop = ghostSpan.offsetTop,
|
||
|
|
clientHeight = ghostSpan.clientHeight;
|
||
|
|
document.body.removeChild(ghostDiv);
|
||
|
|
return {
|
||
|
|
left: Math.abs(offsetLeft - el.scrollLeft),
|
||
|
|
top: Math.abs(offsetTop - el.scrollTop) + clientHeight
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
return {
|
||
|
|
top: 'auto',
|
||
|
|
left: 'auto'
|
||
|
|
};
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "invokeElementMethod",
|
||
|
|
value: function invokeElementMethod(element, methodName, args) {
|
||
|
|
element[methodName].apply(element, args);
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "isClickable",
|
||
|
|
value: function isClickable(element) {
|
||
|
|
var targetNode = element.nodeName;
|
||
|
|
var parentNode = element.parentElement && element.parentElement.nodeName;
|
||
|
|
return targetNode === 'INPUT' || targetNode === 'TEXTAREA' || targetNode === 'BUTTON' || targetNode === 'A' || parentNode === 'INPUT' || parentNode === 'TEXTAREA' || parentNode === 'BUTTON' || parentNode === 'A' || this.hasClass(element, 'p-button') || this.hasClass(element.parentElement, 'p-button') || this.hasClass(element.parentElement, 'p-checkbox') || this.hasClass(element.parentElement, 'p-radiobutton');
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "applyStyle",
|
||
|
|
value: function applyStyle(element, style) {
|
||
|
|
if (typeof style === 'string') {
|
||
|
|
element.style.cssText = this.style;
|
||
|
|
} else {
|
||
|
|
for (var prop in this.style) {
|
||
|
|
element.style[prop] = style[prop];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "exportCSV",
|
||
|
|
value: function exportCSV(csv, filename) {
|
||
|
|
var blob = new Blob([csv], {
|
||
|
|
type: 'application/csv;charset=utf-8;'
|
||
|
|
});
|
||
|
|
|
||
|
|
if (window.navigator.msSaveOrOpenBlob) {
|
||
|
|
navigator.msSaveOrOpenBlob(blob, filename + '.csv');
|
||
|
|
} else {
|
||
|
|
var isDownloaded = DomHandler.saveAs({
|
||
|
|
name: filename + '.csv',
|
||
|
|
src: URL.createObjectURL(blob)
|
||
|
|
});
|
||
|
|
|
||
|
|
if (!isDownloaded) {
|
||
|
|
csv = 'data:text/csv;charset=utf-8,' + csv;
|
||
|
|
window.open(encodeURI(csv));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "saveAs",
|
||
|
|
value: function saveAs(file) {
|
||
|
|
if (file) {
|
||
|
|
var link = document.createElement('a');
|
||
|
|
|
||
|
|
if (link.download !== undefined) {
|
||
|
|
var name = file.name,
|
||
|
|
src = file.src;
|
||
|
|
link.setAttribute('href', src);
|
||
|
|
link.setAttribute('download', name);
|
||
|
|
link.style.display = 'none';
|
||
|
|
document.body.appendChild(link);
|
||
|
|
link.click();
|
||
|
|
document.body.removeChild(link);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "createInlineStyle",
|
||
|
|
value: function createInlineStyle(nonce) {
|
||
|
|
var styleElement = document.createElement('style');
|
||
|
|
|
||
|
|
try {
|
||
|
|
if (!nonce) {
|
||
|
|
nonce = process.env.REACT_APP_CSS_NONCE;
|
||
|
|
}
|
||
|
|
} catch (error) {// NOOP
|
||
|
|
}
|
||
|
|
|
||
|
|
nonce && styleElement.setAttribute('nonce', nonce);
|
||
|
|
document.head.appendChild(styleElement);
|
||
|
|
return styleElement;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "removeInlineStyle",
|
||
|
|
value: function removeInlineStyle(styleElement) {
|
||
|
|
if (this.isExist(styleElement)) {
|
||
|
|
try {
|
||
|
|
document.head.removeChild(styleElement);
|
||
|
|
} catch (error) {// style element may have already been removed in a fast refresh
|
||
|
|
}
|
||
|
|
|
||
|
|
styleElement = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
return styleElement;
|
||
|
|
}
|
||
|
|
}]);
|
||
|
|
|
||
|
|
return DomHandler;
|
||
|
|
}();
|
||
|
|
|
||
|
|
var ConnectedOverlayScrollHandler = /*#__PURE__*/function () {
|
||
|
|
function ConnectedOverlayScrollHandler(element) {
|
||
|
|
var listener = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function () {};
|
||
|
|
|
||
|
|
_classCallCheck(this, ConnectedOverlayScrollHandler);
|
||
|
|
|
||
|
|
this.element = element;
|
||
|
|
this.listener = listener;
|
||
|
|
}
|
||
|
|
|
||
|
|
_createClass(ConnectedOverlayScrollHandler, [{
|
||
|
|
key: "bindScrollListener",
|
||
|
|
value: function bindScrollListener() {
|
||
|
|
this.scrollableParents = DomHandler.getScrollableParents(this.element);
|
||
|
|
|
||
|
|
for (var i = 0; i < this.scrollableParents.length; i++) {
|
||
|
|
this.scrollableParents[i].addEventListener('scroll', this.listener);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "unbindScrollListener",
|
||
|
|
value: function unbindScrollListener() {
|
||
|
|
if (this.scrollableParents) {
|
||
|
|
for (var i = 0; i < this.scrollableParents.length; i++) {
|
||
|
|
this.scrollableParents[i].removeEventListener('scroll', this.listener);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "destroy",
|
||
|
|
value: function destroy() {
|
||
|
|
this.unbindScrollListener();
|
||
|
|
this.element = null;
|
||
|
|
this.listener = null;
|
||
|
|
this.scrollableParents = null;
|
||
|
|
}
|
||
|
|
}]);
|
||
|
|
|
||
|
|
return ConnectedOverlayScrollHandler;
|
||
|
|
}();
|
||
|
|
|
||
|
|
function EventBus () {
|
||
|
|
var allHandlers = new Map();
|
||
|
|
return {
|
||
|
|
on: function on(type, handler) {
|
||
|
|
var handlers = allHandlers.get(type);
|
||
|
|
if (!handlers) handlers = [handler];else handlers.push(handler);
|
||
|
|
allHandlers.set(type, handlers);
|
||
|
|
},
|
||
|
|
off: function off(type, handler) {
|
||
|
|
var handlers = allHandlers.get(type);
|
||
|
|
handlers && handlers.splice(handlers.indexOf(handler) >>> 0, 1);
|
||
|
|
},
|
||
|
|
emit: function emit(type, evt) {
|
||
|
|
var handlers = allHandlers.get(type);
|
||
|
|
handlers && handlers.slice().forEach(function (handler) {
|
||
|
|
return handler(evt);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
function _defineProperty(obj, key, value) {
|
||
|
|
if (key in obj) {
|
||
|
|
Object.defineProperty(obj, key, {
|
||
|
|
value: value,
|
||
|
|
enumerable: true,
|
||
|
|
configurable: true,
|
||
|
|
writable: true
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
obj[key] = value;
|
||
|
|
}
|
||
|
|
|
||
|
|
return obj;
|
||
|
|
}
|
||
|
|
|
||
|
|
function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
|
||
|
|
|
||
|
|
function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
||
|
|
function mask(el, options) {
|
||
|
|
var defaultOptions = {
|
||
|
|
mask: null,
|
||
|
|
slotChar: '_',
|
||
|
|
autoClear: true,
|
||
|
|
unmask: false,
|
||
|
|
readOnly: false,
|
||
|
|
onComplete: null,
|
||
|
|
onChange: null,
|
||
|
|
onFocus: null,
|
||
|
|
onBlur: null
|
||
|
|
};
|
||
|
|
options = _objectSpread$1(_objectSpread$1({}, defaultOptions), options);
|
||
|
|
var tests, partialPosition, len, firstNonMaskPos, defs, androidChrome, lastRequiredNonMaskPos, oldVal, focusText, caretTimeoutId, buffer, defaultBuffer;
|
||
|
|
|
||
|
|
var caret = function caret(first, last) {
|
||
|
|
var range, begin, end;
|
||
|
|
|
||
|
|
if (!el.offsetParent || el !== document.activeElement) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (typeof first === 'number') {
|
||
|
|
begin = first;
|
||
|
|
end = typeof last === 'number' ? last : begin;
|
||
|
|
|
||
|
|
if (el.setSelectionRange) {
|
||
|
|
el.setSelectionRange(begin, end);
|
||
|
|
} else if (el['createTextRange']) {
|
||
|
|
range = el['createTextRange']();
|
||
|
|
range.collapse(true);
|
||
|
|
range.moveEnd('character', end);
|
||
|
|
range.moveStart('character', begin);
|
||
|
|
range.select();
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (el.setSelectionRange) {
|
||
|
|
begin = el.selectionStart;
|
||
|
|
end = el.selectionEnd;
|
||
|
|
} else if (document['selection'] && document['selection'].createRange) {
|
||
|
|
range = document['selection'].createRange();
|
||
|
|
begin = 0 - range.duplicate().moveStart('character', -100000);
|
||
|
|
end = begin + range.text.length;
|
||
|
|
}
|
||
|
|
|
||
|
|
return {
|
||
|
|
begin: begin,
|
||
|
|
end: end
|
||
|
|
};
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
var isCompleted = function isCompleted() {
|
||
|
|
for (var i = firstNonMaskPos; i <= lastRequiredNonMaskPos; i++) {
|
||
|
|
if (tests[i] && buffer[i] === getPlaceholder(i)) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
};
|
||
|
|
|
||
|
|
var getPlaceholder = function getPlaceholder(i) {
|
||
|
|
if (i < options.slotChar.length) {
|
||
|
|
return options.slotChar.charAt(i);
|
||
|
|
}
|
||
|
|
|
||
|
|
return options.slotChar.charAt(0);
|
||
|
|
};
|
||
|
|
|
||
|
|
var getValue = function getValue() {
|
||
|
|
return options.unmask ? getUnmaskedValue() : el && el.value;
|
||
|
|
};
|
||
|
|
|
||
|
|
var seekNext = function seekNext(pos) {
|
||
|
|
while (++pos < len && !tests[pos]) {
|
||
|
|
}
|
||
|
|
|
||
|
|
return pos;
|
||
|
|
};
|
||
|
|
|
||
|
|
var seekPrev = function seekPrev(pos) {
|
||
|
|
while (--pos >= 0 && !tests[pos]) {
|
||
|
|
}
|
||
|
|
|
||
|
|
return pos;
|
||
|
|
};
|
||
|
|
|
||
|
|
var shiftL = function shiftL(begin, end) {
|
||
|
|
var i, j;
|
||
|
|
|
||
|
|
if (begin < 0) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (i = begin, j = seekNext(end); i < len; i++) {
|
||
|
|
if (tests[i]) {
|
||
|
|
if (j < len && tests[i].test(buffer[j])) {
|
||
|
|
buffer[i] = buffer[j];
|
||
|
|
buffer[j] = getPlaceholder(j);
|
||
|
|
} else {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
j = seekNext(j);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
writeBuffer();
|
||
|
|
caret(Math.max(firstNonMaskPos, begin));
|
||
|
|
};
|
||
|
|
|
||
|
|
var shiftR = function shiftR(pos) {
|
||
|
|
var i, c, j, t;
|
||
|
|
|
||
|
|
for (i = pos, c = getPlaceholder(pos); i < len; i++) {
|
||
|
|
if (tests[i]) {
|
||
|
|
j = seekNext(i);
|
||
|
|
t = buffer[i];
|
||
|
|
buffer[i] = c;
|
||
|
|
|
||
|
|
if (j < len && tests[j].test(t)) {
|
||
|
|
c = t;
|
||
|
|
} else {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
var handleAndroidInput = function handleAndroidInput(e) {
|
||
|
|
var curVal = el.value;
|
||
|
|
var pos = caret();
|
||
|
|
|
||
|
|
if (oldVal && oldVal.length && oldVal.length > curVal.length) {
|
||
|
|
// a deletion or backspace happened
|
||
|
|
checkVal(true);
|
||
|
|
|
||
|
|
while (pos.begin > 0 && !tests[pos.begin - 1]) {
|
||
|
|
pos.begin--;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (pos.begin === 0) {
|
||
|
|
while (pos.begin < firstNonMaskPos && !tests[pos.begin]) {
|
||
|
|
pos.begin++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
caret(pos.begin, pos.begin);
|
||
|
|
} else {
|
||
|
|
checkVal(true);
|
||
|
|
|
||
|
|
while (pos.begin < len && !tests[pos.begin]) {
|
||
|
|
pos.begin++;
|
||
|
|
}
|
||
|
|
|
||
|
|
caret(pos.begin, pos.begin);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (options.onComplete && isCompleted()) {
|
||
|
|
options.onComplete({
|
||
|
|
originalEvent: e,
|
||
|
|
value: getValue()
|
||
|
|
});
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
var onBlur = function onBlur(e) {
|
||
|
|
checkVal();
|
||
|
|
updateModel(e);
|
||
|
|
|
||
|
|
if (options.onBlur) {
|
||
|
|
options.onBlur(e);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (el.value !== focusText) {
|
||
|
|
var event = document.createEvent('HTMLEvents');
|
||
|
|
event.initEvent('change', true, false);
|
||
|
|
el.dispatchEvent(event);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
var onKeyDown = function onKeyDown(e) {
|
||
|
|
if (options.readOnly) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
var k = e.which || e.keyCode,
|
||
|
|
pos,
|
||
|
|
begin,
|
||
|
|
end;
|
||
|
|
var iPhone = /iphone/i.test(DomHandler.getUserAgent());
|
||
|
|
oldVal = el.value; //backspace, delete, and escape get special treatment
|
||
|
|
|
||
|
|
if (k === 8 || k === 46 || iPhone && k === 127) {
|
||
|
|
pos = caret();
|
||
|
|
begin = pos.begin;
|
||
|
|
end = pos.end;
|
||
|
|
|
||
|
|
if (end - begin === 0) {
|
||
|
|
begin = k !== 46 ? seekPrev(begin) : end = seekNext(begin - 1);
|
||
|
|
end = k === 46 ? seekNext(end) : end;
|
||
|
|
}
|
||
|
|
|
||
|
|
clearBuffer(begin, end);
|
||
|
|
shiftL(begin, end - 1);
|
||
|
|
updateModel(e);
|
||
|
|
e.preventDefault();
|
||
|
|
} else if (k === 13) {
|
||
|
|
// enter
|
||
|
|
onBlur(e);
|
||
|
|
updateModel(e);
|
||
|
|
} else if (k === 27) {
|
||
|
|
// escape
|
||
|
|
el.value = focusText;
|
||
|
|
caret(0, checkVal());
|
||
|
|
updateModel(e);
|
||
|
|
e.preventDefault();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
var onKeyPress = function onKeyPress(e) {
|
||
|
|
if (options.readOnly) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
var k = e.which || e.keyCode,
|
||
|
|
pos = caret(),
|
||
|
|
p,
|
||
|
|
c,
|
||
|
|
next,
|
||
|
|
completed;
|
||
|
|
|
||
|
|
if (e.ctrlKey || e.altKey || e.metaKey || k < 32) {
|
||
|
|
//Ignore
|
||
|
|
return;
|
||
|
|
} else if (k && k !== 13) {
|
||
|
|
if (pos.end - pos.begin !== 0) {
|
||
|
|
clearBuffer(pos.begin, pos.end);
|
||
|
|
shiftL(pos.begin, pos.end - 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
p = seekNext(pos.begin - 1);
|
||
|
|
|
||
|
|
if (p < len) {
|
||
|
|
c = String.fromCharCode(k);
|
||
|
|
|
||
|
|
if (tests[p].test(c)) {
|
||
|
|
shiftR(p);
|
||
|
|
buffer[p] = c;
|
||
|
|
writeBuffer();
|
||
|
|
next = seekNext(p);
|
||
|
|
|
||
|
|
if (/android/i.test(DomHandler.getUserAgent())) {
|
||
|
|
//Path for CSP Violation on FireFox OS 1.1
|
||
|
|
var proxy = function proxy() {
|
||
|
|
caret(next);
|
||
|
|
};
|
||
|
|
|
||
|
|
setTimeout(proxy, 0);
|
||
|
|
} else {
|
||
|
|
caret(next);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (pos.begin <= lastRequiredNonMaskPos) {
|
||
|
|
completed = isCompleted();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
e.preventDefault();
|
||
|
|
}
|
||
|
|
|
||
|
|
updateModel(e);
|
||
|
|
|
||
|
|
if (options.onComplete && completed) {
|
||
|
|
options.onComplete({
|
||
|
|
originalEvent: e,
|
||
|
|
value: getValue()
|
||
|
|
});
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
var clearBuffer = function clearBuffer(start, end) {
|
||
|
|
var i;
|
||
|
|
|
||
|
|
for (i = start; i < end && i < len; i++) {
|
||
|
|
if (tests[i]) {
|
||
|
|
buffer[i] = getPlaceholder(i);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
var writeBuffer = function writeBuffer() {
|
||
|
|
el.value = buffer.join('');
|
||
|
|
};
|
||
|
|
|
||
|
|
var checkVal = function checkVal(allow) {
|
||
|
|
//try to place characters where they belong
|
||
|
|
var test = el.value,
|
||
|
|
lastMatch = -1,
|
||
|
|
i,
|
||
|
|
c,
|
||
|
|
pos;
|
||
|
|
|
||
|
|
for (i = 0, pos = 0; i < len; i++) {
|
||
|
|
if (tests[i]) {
|
||
|
|
buffer[i] = getPlaceholder(i);
|
||
|
|
|
||
|
|
while (pos++ < test.length) {
|
||
|
|
c = test.charAt(pos - 1);
|
||
|
|
|
||
|
|
if (tests[i].test(c)) {
|
||
|
|
buffer[i] = c;
|
||
|
|
lastMatch = i;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (pos > test.length) {
|
||
|
|
clearBuffer(i + 1, len);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (buffer[i] === test.charAt(pos)) {
|
||
|
|
pos++;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (i < partialPosition) {
|
||
|
|
lastMatch = i;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (allow) {
|
||
|
|
writeBuffer();
|
||
|
|
} else if (lastMatch + 1 < partialPosition) {
|
||
|
|
if (options.autoClear || buffer.join('') === defaultBuffer) {
|
||
|
|
// Invalid value. Remove it and replace it with the
|
||
|
|
// mask, which is the default behavior.
|
||
|
|
if (el.value) el.value = '';
|
||
|
|
clearBuffer(0, len);
|
||
|
|
} else {
|
||
|
|
// Invalid value, but we opt to show the value to the
|
||
|
|
// user and allow them to correct their mistake.
|
||
|
|
writeBuffer();
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
writeBuffer();
|
||
|
|
el.value = el.value.substring(0, lastMatch + 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
return partialPosition ? i : firstNonMaskPos;
|
||
|
|
};
|
||
|
|
|
||
|
|
var onFocus = function onFocus(e) {
|
||
|
|
if (options.readOnly) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
clearTimeout(caretTimeoutId);
|
||
|
|
var pos;
|
||
|
|
focusText = el.value;
|
||
|
|
pos = checkVal();
|
||
|
|
caretTimeoutId = setTimeout(function () {
|
||
|
|
if (el !== document.activeElement) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
writeBuffer();
|
||
|
|
|
||
|
|
if (pos === options.mask.replace("?", "").length) {
|
||
|
|
caret(0, pos);
|
||
|
|
} else {
|
||
|
|
caret(pos);
|
||
|
|
}
|
||
|
|
}, 10);
|
||
|
|
|
||
|
|
if (options.onFocus) {
|
||
|
|
options.onFocus(e);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
var onInput = function onInput(event) {
|
||
|
|
if (androidChrome) handleAndroidInput(event);else handleInputChange(event);
|
||
|
|
};
|
||
|
|
|
||
|
|
var handleInputChange = function handleInputChange(e) {
|
||
|
|
if (options.readOnly) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
var pos = checkVal(true);
|
||
|
|
caret(pos);
|
||
|
|
updateModel(e);
|
||
|
|
|
||
|
|
if (options.onComplete && isCompleted()) {
|
||
|
|
options.onComplete({
|
||
|
|
originalEvent: e,
|
||
|
|
value: getValue()
|
||
|
|
});
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
var getUnmaskedValue = function getUnmaskedValue() {
|
||
|
|
var unmaskedBuffer = [];
|
||
|
|
|
||
|
|
for (var i = 0; i < buffer.length; i++) {
|
||
|
|
var c = buffer[i];
|
||
|
|
|
||
|
|
if (tests[i] && c !== getPlaceholder(i)) {
|
||
|
|
unmaskedBuffer.push(c);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return unmaskedBuffer.join('');
|
||
|
|
};
|
||
|
|
|
||
|
|
var updateModel = function updateModel(e) {
|
||
|
|
if (options.onChange) {
|
||
|
|
var val = getValue().replace(options.slotChar, '');
|
||
|
|
options.onChange({
|
||
|
|
originalEvent: e,
|
||
|
|
value: defaultBuffer !== val ? val : ''
|
||
|
|
});
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
var bindEvents = function bindEvents() {
|
||
|
|
el.addEventListener('focus', onFocus);
|
||
|
|
el.addEventListener('blur', onBlur);
|
||
|
|
el.addEventListener('keydown', onKeyDown);
|
||
|
|
el.addEventListener('keypress', onKeyPress);
|
||
|
|
el.addEventListener('input', onInput);
|
||
|
|
el.addEventListener('paste', handleInputChange);
|
||
|
|
};
|
||
|
|
|
||
|
|
var unbindEvents = function unbindEvents() {
|
||
|
|
el.removeEventListener('focus', onFocus);
|
||
|
|
el.removeEventListener('blur', onBlur);
|
||
|
|
el.removeEventListener('keydown', onKeyDown);
|
||
|
|
el.removeEventListener('keypress', onKeyPress);
|
||
|
|
el.removeEventListener('input', onInput);
|
||
|
|
el.removeEventListener('paste', handleInputChange);
|
||
|
|
};
|
||
|
|
|
||
|
|
var init = function init() {
|
||
|
|
tests = [];
|
||
|
|
partialPosition = options.mask.length;
|
||
|
|
len = options.mask.length;
|
||
|
|
firstNonMaskPos = null;
|
||
|
|
defs = {
|
||
|
|
'9': '[0-9]',
|
||
|
|
'a': '[A-Za-z]',
|
||
|
|
'*': '[A-Za-z0-9]'
|
||
|
|
};
|
||
|
|
var ua = DomHandler.getUserAgent();
|
||
|
|
androidChrome = /chrome/i.test(ua) && /android/i.test(ua);
|
||
|
|
var maskTokens = options.mask.split('');
|
||
|
|
|
||
|
|
for (var i = 0; i < maskTokens.length; i++) {
|
||
|
|
var c = maskTokens[i];
|
||
|
|
|
||
|
|
if (c === '?') {
|
||
|
|
len--;
|
||
|
|
partialPosition = i;
|
||
|
|
} else if (defs[c]) {
|
||
|
|
tests.push(new RegExp(defs[c]));
|
||
|
|
|
||
|
|
if (firstNonMaskPos === null) {
|
||
|
|
firstNonMaskPos = tests.length - 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (i < partialPosition) {
|
||
|
|
lastRequiredNonMaskPos = tests.length - 1;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
tests.push(null);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
buffer = [];
|
||
|
|
|
||
|
|
for (var _i = 0; _i < maskTokens.length; _i++) {
|
||
|
|
var _c = maskTokens[_i];
|
||
|
|
|
||
|
|
if (_c !== '?') {
|
||
|
|
if (defs[_c]) buffer.push(getPlaceholder(_i));else buffer.push(_c);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
defaultBuffer = buffer.join('');
|
||
|
|
};
|
||
|
|
|
||
|
|
if (el && options.mask) {
|
||
|
|
init();
|
||
|
|
bindEvents();
|
||
|
|
}
|
||
|
|
|
||
|
|
return {
|
||
|
|
init: init,
|
||
|
|
bindEvents: bindEvents,
|
||
|
|
unbindEvents: unbindEvents,
|
||
|
|
updateModel: updateModel,
|
||
|
|
getValue: getValue
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
var ObjectUtils = /*#__PURE__*/function () {
|
||
|
|
function ObjectUtils() {
|
||
|
|
_classCallCheck(this, ObjectUtils);
|
||
|
|
}
|
||
|
|
|
||
|
|
_createClass(ObjectUtils, null, [{
|
||
|
|
key: "equals",
|
||
|
|
value: function equals(obj1, obj2, field) {
|
||
|
|
if (field && obj1 && _typeof(obj1) === 'object' && obj2 && _typeof(obj2) === 'object') return this.resolveFieldData(obj1, field) === this.resolveFieldData(obj2, field);else return this.deepEquals(obj1, obj2);
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "deepEquals",
|
||
|
|
value: function deepEquals(a, b) {
|
||
|
|
if (a === b) return true;
|
||
|
|
|
||
|
|
if (a && b && _typeof(a) == 'object' && _typeof(b) == 'object') {
|
||
|
|
var arrA = Array.isArray(a),
|
||
|
|
arrB = Array.isArray(b),
|
||
|
|
i,
|
||
|
|
length,
|
||
|
|
key;
|
||
|
|
|
||
|
|
if (arrA && arrB) {
|
||
|
|
length = a.length;
|
||
|
|
if (length !== b.length) return false;
|
||
|
|
|
||
|
|
for (i = length; i-- !== 0;) {
|
||
|
|
if (!this.deepEquals(a[i], b[i])) return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (arrA !== arrB) return false;
|
||
|
|
var dateA = a instanceof Date,
|
||
|
|
dateB = b instanceof Date;
|
||
|
|
if (dateA !== dateB) return false;
|
||
|
|
if (dateA && dateB) return a.getTime() === b.getTime();
|
||
|
|
var regexpA = a instanceof RegExp,
|
||
|
|
regexpB = b instanceof RegExp;
|
||
|
|
if (regexpA !== regexpB) return false;
|
||
|
|
if (regexpA && regexpB) return a.toString() === b.toString();
|
||
|
|
var keys = Object.keys(a);
|
||
|
|
length = keys.length;
|
||
|
|
if (length !== Object.keys(b).length) return false;
|
||
|
|
|
||
|
|
for (i = length; i-- !== 0;) {
|
||
|
|
if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (i = length; i-- !== 0;) {
|
||
|
|
key = keys[i];
|
||
|
|
if (!this.deepEquals(a[key], b[key])) return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
/*eslint no-self-compare: "off"*/
|
||
|
|
|
||
|
|
|
||
|
|
return a !== a && b !== b;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "resolveFieldData",
|
||
|
|
value: function resolveFieldData(data, field) {
|
||
|
|
if (data && Object.keys(data).length && field) {
|
||
|
|
if (this.isFunction(field)) {
|
||
|
|
return field(data);
|
||
|
|
} else if (field.indexOf('.') === -1) {
|
||
|
|
return data[field];
|
||
|
|
} else {
|
||
|
|
var fields = field.split('.');
|
||
|
|
var value = data;
|
||
|
|
|
||
|
|
for (var i = 0, len = fields.length; i < len; ++i) {
|
||
|
|
if (value == null) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
value = value[fields[i]];
|
||
|
|
}
|
||
|
|
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "isFunction",
|
||
|
|
value: function isFunction(obj) {
|
||
|
|
return !!(obj && obj.constructor && obj.call && obj.apply);
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "findDiffKeys",
|
||
|
|
value: function findDiffKeys(obj1, obj2) {
|
||
|
|
if (!obj1 || !obj2) {
|
||
|
|
return {};
|
||
|
|
}
|
||
|
|
|
||
|
|
return Object.keys(obj1).filter(function (key) {
|
||
|
|
return !obj2.hasOwnProperty(key);
|
||
|
|
}).reduce(function (result, current) {
|
||
|
|
result[current] = obj1[current];
|
||
|
|
return result;
|
||
|
|
}, {});
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "reorderArray",
|
||
|
|
value: function reorderArray(value, from, to) {
|
||
|
|
var target;
|
||
|
|
|
||
|
|
if (value && from !== to) {
|
||
|
|
if (to >= value.length) {
|
||
|
|
target = to - value.length;
|
||
|
|
|
||
|
|
while (target-- + 1) {
|
||
|
|
value.push(undefined);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
value.splice(to, 0, value.splice(from, 1)[0]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "findIndexInList",
|
||
|
|
value: function findIndexInList(value, list, dataKey) {
|
||
|
|
var _this = this;
|
||
|
|
|
||
|
|
if (list) {
|
||
|
|
return dataKey ? list.findIndex(function (item) {
|
||
|
|
return _this.equals(item, value, dataKey);
|
||
|
|
}) : list.findIndex(function (item) {
|
||
|
|
return item === value;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getJSXElement",
|
||
|
|
value: function getJSXElement(obj) {
|
||
|
|
for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
||
|
|
params[_key - 1] = arguments[_key];
|
||
|
|
}
|
||
|
|
|
||
|
|
return this.isFunction(obj) ? obj.apply(void 0, params) : obj;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getPropValue",
|
||
|
|
value: function getPropValue(obj) {
|
||
|
|
for (var _len2 = arguments.length, params = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
|
||
|
|
params[_key2 - 1] = arguments[_key2];
|
||
|
|
}
|
||
|
|
|
||
|
|
return this.isFunction(obj) ? obj.apply(void 0, params) : obj;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "getRefElement",
|
||
|
|
value: function getRefElement(ref) {
|
||
|
|
if (ref) {
|
||
|
|
return _typeof(ref) === 'object' && ref.hasOwnProperty('current') ? ref.current : ref;
|
||
|
|
}
|
||
|
|
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "removeAccents",
|
||
|
|
value: function removeAccents(str) {
|
||
|
|
if (str && str.search(/[\xC0-\xFF]/g) > -1) {
|
||
|
|
str = str.replace(/[\xC0-\xC5]/g, "A").replace(/[\xC6]/g, "AE").replace(/[\xC7]/g, "C").replace(/[\xC8-\xCB]/g, "E").replace(/[\xCC-\xCF]/g, "I").replace(/[\xD0]/g, "D").replace(/[\xD1]/g, "N").replace(/[\xD2-\xD6\xD8]/g, "O").replace(/[\xD9-\xDC]/g, "U").replace(/[\xDD]/g, "Y").replace(/[\xDE]/g, "P").replace(/[\xE0-\xE5]/g, "a").replace(/[\xE6]/g, "ae").replace(/[\xE7]/g, "c").replace(/[\xE8-\xEB]/g, "e").replace(/[\xEC-\xEF]/g, "i").replace(/[\xF1]/g, "n").replace(/[\xF2-\xF6\xF8]/g, "o").replace(/[\xF9-\xFC]/g, "u").replace(/[\xFE]/g, "p").replace(/[\xFD\xFF]/g, "y");
|
||
|
|
}
|
||
|
|
|
||
|
|
return str;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "isEmpty",
|
||
|
|
value: function isEmpty(value) {
|
||
|
|
return value === null || value === undefined || value === '' || Array.isArray(value) && value.length === 0 || !(value instanceof Date) && _typeof(value) === 'object' && Object.keys(value).length === 0;
|
||
|
|
}
|
||
|
|
}, {
|
||
|
|
key: "isNotEmpty",
|
||
|
|
value: function isNotEmpty(value) {
|
||
|
|
return !this.isEmpty(value);
|
||
|
|
}
|
||
|
|
}]);
|
||
|
|
|
||
|
|
return ObjectUtils;
|
||
|
|
}();
|
||
|
|
|
||
|
|
function _extends() {
|
||
|
|
_extends = Object.assign || function (target) {
|
||
|
|
for (var i = 1; i < arguments.length; i++) {
|
||
|
|
var source = arguments[i];
|
||
|
|
|
||
|
|
for (var key in source) {
|
||
|
|
if (Object.prototype.hasOwnProperty.call(source, key)) {
|
||
|
|
target[key] = source[key];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
|
||
|
|
return _extends.apply(this, arguments);
|
||
|
|
}
|
||
|
|
|
||
|
|
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
|
||
|
|
|
||
|
|
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
||
|
|
|
||
|
|
var IconUtils = /*#__PURE__*/function () {
|
||
|
|
function IconUtils() {
|
||
|
|
_classCallCheck(this, IconUtils);
|
||
|
|
}
|
||
|
|
|
||
|
|
_createClass(IconUtils, null, [{
|
||
|
|
key: "getJSXIcon",
|
||
|
|
value: function getJSXIcon(icon, iconProps, options) {
|
||
|
|
var content = null;
|
||
|
|
|
||
|
|
if (icon) {
|
||
|
|
var iconType = _typeof(icon);
|
||
|
|
|
||
|
|
var className = classNames(iconProps.className, iconType === 'string' && icon);
|
||
|
|
content = /*#__PURE__*/React.createElement("span", _extends({}, iconProps, {
|
||
|
|
className: className
|
||
|
|
}));
|
||
|
|
|
||
|
|
if (iconType !== 'string') {
|
||
|
|
var defaultContentOptions = _objectSpread({
|
||
|
|
iconProps: iconProps,
|
||
|
|
element: content
|
||
|
|
}, options);
|
||
|
|
|
||
|
|
return ObjectUtils.getJSXElement(icon, defaultContentOptions);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return content;
|
||
|
|
}
|
||
|
|
}]);
|
||
|
|
|
||
|
|
return IconUtils;
|
||
|
|
}();
|
||
|
|
|
||
|
|
var lastId = 0;
|
||
|
|
function UniqueComponentId () {
|
||
|
|
var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'pr_id_';
|
||
|
|
lastId++;
|
||
|
|
return "".concat(prefix).concat(lastId);
|
||
|
|
}
|
||
|
|
|
||
|
|
function _arrayWithoutHoles(arr) {
|
||
|
|
if (Array.isArray(arr)) return _arrayLikeToArray$1(arr);
|
||
|
|
}
|
||
|
|
|
||
|
|
function _iterableToArray(iter) {
|
||
|
|
if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
|
||
|
|
}
|
||
|
|
|
||
|
|
function _nonIterableSpread() {
|
||
|
|
throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
||
|
|
}
|
||
|
|
|
||
|
|
function _toConsumableArray(arr) {
|
||
|
|
return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray$1(arr) || _nonIterableSpread();
|
||
|
|
}
|
||
|
|
|
||
|
|
function handler() {
|
||
|
|
var zIndexes = [];
|
||
|
|
|
||
|
|
var generateZIndex = function generateZIndex(key, autoZIndex) {
|
||
|
|
var baseZIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 999;
|
||
|
|
var lastZIndex = getLastZIndex(key, autoZIndex, baseZIndex);
|
||
|
|
var newZIndex = lastZIndex.value + (lastZIndex.key === key ? 0 : baseZIndex) + 1;
|
||
|
|
zIndexes.push({
|
||
|
|
key: key,
|
||
|
|
value: newZIndex
|
||
|
|
});
|
||
|
|
return newZIndex;
|
||
|
|
};
|
||
|
|
|
||
|
|
var revertZIndex = function revertZIndex(zIndex) {
|
||
|
|
zIndexes = zIndexes.filter(function (obj) {
|
||
|
|
return obj.value !== zIndex;
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
var getCurrentZIndex = function getCurrentZIndex(key, autoZIndex) {
|
||
|
|
return getLastZIndex(key, autoZIndex).value;
|
||
|
|
};
|
||
|
|
|
||
|
|
var getLastZIndex = function getLastZIndex(key, autoZIndex) {
|
||
|
|
var baseZIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
|
||
|
|
return _toConsumableArray(zIndexes).reverse().find(function (obj) {
|
||
|
|
return autoZIndex ? true : obj.key === key;
|
||
|
|
}) || {
|
||
|
|
key: key,
|
||
|
|
value: baseZIndex
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
var getZIndex = function getZIndex(el) {
|
||
|
|
return el ? parseInt(el.style.zIndex, 10) || 0 : 0;
|
||
|
|
};
|
||
|
|
|
||
|
|
return {
|
||
|
|
get: getZIndex,
|
||
|
|
set: function set(key, el, autoZIndex, baseZIndex) {
|
||
|
|
if (el) {
|
||
|
|
el.style.zIndex = String(generateZIndex(key, autoZIndex, baseZIndex));
|
||
|
|
}
|
||
|
|
},
|
||
|
|
clear: function clear(el) {
|
||
|
|
if (el) {
|
||
|
|
revertZIndex(ZIndexUtils.get(el));
|
||
|
|
el.style.zIndex = '';
|
||
|
|
}
|
||
|
|
},
|
||
|
|
getCurrent: function getCurrent(key, autoZIndex) {
|
||
|
|
return getCurrentZIndex(key, autoZIndex);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
var ZIndexUtils = handler();
|
||
|
|
|
||
|
|
export { ConnectedOverlayScrollHandler, DomHandler, EventBus, IconUtils, ObjectUtils, UniqueComponentId, ZIndexUtils, classNames, mask };
|