51419 lines
1.7 MiB
51419 lines
1.7 MiB
import React, { Component, createRef } from 'react';
|
|
import { CSSTransition as CSSTransition$1, TransitionGroup } from 'react-transition-group';
|
|
import ReactDOM from 'react-dom';
|
|
|
|
function _arrayLikeToArray$j(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 _arrayWithoutHoles(arr) {
|
|
if (Array.isArray(arr)) return _arrayLikeToArray$j(arr);
|
|
}
|
|
|
|
function _iterableToArray(iter) {
|
|
if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
|
|
}
|
|
|
|
function _unsupportedIterableToArray$j(o, minLen) {
|
|
if (!o) return;
|
|
if (typeof o === "string") return _arrayLikeToArray$j(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$j(o, minLen);
|
|
}
|
|
|
|
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$j(arr) || _nonIterableSpread();
|
|
}
|
|
|
|
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 _classCallCheck(instance, Constructor) {
|
|
if (!(instance instanceof Constructor)) {
|
|
throw new TypeError("Cannot call a class as a function");
|
|
}
|
|
}
|
|
|
|
function _setPrototypeOf(o, p) {
|
|
_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
|
|
o.__proto__ = p;
|
|
return o;
|
|
};
|
|
|
|
return _setPrototypeOf(o, p);
|
|
}
|
|
|
|
function _inherits(subClass, superClass) {
|
|
if (typeof superClass !== "function" && superClass !== null) {
|
|
throw new TypeError("Super expression must either be null or a function");
|
|
}
|
|
|
|
subClass.prototype = Object.create(superClass && superClass.prototype, {
|
|
constructor: {
|
|
value: subClass,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
Object.defineProperty(subClass, "prototype", {
|
|
writable: false
|
|
});
|
|
if (superClass) _setPrototypeOf(subClass, superClass);
|
|
}
|
|
|
|
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 _assertThisInitialized(self) {
|
|
if (self === void 0) {
|
|
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
function _possibleConstructorReturn(self, call) {
|
|
if (call && (_typeof(call) === "object" || typeof call === "function")) {
|
|
return call;
|
|
} else if (call !== void 0) {
|
|
throw new TypeError("Derived constructors may only return object or undefined");
|
|
}
|
|
|
|
return _assertThisInitialized(self);
|
|
}
|
|
|
|
function _getPrototypeOf(o) {
|
|
_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
|
|
return o.__proto__ || Object.getPrototypeOf(o);
|
|
};
|
|
return _getPrototypeOf(o);
|
|
}
|
|
|
|
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 _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 _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$j(arr, i) || _nonIterableRest();
|
|
}
|
|
|
|
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 _createForOfIteratorHelper$i(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$i(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$i(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$i(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$i(o, minLen); }
|
|
|
|
function _arrayLikeToArray$i(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$i(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$i(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$i(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 ownKeys$V(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$V(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$V(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$V(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$V(_objectSpread$V({}, 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$U(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$U(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$U(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$U(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$U({
|
|
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 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();
|
|
|
|
var FilterMatchMode = Object.freeze({
|
|
STARTS_WITH: 'startsWith',
|
|
CONTAINS: 'contains',
|
|
NOT_CONTAINS: 'notContains',
|
|
ENDS_WITH: 'endsWith',
|
|
EQUALS: 'equals',
|
|
NOT_EQUALS: 'notEquals',
|
|
IN: 'in',
|
|
LESS_THAN: 'lt',
|
|
LESS_THAN_OR_EQUAL_TO: 'lte',
|
|
GREATER_THAN: 'gt',
|
|
GREATER_THAN_OR_EQUAL_TO: 'gte',
|
|
BETWEEN: 'between',
|
|
DATE_IS: 'dateIs',
|
|
DATE_IS_NOT: 'dateIsNot',
|
|
DATE_BEFORE: 'dateBefore',
|
|
DATE_AFTER: 'dateAfter',
|
|
CUSTOM: 'custom'
|
|
});
|
|
|
|
var PrimeReact = /*#__PURE__*/_createClass(function PrimeReact() {
|
|
_classCallCheck(this, PrimeReact);
|
|
});
|
|
|
|
_defineProperty(PrimeReact, "ripple", false);
|
|
|
|
_defineProperty(PrimeReact, "inputStyle", 'outlined');
|
|
|
|
_defineProperty(PrimeReact, "locale", 'en');
|
|
|
|
_defineProperty(PrimeReact, "appendTo", null);
|
|
|
|
_defineProperty(PrimeReact, "cssTransition", true);
|
|
|
|
_defineProperty(PrimeReact, "autoZIndex", true);
|
|
|
|
_defineProperty(PrimeReact, "nonce", null);
|
|
|
|
_defineProperty(PrimeReact, "zIndex", {
|
|
modal: 1100,
|
|
overlay: 1000,
|
|
menu: 1000,
|
|
tooltip: 1100,
|
|
toast: 1200
|
|
});
|
|
|
|
_defineProperty(PrimeReact, "filterMatchModeOptions", {
|
|
text: [FilterMatchMode.STARTS_WITH, FilterMatchMode.CONTAINS, FilterMatchMode.NOT_CONTAINS, FilterMatchMode.ENDS_WITH, FilterMatchMode.EQUALS, FilterMatchMode.NOT_EQUALS],
|
|
numeric: [FilterMatchMode.EQUALS, FilterMatchMode.NOT_EQUALS, FilterMatchMode.LESS_THAN, FilterMatchMode.LESS_THAN_OR_EQUAL_TO, FilterMatchMode.GREATER_THAN, FilterMatchMode.GREATER_THAN_OR_EQUAL_TO],
|
|
date: [FilterMatchMode.DATE_IS, FilterMatchMode.DATE_IS_NOT, FilterMatchMode.DATE_BEFORE, FilterMatchMode.DATE_AFTER]
|
|
});
|
|
|
|
function ownKeys$T(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$T(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$T(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$T(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
var locales = {
|
|
'en': {
|
|
startsWith: 'Starts with',
|
|
contains: 'Contains',
|
|
notContains: 'Not contains',
|
|
endsWith: 'Ends with',
|
|
equals: 'Equals',
|
|
notEquals: 'Not equals',
|
|
noFilter: 'No Filter',
|
|
lt: 'Less than',
|
|
lte: 'Less than or equal to',
|
|
gt: 'Greater than',
|
|
gte: 'Greater than or equal to',
|
|
dateIs: 'Date is',
|
|
dateIsNot: 'Date is not',
|
|
dateBefore: 'Date is before',
|
|
dateAfter: 'Date is after',
|
|
custom: 'Custom',
|
|
clear: 'Clear',
|
|
apply: 'Apply',
|
|
matchAll: 'Match All',
|
|
matchAny: 'Match Any',
|
|
addRule: 'Add Rule',
|
|
removeRule: 'Remove Rule',
|
|
accept: 'Yes',
|
|
reject: 'No',
|
|
choose: 'Choose',
|
|
upload: 'Upload',
|
|
cancel: 'Cancel',
|
|
dayNames: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
|
|
dayNamesShort: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
|
|
dayNamesMin: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
|
|
monthNames: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
|
|
monthNamesShort: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
|
|
today: 'Today',
|
|
weekHeader: 'Wk',
|
|
firstDayOfWeek: 0,
|
|
dateFormat: 'mm/dd/yy',
|
|
weak: 'Weak',
|
|
medium: 'Medium',
|
|
strong: 'Strong',
|
|
passwordPrompt: 'Enter a password',
|
|
emptyFilterMessage: 'No results found',
|
|
emptyMessage: 'No available options'
|
|
}
|
|
};
|
|
|
|
function locale(locale) {
|
|
locale && (PrimeReact.locale = locale);
|
|
return {
|
|
locale: PrimeReact.locale,
|
|
options: locales[PrimeReact.locale]
|
|
};
|
|
}
|
|
|
|
function addLocale(locale, options) {
|
|
locales[locale] = _objectSpread$T(_objectSpread$T({}, locales['en']), options);
|
|
}
|
|
|
|
function updateLocaleOption(key, value, locale) {
|
|
localeOptions(locale)[key] = value;
|
|
}
|
|
|
|
function updateLocaleOptions(options, locale) {
|
|
var _locale = locale || PrimeReact.locale;
|
|
|
|
locales[_locale] = _objectSpread$T(_objectSpread$T({}, locales[_locale]), options);
|
|
}
|
|
|
|
function localeOption(key, locale) {
|
|
var _locale = locale || PrimeReact.locale;
|
|
|
|
try {
|
|
return localeOptions(_locale)[key];
|
|
} catch (error) {
|
|
throw new Error("The ".concat(key, " option is not found in the current locale('").concat(_locale, "')."));
|
|
}
|
|
}
|
|
|
|
function localeOptions(locale) {
|
|
var _locale = locale || PrimeReact.locale;
|
|
|
|
return locales[_locale];
|
|
}
|
|
|
|
var PrimeIcons = Object.freeze({
|
|
ALIGN_CENTER: 'pi pi-align-center',
|
|
ALIGN_JUSTIFY: 'pi pi-align-justify',
|
|
ALIGN_LEFT: 'pi pi-align-left',
|
|
ALIGN_RIGHT: 'pi pi-align-right',
|
|
AMAZON: 'pi pi-amazon',
|
|
ANDROID: 'pi pi-android',
|
|
ANGLE_DOUBLE_DOWN: 'pi pi-angle-double-down',
|
|
ANGLE_DOUBLE_LEFT: 'pi pi-angle-double-left',
|
|
ANGLE_DOUBLE_RIGHT: 'pi pi-angle-double-right',
|
|
ANGLE_DOUBLE_UP: 'pi pi-angle-double-up',
|
|
ANGLE_DOWN: 'pi pi-angle-down',
|
|
ANGLE_LEFT: 'pi pi-angle-left',
|
|
ANGLE_RIGHT: 'pi pi-angle-right',
|
|
ANGLE_UP: 'pi pi-angle-up',
|
|
APPLE: 'pi pi-apple',
|
|
ARROW_CIRCLE_DOWN: 'pi pi-arrow-circle-down',
|
|
ARROW_CIRCLE_LEFT: 'pi pi-arrow-circle-left',
|
|
ARROW_CIRCLE_RIGHT: 'pi pi-arrow-circle-right',
|
|
ARROW_CIRCLE_UP: 'pi pi-arrow-circle-up',
|
|
ARROW_DOWN: 'pi pi-arrow-down',
|
|
ARROW_DOWN_LEFT: 'pi pi-arrow-down-left',
|
|
ARROW_DOWN_RIGHT: 'pi pi-arrow-down-right',
|
|
ARROW_LEFT: 'pi pi-arrow-left',
|
|
ARROW_RIGHT: 'pi pi-arrow-right',
|
|
ARROW_UP: 'pi pi-arrow-up',
|
|
ARROW_UP_LEFT: 'pi pi-arrow-up-left',
|
|
ARROW_UP_RIGHT: 'pi pi-arrow-up-right',
|
|
ARROW_H: 'pi pi-arrow-h',
|
|
ARROW_V: 'pi pi-arrow-v',
|
|
AT: 'pi pi-at',
|
|
BACKWARD: 'pi pi-backward',
|
|
BAN: 'pi pi-ban',
|
|
BARS: 'pi pi-bars',
|
|
BELL: 'pi pi-bell',
|
|
BOLT: 'pi pi-bolt',
|
|
BOOK: 'pi pi-book',
|
|
BOOKMARK: 'pi pi-bookmark',
|
|
BOOKMARK_FILL: 'pi pi-bookmark-fill',
|
|
BOX: 'pi pi-box',
|
|
BRIEFCASE: 'pi pi-briefcase',
|
|
BUILDING: 'pi pi-building',
|
|
CALENDAR: 'pi pi-calendar',
|
|
CALENDAR_MINUS: 'pi pi-calendar-minus',
|
|
CALENDAR_PLUS: 'pi pi-calendar-plus',
|
|
CALENDAR_TIMES: 'pi pi-calendar-times',
|
|
CAMERA: 'pi pi-camera',
|
|
CAR: 'pi pi-car',
|
|
CARET_DOWN: 'pi pi-caret-down',
|
|
CARET_LEFT: 'pi pi-caret-left',
|
|
CARET_RIGHT: 'pi pi-caret-right',
|
|
CARET_UP: 'pi pi-caret-up',
|
|
CHART_BAR: 'pi pi-chart-bar',
|
|
CHART_LINE: 'pi pi-chart-line',
|
|
CHART_PIE: 'pi pi-chart-pie',
|
|
CHECK: 'pi pi-check',
|
|
CHECK_CIRCLE: 'pi pi-check-circle',
|
|
CHECK_SQUARE: 'pi pi-check-square',
|
|
CHEVRON_CIRCLE_DOWN: 'pi pi-chevron-circle-down',
|
|
CHEVRON_CIRCLE_LEFT: 'pi pi-chevron-circle-left',
|
|
CHEVRON_CIRCLE_RIGHT: 'pi pi-chevron-circle-right',
|
|
CHEVRON_CIRCLE_UP: 'pi pi-chevron-circle-up',
|
|
CHEVRON_DOWN: 'pi pi-chevron-down',
|
|
CHEVRON_LEFT: 'pi pi-chevron-left',
|
|
CHEVRON_RIGHT: 'pi pi-chevron-right',
|
|
CHEVRON_UP: 'pi pi-chevron-up',
|
|
CIRCLE: 'pi pi-circle',
|
|
CIRCLE_FILL: 'pi pi-circle-fill',
|
|
CLOCK: 'pi pi-clock',
|
|
CLONE: 'pi pi-clone',
|
|
CLOUD: 'pi pi-cloud',
|
|
CLOUD_DOWNLOAD: 'pi pi-cloud-download',
|
|
CLOUD_UPLOAD: 'pi pi-cloud-upload',
|
|
CODE: 'pi pi-code',
|
|
COG: 'pi pi-cog',
|
|
COMMENT: 'pi pi-comment',
|
|
COMMENTS: 'pi pi-comments',
|
|
COMPASS: 'pi pi-compass',
|
|
COPY: 'pi pi-copy',
|
|
CREDIT_CARD: 'pi pi-credit-card',
|
|
DATABASE: 'pi pi-database',
|
|
DESKTOP: 'pi pi-desktop',
|
|
DIRECTIONS: 'pi pi-directions',
|
|
DIRECTIONS_ALT: 'pi pi-directions-alt',
|
|
DISCORD: 'pi pi-discord',
|
|
DOLLAR: 'pi pi-dollar',
|
|
DOWNLOAD: 'pi pi-download',
|
|
EJECT: 'pi pi-eject',
|
|
ELLIPSIS_H: 'pi pi-ellipsis-h',
|
|
ELLIPSIS_V: 'pi pi-ellipsis-v',
|
|
ENVELOPE: 'pi pi-envelope',
|
|
EURO: 'pi pi-euro',
|
|
EXCLAMATION_CIRCLE: 'pi pi-exclamation-circle',
|
|
EXCLAMATION_TRIANGLE: 'pi pi-exclamation-triangle',
|
|
EXTERNAL_LINK: 'pi pi-external-link',
|
|
EYE: 'pi pi-eye',
|
|
EYE_SLASH: 'pi pi-eye-slash',
|
|
FACEBOOK: 'pi pi-facebook',
|
|
FAST_BACKWARD: 'pi pi-fast-backward',
|
|
FAST_FORWARD: 'pi pi-fast-forward',
|
|
FILE: 'pi pi-file',
|
|
FILE_EXCEL: 'pi pi-file-excel',
|
|
FILE_PDF: 'pi pi-file-pdf',
|
|
FILTER: 'pi pi-filter',
|
|
FILTER_FILL: 'pi pi-filter-fill',
|
|
FILTER_SLASH: 'pi pi-filter-slash',
|
|
FLAG: 'pi pi-flag',
|
|
FLAG_FILL: 'pi pi-flag-fill',
|
|
FOLDER: 'pi pi-folder',
|
|
FOLDER_OPEN: 'pi pi-folder-open',
|
|
FORWARD: 'pi pi-forward',
|
|
GITHUB: 'pi pi-github',
|
|
GLOBE: 'pi pi-globe',
|
|
GOOGLE: 'pi pi-google',
|
|
HASHTAG: 'pi pi-hashtag',
|
|
HEART: 'pi pi-heart',
|
|
HEART_FILL: 'pi pi-heart-fill',
|
|
HISTORY: 'pi pi-history',
|
|
HOME: 'pi pi-home',
|
|
ID_CARD: 'pi pi-id-card',
|
|
IMAGE: 'pi pi-image',
|
|
IMAGES: 'pi pi-images',
|
|
INBOX: 'pi pi-inbox',
|
|
INFO: 'pi pi-info',
|
|
INFO_CIRCLE: 'pi pi-info-circle',
|
|
INSTAGRAM: 'pi pi-instagram',
|
|
KEY: 'pi pi-key',
|
|
LINK: 'pi pi-link',
|
|
LINKEDIN: 'pi pi-linkedin',
|
|
LIST: 'pi pi-list',
|
|
LOCK: 'pi pi-lock',
|
|
LOCK_OPEN: 'pi pi-lock-open',
|
|
MAP: 'pi pi-map',
|
|
MAP_MARKER: 'pi pi-map-marker',
|
|
MICROSOFT: 'pi pi-microsoft',
|
|
MINUS: 'pi pi-minus',
|
|
MINUS_CIRCLE: 'pi pi-minus-circle',
|
|
MOBILE: 'pi pi-mobile',
|
|
MONEY_BILL: 'pi pi-money-bill',
|
|
MOON: 'pi pi-moon',
|
|
PALETTE: 'pi pi-palette',
|
|
PAPERCLIP: 'pi pi-paperclip',
|
|
PAUSE: 'pi pi-pause',
|
|
PAYPAL: 'pi pi-paypal',
|
|
PENCIL: 'pi pi-pencil',
|
|
PERCENTAGE: 'pi pi-percentage',
|
|
PHONE: 'pi pi-phone',
|
|
PLAY: 'pi pi-play',
|
|
PLUS: 'pi pi-plus',
|
|
PLUS_CIRCLE: 'pi pi-plus-circle',
|
|
POUND: 'pi pi-pound',
|
|
POWER_OFF: 'pi pi-power-off',
|
|
PRIME: 'pi pi-prime',
|
|
PRINT: 'pi pi-print',
|
|
QRCODE: 'pi pi-qrcode',
|
|
QUESTION: 'pi pi-question',
|
|
QUESTION_CIRCLE: 'pi pi-question-circle',
|
|
REDDIT: 'pi pi-reddit',
|
|
REFRESH: 'pi pi-refresh',
|
|
REPLAY: 'pi pi-replay',
|
|
REPLY: 'pi pi-reply',
|
|
SAVE: 'pi pi-save',
|
|
SEARCH: 'pi pi-search',
|
|
SEARCH_MINUS: 'pi pi-search-minus',
|
|
SEARCH_PLUS: 'pi pi-search-plus',
|
|
SEND: 'pi pi-send',
|
|
SERVER: 'pi pi-server',
|
|
SHARE_ALT: 'pi pi-share-alt',
|
|
SHIELD: 'pi pi-shield',
|
|
SHOPPING_BAG: 'pi pi-shopping-bag',
|
|
SHOPPING_CART: 'pi pi-shopping-cart',
|
|
SIGN_IN: 'pi pi-sign-in',
|
|
SIGN_OUT: 'pi pi-sign-out',
|
|
SITEMAP: 'pi pi-sitemap',
|
|
SLACK: 'pi pi-slack',
|
|
SLIDERS_H: 'pi pi-sliders-h',
|
|
SLIDERS_V: 'pi pi-sliders-v',
|
|
SORT: 'pi pi-sort',
|
|
SORT_ALPHA_DOWN: 'pi pi-sort-alpha-down',
|
|
SORT_ALPHA_ALT_DOWN: 'pi pi-sort-alpha-alt-down',
|
|
SORT_ALPHA_UP: 'pi pi-sort-alpha-up',
|
|
SORT_ALPHA_ALT_UP: 'pi pi-sort-alpha-alt-up',
|
|
SORT_ALT: 'pi pi-sort-alt',
|
|
SORT_ALT_SLASH: 'pi pi-sort-slash',
|
|
SORT_AMOUNT_DOWN: 'pi pi-sort-amount-down',
|
|
SORT_AMOUNT_DOWN_ALT: 'pi pi-sort-amount-down-alt',
|
|
SORT_AMOUNT_UP: 'pi pi-sort-amount-up',
|
|
SORT_AMOUNT_UP_ALT: 'pi pi-sort-amount-up-alt',
|
|
SORT_DOWN: 'pi pi-sort-down',
|
|
SORT_NUMERIC_DOWN: 'pi pi-sort-numeric-down',
|
|
SORT_NUMERIC_ALT_DOWN: 'pi pi-sort-numeric-alt-down',
|
|
SORT_NUMERIC_UP: 'pi pi-sort-numeric-up',
|
|
SORT_NUMERIC_ALT_UP: 'pi pi-sort-numeric-alt-up',
|
|
SORT_UP: 'pi pi-sort-up',
|
|
SPINNER: 'pi pi-spinner',
|
|
STAR: 'pi pi-star',
|
|
STAR_FILL: 'pi pi-star-fill',
|
|
STEP_BACKWARD: 'pi pi-step-backward',
|
|
STEP_BACKWARD_ALT: 'pi pi-step-backward-alt',
|
|
STEP_FORWARD: 'pi pi-step-forward',
|
|
STEP_FORWARD_ALT: 'pi pi-step-forward-alt',
|
|
STOP: 'pi pi-stop',
|
|
STOP_CIRCLE: 'pi pi-stop-circle',
|
|
SUN: 'pi pi-sun',
|
|
SYNC: 'pi pi-sync',
|
|
TABLE: 'pi pi-table',
|
|
TABLET: 'pi pi-tablet',
|
|
TAG: 'pi pi-tag',
|
|
TAGS: 'pi pi-tags',
|
|
TELEGRAM: 'pi pi-telegram',
|
|
TH_LARGE: 'pi pi-th-large',
|
|
THUMBS_DOWN: 'pi pi-thumbs-down',
|
|
THUMBS_UP: 'pi pi-thumbs-up',
|
|
TICKET: 'pi pi-ticket',
|
|
TIMES: 'pi pi-times',
|
|
TIMES_CIRCLE: 'pi pi-times-circle',
|
|
TRASH: 'pi pi-trash',
|
|
TWITTER: 'pi pi-twitter',
|
|
UNDO: 'pi pi-undo',
|
|
UNLOCK: 'pi pi-unlock',
|
|
UPLOAD: 'pi pi-upload',
|
|
USER: 'pi pi-user',
|
|
USER_EDIT: 'pi pi-user-edit',
|
|
USER_MINUS: 'pi pi-user-minus',
|
|
USER_PLUS: 'pi pi-user-plus',
|
|
USERS: 'pi pi-users',
|
|
VIDEO: 'pi pi-video',
|
|
VIMEO: 'pi pi-vimeo',
|
|
VOLUME_DOWN: 'pi pi-volume-down',
|
|
VOLUME_OFF: 'pi pi-volume-off',
|
|
VOLUME_UP: 'pi pi-volume-up',
|
|
WALLET: 'pi pi-wallet',
|
|
WHATSAPP: 'pi pi-whatsapp',
|
|
WIFI: 'pi pi-wifi',
|
|
WINDOW_MAXIMIZE: 'pi pi-window-maximize',
|
|
WINDOW_MINIMIZE: 'pi pi-window-minimize',
|
|
YOUTUBE: 'pi pi-youtube'
|
|
});
|
|
|
|
var MessageSeverity = Object.freeze({
|
|
SUCCESS: 'success',
|
|
INFO: 'info',
|
|
WARN: 'warn',
|
|
ERROR: 'error'
|
|
});
|
|
|
|
var FilterOperator = Object.freeze({
|
|
AND: 'and',
|
|
OR: 'or'
|
|
});
|
|
|
|
function _createForOfIteratorHelper$h(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$h(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$h(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$h(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$h(o, minLen); }
|
|
|
|
function _arrayLikeToArray$h(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 FilterService = {
|
|
filter: function filter(value, fields, filterValue, filterMatchMode, filterLocale) {
|
|
var filteredItems = [];
|
|
|
|
if (value) {
|
|
var _iterator = _createForOfIteratorHelper$h(value),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var item = _step.value;
|
|
|
|
var _iterator2 = _createForOfIteratorHelper$h(fields),
|
|
_step2;
|
|
|
|
try {
|
|
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
|
|
var field = _step2.value;
|
|
var fieldValue = ObjectUtils.resolveFieldData(item, field);
|
|
|
|
if (this.filters[filterMatchMode](fieldValue, filterValue, filterLocale)) {
|
|
filteredItems.push(item);
|
|
break;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator2.e(err);
|
|
} finally {
|
|
_iterator2.f();
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
}
|
|
|
|
return filteredItems;
|
|
},
|
|
filters: {
|
|
startsWith: function startsWith(value, filter, filterLocale) {
|
|
if (filter === undefined || filter === null || filter.trim() === '') {
|
|
return true;
|
|
}
|
|
|
|
if (value === undefined || value === null) {
|
|
return false;
|
|
}
|
|
|
|
var filterValue = ObjectUtils.removeAccents(filter.toString()).toLocaleLowerCase(filterLocale);
|
|
var stringValue = ObjectUtils.removeAccents(value.toString()).toLocaleLowerCase(filterLocale);
|
|
return stringValue.slice(0, filterValue.length) === filterValue;
|
|
},
|
|
contains: function contains(value, filter, filterLocale) {
|
|
if (filter === undefined || filter === null || typeof filter === 'string' && filter.trim() === '') {
|
|
return true;
|
|
}
|
|
|
|
if (value === undefined || value === null) {
|
|
return false;
|
|
}
|
|
|
|
var filterValue = ObjectUtils.removeAccents(filter.toString()).toLocaleLowerCase(filterLocale);
|
|
var stringValue = ObjectUtils.removeAccents(value.toString()).toLocaleLowerCase(filterLocale);
|
|
return stringValue.indexOf(filterValue) !== -1;
|
|
},
|
|
notContains: function notContains(value, filter, filterLocale) {
|
|
if (filter === undefined || filter === null || typeof filter === 'string' && filter.trim() === '') {
|
|
return true;
|
|
}
|
|
|
|
if (value === undefined || value === null) {
|
|
return false;
|
|
}
|
|
|
|
var filterValue = ObjectUtils.removeAccents(filter.toString()).toLocaleLowerCase(filterLocale);
|
|
var stringValue = ObjectUtils.removeAccents(value.toString()).toLocaleLowerCase(filterLocale);
|
|
return stringValue.indexOf(filterValue) === -1;
|
|
},
|
|
endsWith: function endsWith(value, filter, filterLocale) {
|
|
if (filter === undefined || filter === null || filter.trim() === '') {
|
|
return true;
|
|
}
|
|
|
|
if (value === undefined || value === null) {
|
|
return false;
|
|
}
|
|
|
|
var filterValue = ObjectUtils.removeAccents(filter.toString()).toLocaleLowerCase(filterLocale);
|
|
var stringValue = ObjectUtils.removeAccents(value.toString()).toLocaleLowerCase(filterLocale);
|
|
return stringValue.indexOf(filterValue, stringValue.length - filterValue.length) !== -1;
|
|
},
|
|
equals: function equals(value, filter, filterLocale) {
|
|
if (filter === undefined || filter === null || typeof filter === 'string' && filter.trim() === '') {
|
|
return true;
|
|
}
|
|
|
|
if (value === undefined || value === null) {
|
|
return false;
|
|
}
|
|
|
|
if (value.getTime && filter.getTime) return value.getTime() === filter.getTime();else return ObjectUtils.removeAccents(value.toString()).toLocaleLowerCase(filterLocale) === ObjectUtils.removeAccents(filter.toString()).toLocaleLowerCase(filterLocale);
|
|
},
|
|
notEquals: function notEquals(value, filter, filterLocale) {
|
|
if (filter === undefined || filter === null || typeof filter === 'string' && filter.trim() === '') {
|
|
return false;
|
|
}
|
|
|
|
if (value === undefined || value === null) {
|
|
return true;
|
|
}
|
|
|
|
if (value.getTime && filter.getTime) return value.getTime() !== filter.getTime();else return ObjectUtils.removeAccents(value.toString()).toLocaleLowerCase(filterLocale) !== ObjectUtils.removeAccents(filter.toString()).toLocaleLowerCase(filterLocale);
|
|
},
|
|
"in": function _in(value, filter) {
|
|
if (filter === undefined || filter === null || filter.length === 0) {
|
|
return true;
|
|
}
|
|
|
|
for (var i = 0; i < filter.length; i++) {
|
|
if (ObjectUtils.equals(value, filter[i])) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
},
|
|
between: function between(value, filter) {
|
|
if (filter == null || filter[0] == null || filter[1] == null) {
|
|
return true;
|
|
}
|
|
|
|
if (value === undefined || value === null) {
|
|
return false;
|
|
}
|
|
|
|
if (value.getTime) return filter[0].getTime() <= value.getTime() && value.getTime() <= filter[1].getTime();else return filter[0] <= value && value <= filter[1];
|
|
},
|
|
lt: function lt(value, filter) {
|
|
if (filter === undefined || filter === null) {
|
|
return true;
|
|
}
|
|
|
|
if (value === undefined || value === null) {
|
|
return false;
|
|
}
|
|
|
|
if (value.getTime && filter.getTime) return value.getTime() < filter.getTime();else return value < filter;
|
|
},
|
|
lte: function lte(value, filter) {
|
|
if (filter === undefined || filter === null) {
|
|
return true;
|
|
}
|
|
|
|
if (value === undefined || value === null) {
|
|
return false;
|
|
}
|
|
|
|
if (value.getTime && filter.getTime) return value.getTime() <= filter.getTime();else return value <= filter;
|
|
},
|
|
gt: function gt(value, filter) {
|
|
if (filter === undefined || filter === null) {
|
|
return true;
|
|
}
|
|
|
|
if (value === undefined || value === null) {
|
|
return false;
|
|
}
|
|
|
|
if (value.getTime && filter.getTime) return value.getTime() > filter.getTime();else return value > filter;
|
|
},
|
|
gte: function gte(value, filter) {
|
|
if (filter === undefined || filter === null) {
|
|
return true;
|
|
}
|
|
|
|
if (value === undefined || value === null) {
|
|
return false;
|
|
}
|
|
|
|
if (value.getTime && filter.getTime) return value.getTime() >= filter.getTime();else return value >= filter;
|
|
},
|
|
dateIs: function dateIs(value, filter) {
|
|
if (filter === undefined || filter === null) {
|
|
return true;
|
|
}
|
|
|
|
if (value === undefined || value === null) {
|
|
return false;
|
|
}
|
|
|
|
return value.toDateString() === filter.toDateString();
|
|
},
|
|
dateIsNot: function dateIsNot(value, filter) {
|
|
if (filter === undefined || filter === null) {
|
|
return true;
|
|
}
|
|
|
|
if (value === undefined || value === null) {
|
|
return false;
|
|
}
|
|
|
|
return value.toDateString() !== filter.toDateString();
|
|
},
|
|
dateBefore: function dateBefore(value, filter) {
|
|
if (filter === undefined || filter === null) {
|
|
return true;
|
|
}
|
|
|
|
if (value === undefined || value === null) {
|
|
return false;
|
|
}
|
|
|
|
return value.getTime() < filter.getTime();
|
|
},
|
|
dateAfter: function dateAfter(value, filter) {
|
|
if (filter === undefined || filter === null) {
|
|
return true;
|
|
}
|
|
|
|
if (value === undefined || value === null) {
|
|
return false;
|
|
}
|
|
|
|
return value.getTime() > filter.getTime();
|
|
}
|
|
},
|
|
register: function register(rule, fn) {
|
|
this.filters[rule] = fn;
|
|
}
|
|
};
|
|
|
|
function ownKeys$S(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$S(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$S(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$S(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$2l(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$2l(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$2l() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var CSSTransition = /*#__PURE__*/function (_Component) {
|
|
_inherits(CSSTransition, _Component);
|
|
|
|
var _super = _createSuper$2l(CSSTransition);
|
|
|
|
function CSSTransition(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, CSSTransition);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onEnter = _this.onEnter.bind(_assertThisInitialized(_this));
|
|
_this.onEntering = _this.onEntering.bind(_assertThisInitialized(_this));
|
|
_this.onEntered = _this.onEntered.bind(_assertThisInitialized(_this));
|
|
_this.onExit = _this.onExit.bind(_assertThisInitialized(_this));
|
|
_this.onExiting = _this.onExiting.bind(_assertThisInitialized(_this));
|
|
_this.onExited = _this.onExited.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(CSSTransition, [{
|
|
key: "disabled",
|
|
get: function get() {
|
|
return this.props.disabled || this.props.options && this.props.options.disabled || !PrimeReact.cssTransition;
|
|
}
|
|
}, {
|
|
key: "onEnter",
|
|
value: function onEnter(node, isAppearing) {
|
|
this.props.onEnter && this.props.onEnter(node, isAppearing); // component
|
|
|
|
this.props.options && this.props.options.onEnter && this.props.options.onEnter(node, isAppearing); // user option
|
|
}
|
|
}, {
|
|
key: "onEntering",
|
|
value: function onEntering(node, isAppearing) {
|
|
this.props.onEntering && this.props.onEntering(node, isAppearing); // component
|
|
|
|
this.props.options && this.props.options.onEntering && this.props.options.onEntering(node, isAppearing); // user option
|
|
}
|
|
}, {
|
|
key: "onEntered",
|
|
value: function onEntered(node, isAppearing) {
|
|
this.props.onEntered && this.props.onEntered(node, isAppearing); // component
|
|
|
|
this.props.options && this.props.options.onEntered && this.props.options.onEntered(node, isAppearing); // user option
|
|
}
|
|
}, {
|
|
key: "onExit",
|
|
value: function onExit(node) {
|
|
this.props.onExit && this.props.onExit(node); // component
|
|
|
|
this.props.options && this.props.options.onExit && this.props.options.onExit(node); // user option
|
|
}
|
|
}, {
|
|
key: "onExiting",
|
|
value: function onExiting(node) {
|
|
this.props.onExiting && this.props.onExiting(node); // component
|
|
|
|
this.props.options && this.props.options.onExiting && this.props.options.onExiting(node); // user option
|
|
}
|
|
}, {
|
|
key: "onExited",
|
|
value: function onExited(node) {
|
|
this.props.onExited && this.props.onExited(node); // component
|
|
|
|
this.props.options && this.props.options.onExited && this.props.options.onExited(node); // user option
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (this.props["in"] !== prevProps["in"] && this.disabled) {
|
|
// no animation
|
|
var node = ObjectUtils.getRefElement(this.props.nodeRef);
|
|
|
|
if (this.props["in"]) {
|
|
this.onEnter(node, true);
|
|
this.onEntering(node, true);
|
|
this.onEntered(node, true);
|
|
} else {
|
|
this.onExit(node);
|
|
this.onExiting(node);
|
|
this.onExited(node);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
if (this.disabled) {
|
|
return this.props["in"] ? this.props.children : null;
|
|
} else {
|
|
var immutableProps = {
|
|
nodeRef: this.props.nodeRef,
|
|
"in": this.props["in"],
|
|
onEnter: this.onEnter,
|
|
onEntering: this.onEntering,
|
|
onEntered: this.onEntered,
|
|
onExit: this.onExit,
|
|
onExiting: this.onExiting,
|
|
onExited: this.onExited
|
|
};
|
|
var mutableProps = {
|
|
classNames: this.props.classNames,
|
|
timeout: this.props.timeout,
|
|
unmountOnExit: this.props.unmountOnExit
|
|
};
|
|
|
|
var props = _objectSpread$S(_objectSpread$S(_objectSpread$S({}, mutableProps), this.props.options || {}), immutableProps);
|
|
|
|
return /*#__PURE__*/React.createElement(CSSTransition$1, props, this.props.children);
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return CSSTransition;
|
|
}(Component);
|
|
|
|
function ownKeys$R(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$R(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$R(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$R(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$2k(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$2k(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$2k() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var AccordionTab = /*#__PURE__*/function (_Component) {
|
|
_inherits(AccordionTab, _Component);
|
|
|
|
var _super = _createSuper$2k(AccordionTab);
|
|
|
|
function AccordionTab() {
|
|
_classCallCheck(this, AccordionTab);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
return _createClass(AccordionTab);
|
|
}(Component);
|
|
|
|
_defineProperty(AccordionTab, "defaultProps", {
|
|
header: null,
|
|
disabled: false,
|
|
style: null,
|
|
className: null,
|
|
headerStyle: null,
|
|
headerClassName: null,
|
|
headerTemplate: null,
|
|
contentStyle: null,
|
|
contentClassName: null
|
|
});
|
|
|
|
var Accordion = /*#__PURE__*/function (_Component2) {
|
|
_inherits(Accordion, _Component2);
|
|
|
|
var _super2 = _createSuper$2k(Accordion);
|
|
|
|
function Accordion(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Accordion);
|
|
|
|
_this = _super2.call(this, props);
|
|
var state = {
|
|
id: _this.props.id
|
|
};
|
|
|
|
if (!_this.props.onTabChange) {
|
|
state = _objectSpread$R(_objectSpread$R({}, state), {}, {
|
|
activeIndex: props.activeIndex
|
|
});
|
|
}
|
|
|
|
_this.state = state;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Accordion, [{
|
|
key: "shouldTabRender",
|
|
value: function shouldTabRender(tab) {
|
|
return tab && tab.type === AccordionTab;
|
|
}
|
|
}, {
|
|
key: "onTabHeaderClick",
|
|
value: function onTabHeaderClick(event, tab, index) {
|
|
if (!tab.props.disabled) {
|
|
var selected = this.isSelected(index);
|
|
var newActiveIndex = null;
|
|
|
|
if (this.props.multiple) {
|
|
var indexes = (this.props.onTabChange ? this.props.activeIndex : this.state.activeIndex) || [];
|
|
if (selected) indexes = indexes.filter(function (i) {
|
|
return i !== index;
|
|
});else indexes = [].concat(_toConsumableArray(indexes), [index]);
|
|
newActiveIndex = indexes;
|
|
} else {
|
|
newActiveIndex = selected ? null : index;
|
|
}
|
|
|
|
var callback = selected ? this.props.onTabClose : this.props.onTabOpen;
|
|
|
|
if (callback) {
|
|
callback({
|
|
originalEvent: event,
|
|
index: index
|
|
});
|
|
}
|
|
|
|
if (this.props.onTabChange) {
|
|
this.props.onTabChange({
|
|
originalEvent: event,
|
|
index: newActiveIndex
|
|
});
|
|
} else {
|
|
this.setState({
|
|
activeIndex: newActiveIndex
|
|
});
|
|
}
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "isSelected",
|
|
value: function isSelected(index) {
|
|
var activeIndex = this.props.onTabChange ? this.props.activeIndex : this.state.activeIndex;
|
|
return this.props.multiple ? activeIndex && activeIndex.indexOf(index) >= 0 : activeIndex === index;
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (!this.state.id) {
|
|
this.setState({
|
|
id: UniqueComponentId()
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderTabHeader",
|
|
value: function renderTabHeader(tab, selected, index) {
|
|
var _this2 = this;
|
|
|
|
var style = _objectSpread$R(_objectSpread$R({}, tab.props.headerStyle || {}), tab.props.style || {});
|
|
|
|
var className = classNames('p-accordion-header', {
|
|
'p-highlight': selected,
|
|
'p-disabled': tab.props.disabled
|
|
}, tab.props.headerClassName, tab.props.className);
|
|
var id = this.state.id + '_header_' + index;
|
|
var ariaControls = this.state.id + '_content_' + index;
|
|
var tabIndex = tab.props.disabled ? -1 : null;
|
|
var header = tab.props.headerTemplate ? ObjectUtils.getJSXElement(tab.props.headerTemplate, tab.props) : /*#__PURE__*/React.createElement("span", {
|
|
className: "p-accordion-header-text"
|
|
}, tab.props.header);
|
|
var icon = selected ? this.props.collapseIcon : this.props.expandIcon;
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: className,
|
|
style: style
|
|
}, /*#__PURE__*/React.createElement("a", {
|
|
href: '#' + ariaControls,
|
|
id: id,
|
|
className: "p-accordion-header-link",
|
|
"aria-controls": ariaControls,
|
|
role: "tab",
|
|
"aria-expanded": selected,
|
|
onClick: function onClick(event) {
|
|
return _this2.onTabHeaderClick(event, tab, index);
|
|
},
|
|
tabIndex: tabIndex
|
|
}, IconUtils.getJSXIcon(icon, {
|
|
className: 'p-accordion-toggle-icon'
|
|
}, {
|
|
props: this.props,
|
|
selected: selected
|
|
}), header));
|
|
}
|
|
}, {
|
|
key: "renderTabContent",
|
|
value: function renderTabContent(tab, selected, index) {
|
|
var style = _objectSpread$R(_objectSpread$R({}, tab.props.contentStyle || {}), tab.props.style || {});
|
|
|
|
var className = classNames('p-toggleable-content', tab.props.contentClassName, tab.props.className);
|
|
var id = this.state.id + '_content_' + index;
|
|
var toggleableContentRef = /*#__PURE__*/React.createRef();
|
|
return /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: toggleableContentRef,
|
|
classNames: "p-toggleable-content",
|
|
timeout: {
|
|
enter: 1000,
|
|
exit: 450
|
|
},
|
|
"in": selected,
|
|
unmountOnExit: true,
|
|
options: this.props.transitionOptions
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: toggleableContentRef,
|
|
id: id,
|
|
className: className,
|
|
style: style,
|
|
role: "region",
|
|
"aria-labelledby": this.state.id + '_header_' + index
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-accordion-content"
|
|
}, tab.props.children)));
|
|
}
|
|
}, {
|
|
key: "renderTab",
|
|
value: function renderTab(tab, index) {
|
|
var selected = this.isSelected(index);
|
|
var tabHeader = this.renderTabHeader(tab, selected, index);
|
|
var tabContent = this.renderTabContent(tab, selected, index);
|
|
var tabClassName = classNames('p-accordion-tab', {
|
|
'p-accordion-tab-active': selected
|
|
});
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
key: tab.props.header,
|
|
className: tabClassName
|
|
}, tabHeader, tabContent);
|
|
}
|
|
}, {
|
|
key: "renderTabs",
|
|
value: function renderTabs() {
|
|
var _this3 = this;
|
|
|
|
return React.Children.map(this.props.children, function (tab, index) {
|
|
if (_this3.shouldTabRender(tab)) {
|
|
return _this3.renderTab(tab, index);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this4 = this;
|
|
|
|
var className = classNames('p-accordion p-component', this.props.className);
|
|
var tabs = this.renderTabs();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this4.container = el;
|
|
},
|
|
id: this.state.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, tabs);
|
|
}
|
|
}]);
|
|
|
|
return Accordion;
|
|
}(Component);
|
|
|
|
_defineProperty(Accordion, "defaultProps", {
|
|
id: null,
|
|
activeIndex: null,
|
|
className: null,
|
|
style: null,
|
|
multiple: false,
|
|
expandIcon: 'pi pi-chevron-right',
|
|
collapseIcon: 'pi pi-chevron-down',
|
|
transitionOptions: null,
|
|
onTabOpen: null,
|
|
onTabClose: null,
|
|
onTabChange: null
|
|
});
|
|
|
|
var KeyFilter = /*#__PURE__*/function () {
|
|
function KeyFilter() {
|
|
_classCallCheck(this, KeyFilter);
|
|
}
|
|
|
|
_createClass(KeyFilter, null, [{
|
|
key: "isNavKeyPress",
|
|
value:
|
|
/* eslint-disable */
|
|
|
|
/* eslint-enable */
|
|
function isNavKeyPress(e) {
|
|
var k = e.keyCode;
|
|
k = DomHandler.getBrowser().safari ? KeyFilter.SAFARI_KEYS[k] || k : k;
|
|
return k >= 33 && k <= 40 || k === KeyFilter.KEYS.RETURN || k === KeyFilter.KEYS.TAB || k === KeyFilter.KEYS.ESC;
|
|
}
|
|
}, {
|
|
key: "isSpecialKey",
|
|
value: function isSpecialKey(e) {
|
|
var k = e.keyCode;
|
|
return k === 9 || k === 13 || k === 27 || k === 16 || k === 17 || k >= 18 && k <= 20 || DomHandler.getBrowser().opera && !e.shiftKey && (k === 8 || k >= 33 && k <= 35 || k >= 36 && k <= 39 || k >= 44 && k <= 45);
|
|
}
|
|
}, {
|
|
key: "getKey",
|
|
value: function getKey(e) {
|
|
var k = e.keyCode || e.charCode;
|
|
return DomHandler.getBrowser().safari ? KeyFilter.SAFARI_KEYS[k] || k : k;
|
|
}
|
|
}, {
|
|
key: "getCharCode",
|
|
value: function getCharCode(e) {
|
|
return e.charCode || e.keyCode || e.which;
|
|
}
|
|
}, {
|
|
key: "onKeyPress",
|
|
value: function onKeyPress(e, keyfilter, validateOnly) {
|
|
if (validateOnly) {
|
|
return;
|
|
}
|
|
|
|
var regex = KeyFilter.DEFAULT_MASKS[keyfilter] ? KeyFilter.DEFAULT_MASKS[keyfilter] : keyfilter;
|
|
var browser = DomHandler.getBrowser();
|
|
|
|
if (e.ctrlKey || e.altKey) {
|
|
return;
|
|
}
|
|
|
|
var k = this.getKey(e);
|
|
|
|
if (browser.mozilla && (this.isNavKeyPress(e) || k === KeyFilter.KEYS.BACKSPACE || k === KeyFilter.KEYS.DELETE && e.charCode === 0)) {
|
|
return;
|
|
}
|
|
|
|
var c = this.getCharCode(e);
|
|
var cc = String.fromCharCode(c);
|
|
|
|
if (browser.mozilla && (this.isSpecialKey(e) || !cc)) {
|
|
return;
|
|
}
|
|
|
|
if (!regex.test(cc)) {
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "validate",
|
|
value: function validate(e, keyfilter) {
|
|
var value = e.target.value,
|
|
validatePattern = true;
|
|
|
|
if (value && !keyfilter.test(value)) {
|
|
validatePattern = false;
|
|
}
|
|
|
|
return validatePattern;
|
|
}
|
|
}]);
|
|
|
|
return KeyFilter;
|
|
}();
|
|
|
|
_defineProperty(KeyFilter, "DEFAULT_MASKS", {
|
|
pint: /[\d]/,
|
|
"int": /[\d\-]/,
|
|
pnum: /[\d\.]/,
|
|
money: /[\d\.\s,]/,
|
|
num: /[\d\-\.]/,
|
|
hex: /[0-9a-f]/i,
|
|
email: /[a-z0-9_\.\-@]/i,
|
|
alpha: /[a-z_]/i,
|
|
alphanum: /[a-z0-9_]/i
|
|
});
|
|
|
|
_defineProperty(KeyFilter, "KEYS", {
|
|
TAB: 9,
|
|
RETURN: 13,
|
|
ESC: 27,
|
|
BACKSPACE: 8,
|
|
DELETE: 46
|
|
});
|
|
|
|
_defineProperty(KeyFilter, "SAFARI_KEYS", {
|
|
63234: 37,
|
|
// left
|
|
63235: 39,
|
|
// right
|
|
63232: 38,
|
|
// up
|
|
63233: 40,
|
|
// down
|
|
63276: 33,
|
|
// page up
|
|
63277: 34,
|
|
// page down
|
|
63272: 46,
|
|
// delete
|
|
63273: 36,
|
|
// home
|
|
63275: 35 // end
|
|
|
|
});
|
|
|
|
function _createSuper$2j(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$2j(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$2j() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Portal = /*#__PURE__*/function (_Component) {
|
|
_inherits(Portal, _Component);
|
|
|
|
var _super = _createSuper$2j(Portal);
|
|
|
|
function Portal(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Portal);
|
|
|
|
_this = _super.call(this, props);
|
|
var mounted = props.visible && DomHandler.hasDOM();
|
|
_this.state = {
|
|
mounted: mounted
|
|
};
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Portal, [{
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (DomHandler.hasDOM() && !this.state.mounted) {
|
|
this.setState({
|
|
mounted: true
|
|
}, this.props.onMounted);
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.props.onUnmounted && this.props.onUnmounted();
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var element = this.props.element || this.props.children;
|
|
|
|
if (element && this.state.mounted) {
|
|
var appendTo = this.props.appendTo || PrimeReact.appendTo || document.body;
|
|
return appendTo === 'self' ? element : /*#__PURE__*/ReactDOM.createPortal(element, appendTo);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}]);
|
|
|
|
return Portal;
|
|
}(Component);
|
|
|
|
_defineProperty(Portal, "defaultProps", {
|
|
element: null,
|
|
appendTo: null,
|
|
visible: false,
|
|
onMounted: null,
|
|
onUnmounted: null
|
|
});
|
|
|
|
function _createSuper$2i(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$2i(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$2i() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function ownKeys$Q(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$Q(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$Q(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$Q(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
function tip(props) {
|
|
var appendTo = props.appendTo || document.body;
|
|
var tooltipWrapper = document.createDocumentFragment();
|
|
DomHandler.appendChild(tooltipWrapper, appendTo);
|
|
props = _objectSpread$Q(_objectSpread$Q({}, props), props.options);
|
|
var tooltipEl = /*#__PURE__*/React.createElement(Tooltip, props);
|
|
ReactDOM.render(tooltipEl, tooltipWrapper);
|
|
|
|
var updateTooltip = function updateTooltip(newProps) {
|
|
props = _objectSpread$Q(_objectSpread$Q({}, props), newProps);
|
|
ReactDOM.render( /*#__PURE__*/React.cloneElement(tooltipEl, props), tooltipWrapper);
|
|
};
|
|
|
|
return {
|
|
destroy: function destroy() {
|
|
ReactDOM.unmountComponentAtNode(tooltipWrapper);
|
|
},
|
|
updateContent: function updateContent(newContent) {
|
|
console.warn("The 'updateContent' method has been deprecated on Tooltip. Use update(newProps) method.");
|
|
updateTooltip({
|
|
content: newContent
|
|
});
|
|
},
|
|
update: function update(newProps) {
|
|
updateTooltip(newProps);
|
|
}
|
|
};
|
|
}
|
|
var Tooltip = /*#__PURE__*/function (_Component) {
|
|
_inherits(Tooltip, _Component);
|
|
|
|
var _super = _createSuper$2i(Tooltip);
|
|
|
|
function Tooltip(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Tooltip);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
visible: false,
|
|
position: _this.props.position
|
|
};
|
|
_this.show = _this.show.bind(_assertThisInitialized(_this));
|
|
_this.hide = _this.hide.bind(_assertThisInitialized(_this));
|
|
_this.onMouseEnter = _this.onMouseEnter.bind(_assertThisInitialized(_this));
|
|
_this.onMouseLeave = _this.onMouseLeave.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Tooltip, [{
|
|
key: "isTargetContentEmpty",
|
|
value: function isTargetContentEmpty(target) {
|
|
return !(this.props.content || this.getTargetOption(target, 'tooltip'));
|
|
}
|
|
}, {
|
|
key: "isContentEmpty",
|
|
value: function isContentEmpty(target) {
|
|
return !(this.props.content || this.getTargetOption(target, 'tooltip') || this.props.children);
|
|
}
|
|
}, {
|
|
key: "isMouseTrack",
|
|
value: function isMouseTrack(target) {
|
|
return this.getTargetOption(target, 'mousetrack') || this.props.mouseTrack;
|
|
}
|
|
}, {
|
|
key: "isDisabled",
|
|
value: function isDisabled(target) {
|
|
return this.getTargetOption(target, 'disabled') === 'true' || this.hasTargetOption(target, 'disabled') || this.props.disabled;
|
|
}
|
|
}, {
|
|
key: "isShowOnDisabled",
|
|
value: function isShowOnDisabled(target) {
|
|
return this.getTargetOption(target, 'showondisabled') || this.props.showOnDisabled;
|
|
}
|
|
}, {
|
|
key: "isAutoHide",
|
|
value: function isAutoHide() {
|
|
return this.getTargetOption(this.currentTarget, 'autohide') || this.props.autoHide;
|
|
}
|
|
}, {
|
|
key: "getTargetOption",
|
|
value: function getTargetOption(target, option) {
|
|
if (this.hasTargetOption(target, "data-pr-".concat(option))) {
|
|
return target.getAttribute("data-pr-".concat(option));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "hasTargetOption",
|
|
value: function hasTargetOption(target, option) {
|
|
return target && target.hasAttribute(option);
|
|
}
|
|
}, {
|
|
key: "getEvents",
|
|
value: function getEvents(target) {
|
|
var showEvent = this.getTargetOption(target, 'showevent') || this.props.showEvent;
|
|
var hideEvent = this.getTargetOption(target, 'hideevent') || this.props.hideEvent;
|
|
|
|
if (this.isMouseTrack(target)) {
|
|
showEvent = 'mousemove';
|
|
hideEvent = 'mouseleave';
|
|
} else {
|
|
var event = this.getTargetOption(target, 'event') || this.props.event;
|
|
|
|
if (event === 'focus') {
|
|
showEvent = 'focus';
|
|
hideEvent = 'blur';
|
|
}
|
|
}
|
|
|
|
return {
|
|
showEvent: showEvent,
|
|
hideEvent: hideEvent
|
|
};
|
|
}
|
|
}, {
|
|
key: "getPosition",
|
|
value: function getPosition(target) {
|
|
return this.getTargetOption(target, 'position') || this.state.position;
|
|
}
|
|
}, {
|
|
key: "getMouseTrackPosition",
|
|
value: function getMouseTrackPosition(target) {
|
|
var top = this.getTargetOption(target, 'mousetracktop') || this.props.mouseTrackTop;
|
|
var left = this.getTargetOption(target, 'mousetrackleft') || this.props.mouseTrackLeft;
|
|
return {
|
|
top: top,
|
|
left: left
|
|
};
|
|
}
|
|
}, {
|
|
key: "updateText",
|
|
value: function updateText(target, callback) {
|
|
if (this.tooltipTextEl) {
|
|
var content = this.getTargetOption(target, 'tooltip') || this.props.content;
|
|
|
|
if (content) {
|
|
this.tooltipTextEl.innerHTML = ''; // remove children
|
|
|
|
this.tooltipTextEl.appendChild(document.createTextNode(content));
|
|
callback();
|
|
} else if (this.props.children) {
|
|
callback();
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "show",
|
|
value: function show(e) {
|
|
var _this2 = this;
|
|
|
|
this.currentTarget = e.currentTarget;
|
|
var disabled = this.isDisabled(this.currentTarget);
|
|
var empty = this.isContentEmpty(this.isShowOnDisabled(this.currentTarget) && disabled ? this.currentTarget.firstChild : this.currentTarget);
|
|
|
|
if (empty || disabled) {
|
|
return;
|
|
}
|
|
|
|
var updateTooltipState = function updateTooltipState() {
|
|
_this2.updateText(_this2.currentTarget, function () {
|
|
if (_this2.props.autoZIndex && !ZIndexUtils.get(_this2.containerEl)) {
|
|
ZIndexUtils.set('tooltip', _this2.containerEl, PrimeReact.autoZIndex, _this2.props.baseZIndex || PrimeReact.zIndex['tooltip']);
|
|
}
|
|
|
|
_this2.containerEl.style.left = '';
|
|
_this2.containerEl.style.top = '';
|
|
|
|
if (_this2.isMouseTrack(_this2.currentTarget) && !_this2.containerSize) {
|
|
_this2.containerSize = {
|
|
width: DomHandler.getOuterWidth(_this2.containerEl),
|
|
height: DomHandler.getOuterHeight(_this2.containerEl)
|
|
};
|
|
}
|
|
|
|
_this2.align(_this2.currentTarget, {
|
|
x: e.pageX,
|
|
y: e.pageY
|
|
});
|
|
});
|
|
};
|
|
|
|
if (this.state.visible) {
|
|
this.applyDelay('updateDelay', updateTooltipState);
|
|
} else {
|
|
this.sendCallback(this.props.onBeforeShow, {
|
|
originalEvent: e,
|
|
target: this.currentTarget
|
|
});
|
|
this.applyDelay('showDelay', function () {
|
|
_this2.setState({
|
|
visible: true,
|
|
position: _this2.getPosition(_this2.currentTarget)
|
|
}, function () {
|
|
updateTooltipState();
|
|
|
|
_this2.sendCallback(_this2.props.onShow, {
|
|
originalEvent: e,
|
|
target: _this2.currentTarget
|
|
});
|
|
});
|
|
|
|
_this2.bindDocumentResizeListener();
|
|
|
|
_this2.bindScrollListener();
|
|
|
|
DomHandler.addClass(_this2.currentTarget, _this2.getTargetOption(_this2.currentTarget, 'classname'));
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "hide",
|
|
value: function hide(e) {
|
|
var _this3 = this;
|
|
|
|
this.clearTimeouts();
|
|
|
|
if (this.state.visible) {
|
|
DomHandler.removeClass(this.currentTarget, this.getTargetOption(this.currentTarget, 'classname'));
|
|
this.sendCallback(this.props.onBeforeHide, {
|
|
originalEvent: e,
|
|
target: this.currentTarget
|
|
});
|
|
this.applyDelay('hideDelay', function () {
|
|
ZIndexUtils.clear(_this3.containerEl);
|
|
DomHandler.removeClass(_this3.containerEl, 'p-tooltip-active');
|
|
|
|
if (!_this3.isAutoHide() && _this3.allowHide === false) {
|
|
return;
|
|
}
|
|
|
|
_this3.setState({
|
|
visible: false,
|
|
position: _this3.props.position
|
|
}, function () {
|
|
if (_this3.tooltipTextEl) {
|
|
ReactDOM.unmountComponentAtNode(_this3.tooltipTextEl);
|
|
}
|
|
|
|
_this3.unbindDocumentResizeListener();
|
|
|
|
_this3.unbindScrollListener();
|
|
|
|
_this3.currentTarget = null;
|
|
_this3.scrollHandler = null;
|
|
_this3.containerSize = null;
|
|
_this3.allowHide = true;
|
|
|
|
_this3.sendCallback(_this3.props.onHide, {
|
|
originalEvent: e,
|
|
target: _this3.currentTarget
|
|
});
|
|
});
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "align",
|
|
value: function align(target, coordinate) {
|
|
var _this4 = this;
|
|
|
|
var left = 0,
|
|
top = 0;
|
|
|
|
if (this.isMouseTrack(target) && coordinate) {
|
|
var containerSize = {
|
|
width: DomHandler.getOuterWidth(this.containerEl),
|
|
height: DomHandler.getOuterHeight(this.containerEl)
|
|
};
|
|
left = coordinate.x;
|
|
top = coordinate.y;
|
|
|
|
var _this$getMouseTrackPo = this.getMouseTrackPosition(target),
|
|
mouseTrackTop = _this$getMouseTrackPo.top,
|
|
mouseTrackLeft = _this$getMouseTrackPo.left;
|
|
|
|
switch (this.state.position) {
|
|
case 'left':
|
|
left -= containerSize.width + mouseTrackLeft;
|
|
top -= containerSize.height / 2 - mouseTrackTop;
|
|
break;
|
|
|
|
case 'right':
|
|
left += mouseTrackLeft;
|
|
top -= containerSize.height / 2 - mouseTrackTop;
|
|
break;
|
|
|
|
case 'top':
|
|
left -= containerSize.width / 2 - mouseTrackLeft;
|
|
top -= containerSize.height + mouseTrackTop;
|
|
break;
|
|
|
|
case 'bottom':
|
|
left -= containerSize.width / 2 - mouseTrackLeft;
|
|
top += mouseTrackTop;
|
|
break;
|
|
}
|
|
|
|
if (left <= 0 || this.containerSize.width > containerSize.width) {
|
|
this.containerEl.style.left = '0px';
|
|
this.containerEl.style.right = window.innerWidth - containerSize.width - left + 'px';
|
|
} else {
|
|
this.containerEl.style.right = '';
|
|
this.containerEl.style.left = left + 'px';
|
|
}
|
|
|
|
this.containerEl.style.top = top + 'px';
|
|
DomHandler.addClass(this.containerEl, 'p-tooltip-active');
|
|
} else {
|
|
var pos = DomHandler.findCollisionPosition(this.state.position);
|
|
var my = this.getTargetOption(target, 'my') || this.props.my || pos.my;
|
|
var at = this.getTargetOption(target, 'at') || this.props.at || pos.at;
|
|
this.containerEl.style.padding = '0px';
|
|
DomHandler.flipfitCollision(this.containerEl, target, my, at, function (currentPosition) {
|
|
var _currentPosition$at = currentPosition.at,
|
|
atX = _currentPosition$at.x,
|
|
atY = _currentPosition$at.y;
|
|
var myX = currentPosition.my.x;
|
|
var position = _this4.props.at ? atX !== 'center' && atX !== myX ? atX : atY : currentPosition.at["".concat(pos.axis)];
|
|
_this4.containerEl.style.padding = '';
|
|
|
|
_this4.setState({
|
|
position: position
|
|
}, function () {
|
|
_this4.updateContainerPosition();
|
|
|
|
DomHandler.addClass(_this4.containerEl, 'p-tooltip-active');
|
|
});
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateContainerPosition",
|
|
value: function updateContainerPosition() {
|
|
if (this.containerEl) {
|
|
var style = getComputedStyle(this.containerEl);
|
|
if (this.state.position === 'left') this.containerEl.style.left = parseFloat(style.left) - parseFloat(style.paddingLeft) * 2 + 'px';else if (this.state.position === 'top') this.containerEl.style.top = parseFloat(style.top) - parseFloat(style.paddingTop) * 2 + 'px';
|
|
}
|
|
}
|
|
}, {
|
|
key: "onMouseEnter",
|
|
value: function onMouseEnter() {
|
|
if (!this.isAutoHide()) {
|
|
this.allowHide = false;
|
|
}
|
|
}
|
|
}, {
|
|
key: "onMouseLeave",
|
|
value: function onMouseLeave(e) {
|
|
if (!this.isAutoHide()) {
|
|
this.allowHide = true;
|
|
this.hide(e);
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindDocumentResizeListener",
|
|
value: function bindDocumentResizeListener() {
|
|
var _this5 = this;
|
|
|
|
this.documentResizeListener = function (e) {
|
|
if (!DomHandler.isTouchDevice()) {
|
|
_this5.hide(e);
|
|
}
|
|
};
|
|
|
|
window.addEventListener('resize', this.documentResizeListener);
|
|
}
|
|
}, {
|
|
key: "unbindDocumentResizeListener",
|
|
value: function unbindDocumentResizeListener() {
|
|
if (this.documentResizeListener) {
|
|
window.removeEventListener('resize', this.documentResizeListener);
|
|
this.documentResizeListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindScrollListener",
|
|
value: function bindScrollListener() {
|
|
var _this6 = this;
|
|
|
|
if (!this.scrollHandler) {
|
|
this.scrollHandler = new ConnectedOverlayScrollHandler(this.currentTarget, function (e) {
|
|
if (_this6.state.visible) {
|
|
_this6.hide(e);
|
|
}
|
|
});
|
|
}
|
|
|
|
this.scrollHandler.bindScrollListener();
|
|
}
|
|
}, {
|
|
key: "unbindScrollListener",
|
|
value: function unbindScrollListener() {
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.unbindScrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindTargetEvent",
|
|
value: function bindTargetEvent(target) {
|
|
if (target) {
|
|
var _this$getEvents = this.getEvents(target),
|
|
showEvent = _this$getEvents.showEvent,
|
|
hideEvent = _this$getEvents.hideEvent;
|
|
|
|
var currentTarget = this.getTarget(target);
|
|
currentTarget.addEventListener(showEvent, this.show);
|
|
currentTarget.addEventListener(hideEvent, this.hide);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindTargetEvent",
|
|
value: function unbindTargetEvent(target) {
|
|
if (target) {
|
|
var _this$getEvents2 = this.getEvents(target),
|
|
showEvent = _this$getEvents2.showEvent,
|
|
hideEvent = _this$getEvents2.hideEvent;
|
|
|
|
var currentTarget = this.getTarget(target);
|
|
currentTarget.removeEventListener(showEvent, this.show);
|
|
currentTarget.removeEventListener(hideEvent, this.hide);
|
|
}
|
|
}
|
|
}, {
|
|
key: "applyDelay",
|
|
value: function applyDelay(delayProp, callback) {
|
|
this.clearTimeouts();
|
|
var delay = this.getTargetOption(this.currentTarget, delayProp.toLowerCase()) || this.props[delayProp];
|
|
|
|
if (!!delay) {
|
|
this["".concat(delayProp, "Timeout")] = setTimeout(function () {
|
|
return callback();
|
|
}, delay);
|
|
} else {
|
|
callback();
|
|
}
|
|
}
|
|
}, {
|
|
key: "sendCallback",
|
|
value: function sendCallback(callback) {
|
|
if (callback) {
|
|
for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
|
params[_key - 1] = arguments[_key];
|
|
}
|
|
|
|
callback.apply(void 0, params);
|
|
}
|
|
}
|
|
}, {
|
|
key: "clearTimeouts",
|
|
value: function clearTimeouts() {
|
|
clearTimeout(this.showDelayTimeout);
|
|
clearTimeout(this.updateDelayTimeout);
|
|
clearTimeout(this.hideDelayTimeout);
|
|
}
|
|
}, {
|
|
key: "getTarget",
|
|
value: function getTarget(target) {
|
|
if (target) {
|
|
if (this.isShowOnDisabled(target)) {
|
|
var wrapper = document.createElement('span');
|
|
target.parentNode.insertBefore(wrapper, target);
|
|
wrapper.appendChild(target);
|
|
return wrapper;
|
|
}
|
|
|
|
return target;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "updateTargetEvents",
|
|
value: function updateTargetEvents(target) {
|
|
this.unloadTargetEvents(target);
|
|
this.loadTargetEvents(target);
|
|
}
|
|
}, {
|
|
key: "loadTargetEvents",
|
|
value: function loadTargetEvents(target) {
|
|
this.setTargetEventOperations(target || this.props.target, 'bindTargetEvent');
|
|
}
|
|
}, {
|
|
key: "unloadTargetEvents",
|
|
value: function unloadTargetEvents(target) {
|
|
this.setTargetEventOperations(target || this.props.target, 'unbindTargetEvent');
|
|
}
|
|
}, {
|
|
key: "setTargetEventOperations",
|
|
value: function setTargetEventOperations(target, operation) {
|
|
var _this7 = this;
|
|
|
|
if (target) {
|
|
if (DomHandler.isElement(target)) {
|
|
this[operation](target);
|
|
} else {
|
|
var setEvent = function setEvent(target) {
|
|
var element = DomHandler.find(document, target);
|
|
element.forEach(function (el) {
|
|
_this7[operation](el);
|
|
});
|
|
};
|
|
|
|
if (target instanceof Array) {
|
|
target.forEach(function (t) {
|
|
setEvent(t);
|
|
});
|
|
} else {
|
|
setEvent(target);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (this.props.target) {
|
|
this.loadTargetEvents();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps, prevState) {
|
|
var _this8 = this;
|
|
|
|
if (prevProps.target !== this.props.target) {
|
|
this.unloadTargetEvents(prevProps.target);
|
|
this.loadTargetEvents();
|
|
}
|
|
|
|
if (this.state.visible) {
|
|
if (prevProps.content !== this.props.content) {
|
|
this.applyDelay('updateDelay', function () {
|
|
_this8.updateText(_this8.currentTarget, function () {
|
|
_this8.align(_this8.currentTarget);
|
|
});
|
|
});
|
|
}
|
|
|
|
if (this.currentTarget && this.isDisabled(this.currentTarget)) {
|
|
this.hide();
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.clearTimeouts();
|
|
this.unbindDocumentResizeListener();
|
|
this.unloadTargetEvents();
|
|
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.destroy();
|
|
this.scrollHandler = null;
|
|
}
|
|
|
|
ZIndexUtils.clear(this.containerEl);
|
|
}
|
|
}, {
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
var _this9 = this;
|
|
|
|
var tooltipClassName = classNames('p-tooltip p-component', _defineProperty({}, "p-tooltip-".concat(this.state.position), true), this.props.className);
|
|
var isTargetContentEmpty = this.isTargetContentEmpty(this.currentTarget);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
ref: function ref(el) {
|
|
return _this9.containerEl = el;
|
|
},
|
|
className: tooltipClassName,
|
|
style: this.props.style,
|
|
role: "tooltip",
|
|
"aria-hidden": this.state.visible,
|
|
onMouseEnter: this.onMouseEnter,
|
|
onMouseLeave: this.onMouseLeave
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-tooltip-arrow"
|
|
}), /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this9.tooltipTextEl = el;
|
|
},
|
|
className: "p-tooltip-text"
|
|
}, isTargetContentEmpty && this.props.children));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
if (this.state.visible) {
|
|
var element = this.renderElement();
|
|
return /*#__PURE__*/React.createElement(Portal, {
|
|
element: element,
|
|
appendTo: this.props.appendTo,
|
|
visible: true
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}]);
|
|
|
|
return Tooltip;
|
|
}(Component);
|
|
|
|
_defineProperty(Tooltip, "defaultProps", {
|
|
id: null,
|
|
target: null,
|
|
content: null,
|
|
disabled: false,
|
|
className: null,
|
|
style: null,
|
|
appendTo: null,
|
|
position: 'right',
|
|
my: null,
|
|
at: null,
|
|
event: null,
|
|
showEvent: 'mouseenter',
|
|
hideEvent: 'mouseleave',
|
|
autoZIndex: true,
|
|
baseZIndex: 0,
|
|
mouseTrack: false,
|
|
mouseTrackTop: 5,
|
|
mouseTrackLeft: 5,
|
|
showDelay: 0,
|
|
updateDelay: 0,
|
|
hideDelay: 0,
|
|
autoHide: true,
|
|
showOnDisabled: false,
|
|
onBeforeShow: null,
|
|
onBeforeHide: null,
|
|
onShow: null,
|
|
onHide: null
|
|
});
|
|
|
|
function ownKeys$P(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$P(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$P(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$P(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$2h(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$2h(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$2h() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
var InputTextComponent = /*#__PURE__*/function (_Component) {
|
|
_inherits(InputTextComponent, _Component);
|
|
|
|
var _super = _createSuper$2h(InputTextComponent);
|
|
|
|
function InputTextComponent(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, InputTextComponent);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onInput = _this.onInput.bind(_assertThisInitialized(_this));
|
|
_this.onKeyPress = _this.onKeyPress.bind(_assertThisInitialized(_this));
|
|
_this.elementRef = /*#__PURE__*/createRef(_this.props.forwardRef);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(InputTextComponent, [{
|
|
key: "isFilled",
|
|
value: function isFilled() {
|
|
return this.props.value != null && this.props.value.toString().length > 0 || this.props.defaultValue != null && this.props.defaultValue.toString().length > 0 || this.elementRef && this.elementRef.current && this.elementRef.current.value != null && this.elementRef.current.value.toString().length > 0;
|
|
}
|
|
}, {
|
|
key: "onKeyPress",
|
|
value: function onKeyPress(event) {
|
|
if (this.props.onKeyPress) {
|
|
this.props.onKeyPress(event);
|
|
}
|
|
|
|
if (this.props.keyfilter) {
|
|
KeyFilter.onKeyPress(event, this.props.keyfilter, this.props.validateOnly);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onInput",
|
|
value: function onInput(event) {
|
|
var validatePattern = true;
|
|
|
|
if (this.props.keyfilter && this.props.validateOnly) {
|
|
validatePattern = KeyFilter.validate(event, this.props.keyfilter);
|
|
}
|
|
|
|
if (this.props.onInput) {
|
|
this.props.onInput(event, validatePattern);
|
|
}
|
|
|
|
if (!this.props.onChange) {
|
|
if (event.target.value.length > 0) DomHandler.addClass(event.target, 'p-filled');else DomHandler.removeClass(event.target, 'p-filled');
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateForwardRef",
|
|
value: function updateForwardRef() {
|
|
var ref = this.props.forwardRef;
|
|
|
|
if (ref) {
|
|
if (typeof ref === 'function') {
|
|
ref(this.elementRef.current);
|
|
} else {
|
|
ref.current = this.elementRef.current;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.updateForwardRef();
|
|
|
|
if (this.props.tooltip) {
|
|
this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$P({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.elementRef.current,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-inputtext p-component', {
|
|
'p-disabled': this.props.disabled,
|
|
'p-filled': this.isFilled()
|
|
}, this.props.className);
|
|
var inputProps = ObjectUtils.findDiffKeys(this.props, InputTextComponent.defaultProps);
|
|
return /*#__PURE__*/React.createElement("input", _extends({
|
|
ref: this.elementRef
|
|
}, inputProps, {
|
|
className: className,
|
|
onInput: this.onInput,
|
|
onKeyPress: this.onKeyPress
|
|
}));
|
|
}
|
|
}]);
|
|
|
|
return InputTextComponent;
|
|
}(Component);
|
|
|
|
_defineProperty(InputTextComponent, "defaultProps", {
|
|
keyfilter: null,
|
|
validateOnly: false,
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
onInput: null,
|
|
onKeyPress: null,
|
|
forwardRef: null
|
|
});
|
|
|
|
var InputText = /*#__PURE__*/React.forwardRef(function (props, ref) {
|
|
return /*#__PURE__*/React.createElement(InputTextComponent, _extends({
|
|
forwardRef: ref
|
|
}, props));
|
|
});
|
|
|
|
function _createSuper$2g(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$2g(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$2g() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Ripple = /*#__PURE__*/function (_Component) {
|
|
_inherits(Ripple, _Component);
|
|
|
|
var _super = _createSuper$2g(Ripple);
|
|
|
|
function Ripple(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Ripple);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onMouseDown = _this.onMouseDown.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Ripple, [{
|
|
key: "getTarget",
|
|
value: function getTarget() {
|
|
return this.ink && this.ink.parentElement;
|
|
}
|
|
}, {
|
|
key: "bindEvents",
|
|
value: function bindEvents() {
|
|
if (this.target) {
|
|
this.target.addEventListener('mousedown', this.onMouseDown);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindEvents",
|
|
value: function unbindEvents() {
|
|
if (this.target) {
|
|
this.target.removeEventListener('mousedown', this.onMouseDown);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onMouseDown",
|
|
value: function onMouseDown(event) {
|
|
if (!this.ink || getComputedStyle(this.ink, null).display === 'none') {
|
|
return;
|
|
}
|
|
|
|
DomHandler.removeClass(this.ink, 'p-ink-active');
|
|
|
|
if (!DomHandler.getHeight(this.ink) && !DomHandler.getWidth(this.ink)) {
|
|
var d = Math.max(DomHandler.getOuterWidth(this.target), DomHandler.getOuterHeight(this.target));
|
|
this.ink.style.height = d + 'px';
|
|
this.ink.style.width = d + 'px';
|
|
}
|
|
|
|
var offset = DomHandler.getOffset(this.target);
|
|
var x = event.pageX - offset.left + document.body.scrollTop - DomHandler.getWidth(this.ink) / 2;
|
|
var y = event.pageY - offset.top + document.body.scrollLeft - DomHandler.getHeight(this.ink) / 2;
|
|
this.ink.style.top = y + 'px';
|
|
this.ink.style.left = x + 'px';
|
|
DomHandler.addClass(this.ink, 'p-ink-active');
|
|
}
|
|
}, {
|
|
key: "onAnimationEnd",
|
|
value: function onAnimationEnd(event) {
|
|
DomHandler.removeClass(event.currentTarget, 'p-ink-active');
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (this.ink) {
|
|
this.target = this.getTarget();
|
|
this.bindEvents();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate() {
|
|
if (this.ink && !this.target) {
|
|
this.target = this.getTarget();
|
|
this.bindEvents();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.ink) {
|
|
this.target = null;
|
|
this.unbindEvents();
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this2 = this;
|
|
|
|
return PrimeReact.ripple ? /*#__PURE__*/React.createElement("span", {
|
|
ref: function ref(el) {
|
|
return _this2.ink = el;
|
|
},
|
|
className: "p-ink",
|
|
onAnimationEnd: this.onAnimationEnd
|
|
}) : null;
|
|
}
|
|
}]);
|
|
|
|
return Ripple;
|
|
}(Component);
|
|
|
|
function ownKeys$O(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$O(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$O(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$O(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$2f(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$2f(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$2f() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var ButtonComponent = /*#__PURE__*/function (_Component) {
|
|
_inherits(ButtonComponent, _Component);
|
|
|
|
var _super = _createSuper$2f(ButtonComponent);
|
|
|
|
function ButtonComponent(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, ButtonComponent);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.elementRef = /*#__PURE__*/createRef(_this.props.forwardRef);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(ButtonComponent, [{
|
|
key: "updateForwardRef",
|
|
value: function updateForwardRef() {
|
|
var ref = this.props.forwardRef;
|
|
|
|
if (ref) {
|
|
if (typeof ref === 'function') {
|
|
ref(this.elementRef.current);
|
|
} else {
|
|
ref.current = this.elementRef.current;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "isDisabled",
|
|
value: function isDisabled() {
|
|
return this.props.disabled || this.props.loading;
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.updateForwardRef();
|
|
|
|
if (this.props.tooltip) {
|
|
this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$O({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.elementRef.current,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderIcon",
|
|
value: function renderIcon() {
|
|
var icon = this.props.loading ? this.props.loadingIcon : this.props.icon;
|
|
var className = classNames('p-button-icon p-c', {
|
|
'p-button-loading-icon': this.props.loading,
|
|
'p-button-icon-left': this.props.iconPos === 'left' && this.props.label,
|
|
'p-button-icon-right': this.props.iconPos === 'right' && this.props.label,
|
|
'p-button-icon-top': this.props.iconPos === 'top' && this.props.label,
|
|
'p-button-icon-bottom': this.props.iconPos === 'bottom' && this.props.label
|
|
});
|
|
return IconUtils.getJSXIcon(icon, {
|
|
className: className
|
|
}, {
|
|
props: this.props
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderLabel",
|
|
value: function renderLabel() {
|
|
if (this.props.label) {
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: "p-button-label p-c"
|
|
}, this.props.label);
|
|
}
|
|
|
|
return !this.props.children && !this.props.label && /*#__PURE__*/React.createElement("span", {
|
|
className: "p-button-label p-c",
|
|
dangerouslySetInnerHTML: {
|
|
__html: " "
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderBadge",
|
|
value: function renderBadge() {
|
|
if (this.props.badge) {
|
|
var badgeClassName = classNames('p-badge', this.props.badgeClassName);
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: badgeClassName
|
|
}, this.props.badge);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var disabled = this.isDisabled();
|
|
var className = classNames('p-button p-component', this.props.className, _defineProperty({
|
|
'p-button-icon-only': (this.props.icon || this.props.loading && this.props.loadingIcon) && !this.props.label,
|
|
'p-button-vertical': (this.props.iconPos === 'top' || this.props.iconPos === 'bottom') && this.props.label,
|
|
'p-disabled': disabled,
|
|
'p-button-loading': this.props.loading,
|
|
'p-button-loading-label-only': this.props.loading && !this.props.icon && this.props.label
|
|
}, "p-button-loading-".concat(this.props.iconPos), this.props.loading && this.props.loadingIcon && this.props.label));
|
|
var icon = this.renderIcon();
|
|
var label = this.renderLabel();
|
|
var badge = this.renderBadge();
|
|
var buttonProps = ObjectUtils.findDiffKeys(this.props, ButtonComponent.defaultProps);
|
|
return /*#__PURE__*/React.createElement("button", _extends({
|
|
ref: this.elementRef
|
|
}, buttonProps, {
|
|
className: className,
|
|
disabled: disabled
|
|
}), icon, label, this.props.children, badge, /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
}]);
|
|
|
|
return ButtonComponent;
|
|
}(Component);
|
|
|
|
_defineProperty(ButtonComponent, "defaultProps", {
|
|
label: null,
|
|
icon: null,
|
|
iconPos: 'left',
|
|
badge: null,
|
|
badgeClassName: null,
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
forwardRef: null,
|
|
disabled: false,
|
|
loading: false,
|
|
loadingIcon: 'pi pi-spinner pi-spin'
|
|
});
|
|
|
|
var Button = /*#__PURE__*/React.forwardRef(function (props, ref) {
|
|
return /*#__PURE__*/React.createElement(ButtonComponent, _extends({
|
|
forwardRef: ref
|
|
}, props));
|
|
});
|
|
|
|
function ownKeys$N(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$N(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$N(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$N(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$2e(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$2e(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$2e() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var VirtualScroller = /*#__PURE__*/function (_Component) {
|
|
_inherits(VirtualScroller, _Component);
|
|
|
|
var _super = _createSuper$2e(VirtualScroller);
|
|
|
|
function VirtualScroller(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, VirtualScroller);
|
|
|
|
_this = _super.call(this, props);
|
|
|
|
var isBoth = _this.isBoth();
|
|
|
|
_this.state = {
|
|
first: isBoth ? {
|
|
rows: 0,
|
|
cols: 0
|
|
} : 0,
|
|
last: isBoth ? {
|
|
rows: 0,
|
|
cols: 0
|
|
} : 0,
|
|
numItemsInViewport: isBoth ? {
|
|
rows: 0,
|
|
cols: 0
|
|
} : 0,
|
|
numToleratedItems: props.numToleratedItems,
|
|
loading: props.loading,
|
|
loaderArr: []
|
|
};
|
|
_this.onScroll = _this.onScroll.bind(_assertThisInitialized(_this));
|
|
_this.lastScrollPos = isBoth ? {
|
|
top: 0,
|
|
left: 0
|
|
} : 0;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(VirtualScroller, [{
|
|
key: "scrollTo",
|
|
value: function scrollTo(options) {
|
|
this.el && this.el.scrollTo(options);
|
|
}
|
|
}, {
|
|
key: "scrollToIndex",
|
|
value: function scrollToIndex(index) {
|
|
var _this2 = this;
|
|
|
|
var behavior = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'auto';
|
|
var isBoth = this.isBoth();
|
|
var isHorizontal = this.isHorizontal();
|
|
var first = this.state.first;
|
|
|
|
var _this$calculateNumIte = this.calculateNumItems(),
|
|
numToleratedItems = _this$calculateNumIte.numToleratedItems;
|
|
|
|
var itemSize = this.props.itemSize;
|
|
var contentPos = this.getContentPosition();
|
|
|
|
var calculateFirst = function calculateFirst() {
|
|
var _index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
|
|
|
|
var _numT = arguments.length > 1 ? arguments[1] : undefined;
|
|
|
|
return _index <= _numT ? 0 : _index;
|
|
};
|
|
|
|
var calculateCoord = function calculateCoord(_first, _size, _cpos) {
|
|
return _first * _size + _cpos;
|
|
};
|
|
|
|
var scrollTo = function scrollTo() {
|
|
var left = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
|
|
var top = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
|
|
return _this2.scrollTo({
|
|
left: left,
|
|
top: top,
|
|
behavior: behavior
|
|
});
|
|
};
|
|
|
|
if (isBoth) {
|
|
var newFirst = {
|
|
rows: calculateFirst(index[0], numToleratedItems[0]),
|
|
cols: calculateFirst(index[1], numToleratedItems[1])
|
|
};
|
|
|
|
if (newFirst.rows !== first.rows || newFirst.cols !== first.cols) {
|
|
scrollTo(calculateCoord(newFirst.cols, itemSize[1], contentPos.left), calculateCoord(newFirst.rows, itemSize[0], contentPos.top));
|
|
this.setState({
|
|
first: newFirst
|
|
});
|
|
}
|
|
} else {
|
|
var _newFirst = calculateFirst(index, numToleratedItems);
|
|
|
|
if (_newFirst !== first) {
|
|
isHorizontal ? scrollTo(calculateCoord(_newFirst, itemSize, contentPos.left), 0) : scrollTo(0, calculateCoord(_newFirst, itemSize, contentPos.top));
|
|
this.setState({
|
|
first: _newFirst
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "scrollInView",
|
|
value: function scrollInView(index, to) {
|
|
var _this3 = this;
|
|
|
|
var behavior = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'auto';
|
|
|
|
if (to) {
|
|
var isBoth = this.isBoth();
|
|
var isHorizontal = this.isHorizontal();
|
|
|
|
var _this$getRenderedRang = this.getRenderedRange(),
|
|
first = _this$getRenderedRang.first,
|
|
viewport = _this$getRenderedRang.viewport;
|
|
|
|
var itemSize = this.props.itemSize;
|
|
|
|
var scrollTo = function scrollTo() {
|
|
var left = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
|
|
var top = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
|
|
return _this3.scrollTo({
|
|
left: left,
|
|
top: top,
|
|
behavior: behavior
|
|
});
|
|
};
|
|
|
|
var isToStart = to === 'to-start';
|
|
var isToEnd = to === 'to-end';
|
|
|
|
if (isToStart) {
|
|
if (isBoth) {
|
|
if (viewport.first.rows - first.rows > index[0]) {
|
|
scrollTo(viewport.first.cols * itemSize, (viewport.first.rows - 1) * itemSize);
|
|
} else if (viewport.first.cols - first.cols > index[1]) {
|
|
scrollTo((viewport.first.cols - 1) * itemSize, viewport.first.rows * itemSize);
|
|
}
|
|
} else {
|
|
if (viewport.first - first > index) {
|
|
var pos = (viewport.first - 1) * itemSize;
|
|
isHorizontal ? scrollTo(pos, 0) : scrollTo(0, pos);
|
|
}
|
|
}
|
|
} else if (isToEnd) {
|
|
if (isBoth) {
|
|
if (viewport.last.rows - first.rows <= index[0] + 1) {
|
|
scrollTo(viewport.first.cols * itemSize, (viewport.first.rows + 1) * itemSize);
|
|
} else if (viewport.last.cols - first.cols <= index[1] + 1) {
|
|
scrollTo((viewport.first.cols + 1) * itemSize, viewport.first.rows * itemSize);
|
|
}
|
|
} else {
|
|
if (viewport.last - first <= index + 1) {
|
|
var _pos2 = (viewport.first + 1) * itemSize;
|
|
|
|
isHorizontal ? scrollTo(_pos2, 0) : scrollTo(0, _pos2);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
this.scrollToIndex(index, behavior);
|
|
}
|
|
}
|
|
}, {
|
|
key: "getRows",
|
|
value: function getRows() {
|
|
return this.state.loading ? this.props.loaderDisabled ? this.state.loaderArr : [] : this.loadedItems();
|
|
}
|
|
}, {
|
|
key: "getColumns",
|
|
value: function getColumns() {
|
|
if (this.props.columns) {
|
|
var isBoth = this.isBoth();
|
|
var isHorizontal = this.isHorizontal();
|
|
|
|
if (isBoth || isHorizontal) {
|
|
return this.state.loading && this.props.loaderDisabled ? isBoth ? this.state.loaderArr[0] : this.state.loaderArr : this.props.columns.slice(isBoth ? this.state.first.cols : this.state.first, isBoth ? this.state.last.cols : this.state.last);
|
|
}
|
|
}
|
|
|
|
return this.props.columns;
|
|
}
|
|
}, {
|
|
key: "getRenderedRange",
|
|
value: function getRenderedRange() {
|
|
var isBoth = this.isBoth();
|
|
var isHorizontal = this.isHorizontal();
|
|
var _this$state = this.state,
|
|
first = _this$state.first,
|
|
last = _this$state.last,
|
|
numItemsInViewport = _this$state.numItemsInViewport;
|
|
var itemSize = this.props.itemSize;
|
|
|
|
var calculateFirstInViewport = function calculateFirstInViewport(_pos, _size) {
|
|
return Math.floor(_pos / (_size || _pos));
|
|
};
|
|
|
|
var firstInViewport = first;
|
|
var lastInViewport = 0;
|
|
|
|
if (this.el) {
|
|
var scrollTop = this.el.scrollTop;
|
|
var scrollLeft = this.el.scrollLeft;
|
|
|
|
if (isBoth) {
|
|
firstInViewport = {
|
|
rows: calculateFirstInViewport(scrollTop, itemSize[0]),
|
|
cols: calculateFirstInViewport(scrollLeft, itemSize[1])
|
|
};
|
|
lastInViewport = {
|
|
rows: firstInViewport.rows + numItemsInViewport.rows,
|
|
cols: firstInViewport.cols + numItemsInViewport.cols
|
|
};
|
|
} else {
|
|
var scrollPos = isHorizontal ? scrollLeft : scrollTop;
|
|
firstInViewport = calculateFirstInViewport(scrollPos, itemSize);
|
|
lastInViewport = firstInViewport + numItemsInViewport;
|
|
}
|
|
}
|
|
|
|
return {
|
|
first: first,
|
|
last: last,
|
|
viewport: {
|
|
first: firstInViewport,
|
|
last: lastInViewport
|
|
}
|
|
};
|
|
}
|
|
}, {
|
|
key: "isVertical",
|
|
value: function isVertical() {
|
|
return this.props.orientation === 'vertical';
|
|
}
|
|
}, {
|
|
key: "isHorizontal",
|
|
value: function isHorizontal() {
|
|
return this.props.orientation === 'horizontal';
|
|
}
|
|
}, {
|
|
key: "isBoth",
|
|
value: function isBoth() {
|
|
return this.props.orientation === 'both';
|
|
}
|
|
}, {
|
|
key: "calculateNumItems",
|
|
value: function calculateNumItems() {
|
|
var isBoth = this.isBoth();
|
|
var isHorizontal = this.isHorizontal();
|
|
var itemSize = this.props.itemSize;
|
|
var contentPos = this.getContentPosition();
|
|
var contentWidth = this.el ? this.el.offsetWidth - contentPos.left : 0;
|
|
var contentHeight = this.el ? this.el.offsetHeight - contentPos.top : 0;
|
|
|
|
var calculateNumItemsInViewport = function calculateNumItemsInViewport(_contentSize, _itemSize) {
|
|
return Math.ceil(_contentSize / (_itemSize || _contentSize));
|
|
};
|
|
|
|
var calculateNumToleratedItems = function calculateNumToleratedItems(_numItems) {
|
|
return Math.ceil(_numItems / 2);
|
|
};
|
|
|
|
var numItemsInViewport = isBoth ? {
|
|
rows: calculateNumItemsInViewport(contentHeight, itemSize[0]),
|
|
cols: calculateNumItemsInViewport(contentWidth, itemSize[1])
|
|
} : calculateNumItemsInViewport(isHorizontal ? contentWidth : contentHeight, itemSize);
|
|
var numToleratedItems = this.state.numToleratedItems || (isBoth ? [calculateNumToleratedItems(numItemsInViewport.rows), calculateNumToleratedItems(numItemsInViewport.cols)] : calculateNumToleratedItems(numItemsInViewport));
|
|
return {
|
|
numItemsInViewport: numItemsInViewport,
|
|
numToleratedItems: numToleratedItems
|
|
};
|
|
}
|
|
}, {
|
|
key: "calculateOptions",
|
|
value: function calculateOptions() {
|
|
var _this4 = this;
|
|
|
|
var isBoth = this.isBoth();
|
|
var first = this.state.first;
|
|
|
|
var _this$calculateNumIte2 = this.calculateNumItems(),
|
|
numItemsInViewport = _this$calculateNumIte2.numItemsInViewport,
|
|
numToleratedItems = _this$calculateNumIte2.numToleratedItems;
|
|
|
|
var calculateLast = function calculateLast(_first, _num, _numT, _isCols) {
|
|
return _this4.getLast(_first + _num + (_first < _numT ? 2 : 3) * _numT, _isCols);
|
|
};
|
|
|
|
var last = isBoth ? {
|
|
rows: calculateLast(first.rows, numItemsInViewport.rows, numToleratedItems[0]),
|
|
cols: calculateLast(first.cols, numItemsInViewport.cols, numToleratedItems[1], true)
|
|
} : calculateLast(first, numItemsInViewport, numToleratedItems);
|
|
var state = {
|
|
numItemsInViewport: numItemsInViewport,
|
|
last: last,
|
|
numToleratedItems: numToleratedItems
|
|
};
|
|
|
|
if (this.props.showLoader) {
|
|
state['loaderArr'] = isBoth ? Array.from({
|
|
length: numItemsInViewport.rows
|
|
}).map(function () {
|
|
return Array.from({
|
|
length: numItemsInViewport.cols
|
|
});
|
|
}) : Array.from({
|
|
length: numItemsInViewport
|
|
});
|
|
}
|
|
|
|
this.setState(state, function () {
|
|
if (_this4.props.lazy) {
|
|
_this4.props.onLazyLoad && _this4.props.onLazyLoad({
|
|
first: _this4.state.first,
|
|
last: _this4.state.last
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "getLast",
|
|
value: function getLast() {
|
|
var last = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
|
|
var isCols = arguments.length > 1 ? arguments[1] : undefined;
|
|
|
|
if (this.props.items) {
|
|
return Math.min(isCols ? (this.props.columns || this.props.items[0]).length : this.props.items.length, last);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
}, {
|
|
key: "getContentPosition",
|
|
value: function getContentPosition() {
|
|
if (this.content) {
|
|
var style = getComputedStyle(this.content);
|
|
var left = parseInt(style.paddingLeft, 10) + Math.max(parseInt(style.left, 10), 0);
|
|
var right = parseInt(style.paddingRight, 10) + Math.max(parseInt(style.right, 10), 0);
|
|
var top = parseInt(style.paddingTop, 10) + Math.max(parseInt(style.top, 10), 0);
|
|
var bottom = parseInt(style.paddingBottom, 10) + Math.max(parseInt(style.bottom, 10), 0);
|
|
return {
|
|
left: left,
|
|
right: right,
|
|
top: top,
|
|
bottom: bottom,
|
|
x: left + right,
|
|
y: top + bottom
|
|
};
|
|
}
|
|
|
|
return {
|
|
left: 0,
|
|
right: 0,
|
|
top: 0,
|
|
bottom: 0,
|
|
x: 0,
|
|
y: 0
|
|
};
|
|
}
|
|
}, {
|
|
key: "setSize",
|
|
value: function setSize() {
|
|
var _this5 = this;
|
|
|
|
if (this.el) {
|
|
var isBoth = this.isBoth();
|
|
var isHorizontal = this.isHorizontal();
|
|
var parentElement = this.el.parentElement;
|
|
var width = this.props.scrollWidth || "".concat(this.el.offsetWidth || parentElement.offsetWidth, "px");
|
|
var height = this.props.scrollHeight || "".concat(this.el.offsetHeight || parentElement.offsetHeight, "px");
|
|
|
|
var setProp = function setProp(_name, _value) {
|
|
return _this5.el.style[_name] = _value;
|
|
};
|
|
|
|
if (isBoth || isHorizontal) {
|
|
setProp('height', height);
|
|
setProp('width', width);
|
|
} else {
|
|
setProp('height', height);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "setSpacerSize",
|
|
value: function setSpacerSize() {
|
|
var _this6 = this;
|
|
|
|
var items = this.props.items;
|
|
|
|
if (this.spacer && items) {
|
|
var isBoth = this.isBoth();
|
|
var isHorizontal = this.isHorizontal();
|
|
var itemSize = this.props.itemSize;
|
|
var contentPos = this.getContentPosition();
|
|
|
|
var setProp = function setProp(_name, _value, _size) {
|
|
var _cpos = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
|
|
|
|
return _this6.spacer.style[_name] = (_value || []).length * _size + _cpos + 'px';
|
|
};
|
|
|
|
if (isBoth) {
|
|
setProp('height', items, itemSize[0], contentPos.y);
|
|
setProp('width', this.props.columns || items[1], itemSize[1], contentPos.x);
|
|
} else {
|
|
isHorizontal ? setProp('width', this.props.columns || items, itemSize, contentPos.x) : setProp('height', items, itemSize, contentPos.y);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "setContentPosition",
|
|
value: function setContentPosition(pos) {
|
|
var _this7 = this;
|
|
|
|
if (this.content) {
|
|
var isBoth = this.isBoth();
|
|
var isHorizontal = this.isHorizontal();
|
|
var first = pos ? pos.first : this.state.first;
|
|
var itemSize = this.props.itemSize;
|
|
|
|
var calculateTranslateVal = function calculateTranslateVal(_first, _size) {
|
|
return _first * _size;
|
|
};
|
|
|
|
var setTransform = function setTransform() {
|
|
var _x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
|
|
|
|
var _y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
|
|
|
|
_this7.sticky && (_this7.sticky.style.top = "-".concat(_y, "px"));
|
|
_this7.content.style.transform = "translate3d(".concat(_x, "px, ").concat(_y, "px, 0)");
|
|
};
|
|
|
|
if (isBoth) {
|
|
setTransform(calculateTranslateVal(first.cols, itemSize[1]), calculateTranslateVal(first.rows, itemSize[0]));
|
|
} else {
|
|
var translateVal = calculateTranslateVal(first, itemSize);
|
|
isHorizontal ? setTransform(translateVal, 0) : setTransform(0, translateVal);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onScrollPositionChange",
|
|
value: function onScrollPositionChange(event) {
|
|
var _this8 = this;
|
|
|
|
var target = event.target;
|
|
var isBoth = this.isBoth();
|
|
var isHorizontal = this.isHorizontal();
|
|
var _this$state2 = this.state,
|
|
first = _this$state2.first,
|
|
last = _this$state2.last,
|
|
numItemsInViewport = _this$state2.numItemsInViewport,
|
|
numToleratedItems = _this$state2.numToleratedItems;
|
|
var itemSize = this.props.itemSize;
|
|
var contentPos = this.getContentPosition();
|
|
|
|
var calculateScrollPos = function calculateScrollPos(_pos, _cpos) {
|
|
return _pos ? _pos > _cpos ? _pos - _cpos : _pos : 0;
|
|
};
|
|
|
|
var calculateCurrentIndex = function calculateCurrentIndex(_pos, _size) {
|
|
return Math.floor(_pos / (_size || _pos));
|
|
};
|
|
|
|
var calculateTriggerIndex = function calculateTriggerIndex(_currentIndex, _first, _last, _num, _numT, _isScrollDownOrRight) {
|
|
return _currentIndex <= _numT ? _numT : _isScrollDownOrRight ? _last - _num - _numT : _first + _numT - 1;
|
|
};
|
|
|
|
var calculateFirst = function calculateFirst(_currentIndex, _triggerIndex, _first, _last, _num, _numT, _isScrollDownOrRight) {
|
|
if (_currentIndex <= _numT) return 0;else return Math.max(0, _isScrollDownOrRight ? _currentIndex < _triggerIndex ? _first : _currentIndex - _numT : _currentIndex > _triggerIndex ? _first : _currentIndex - 2 * _numT);
|
|
};
|
|
|
|
var calculateLast = function calculateLast(_currentIndex, _first, _last, _num, _numT, _isCols) {
|
|
var lastValue = _first + _num + 2 * _numT;
|
|
|
|
if (_currentIndex >= _numT) {
|
|
lastValue += _numT + 1;
|
|
}
|
|
|
|
return _this8.getLast(lastValue, _isCols);
|
|
};
|
|
|
|
var scrollTop = calculateScrollPos(target.scrollTop, contentPos.top);
|
|
var scrollLeft = calculateScrollPos(target.scrollLeft, contentPos.left);
|
|
var newFirst = 0;
|
|
var newLast = last;
|
|
var isRangeChanged = false;
|
|
|
|
if (isBoth) {
|
|
var isScrollDown = this.lastScrollPos.top <= scrollTop;
|
|
var isScrollRight = this.lastScrollPos.left <= scrollLeft;
|
|
var currentIndex = {
|
|
rows: calculateCurrentIndex(scrollTop, itemSize[0]),
|
|
cols: calculateCurrentIndex(scrollLeft, itemSize[1])
|
|
};
|
|
var triggerIndex = {
|
|
rows: calculateTriggerIndex(currentIndex.rows, first.rows, last.rows, numItemsInViewport.rows, numToleratedItems[0], isScrollDown),
|
|
cols: calculateTriggerIndex(currentIndex.cols, first.cols, last.cols, numItemsInViewport.cols, numToleratedItems[1], isScrollRight)
|
|
};
|
|
newFirst = {
|
|
rows: calculateFirst(currentIndex.rows, triggerIndex.rows, first.rows, last.rows, numItemsInViewport.rows, numToleratedItems[0], isScrollDown),
|
|
cols: calculateFirst(currentIndex.cols, triggerIndex.cols, first.cols, last.cols, numItemsInViewport.cols, numToleratedItems[1], isScrollRight)
|
|
};
|
|
newLast = {
|
|
rows: calculateLast(currentIndex.rows, newFirst.rows, last.rows, numItemsInViewport.rows, numToleratedItems[0]),
|
|
cols: calculateLast(currentIndex.cols, newFirst.cols, last.cols, numItemsInViewport.cols, numToleratedItems[1], true)
|
|
};
|
|
isRangeChanged = newFirst.rows !== first.rows && newLast.rows !== last.rows || newFirst.cols !== first.cols && newLast.cols !== last.cols;
|
|
this.lastScrollPos = {
|
|
top: scrollTop,
|
|
left: scrollLeft
|
|
};
|
|
} else {
|
|
var scrollPos = isHorizontal ? scrollLeft : scrollTop;
|
|
var isScrollDownOrRight = this.lastScrollPos <= scrollPos;
|
|
|
|
var _currentIndex2 = calculateCurrentIndex(scrollPos, itemSize);
|
|
|
|
var _triggerIndex2 = calculateTriggerIndex(_currentIndex2, first, last, numItemsInViewport, numToleratedItems, isScrollDownOrRight);
|
|
|
|
newFirst = calculateFirst(_currentIndex2, _triggerIndex2, first, last, numItemsInViewport, numToleratedItems, isScrollDownOrRight);
|
|
newLast = calculateLast(_currentIndex2, newFirst, last, numItemsInViewport, numToleratedItems);
|
|
isRangeChanged = newFirst !== first && newLast !== last;
|
|
this.lastScrollPos = scrollPos;
|
|
}
|
|
|
|
return {
|
|
first: newFirst,
|
|
last: newLast,
|
|
isRangeChanged: isRangeChanged
|
|
};
|
|
}
|
|
}, {
|
|
key: "onScrollChange",
|
|
value: function onScrollChange(event) {
|
|
var _this9 = this;
|
|
|
|
var _this$onScrollPositio = this.onScrollPositionChange(event),
|
|
first = _this$onScrollPositio.first,
|
|
last = _this$onScrollPositio.last,
|
|
isRangeChanged = _this$onScrollPositio.isRangeChanged;
|
|
|
|
if (isRangeChanged) {
|
|
var newState = {
|
|
first: first,
|
|
last: last
|
|
};
|
|
this.setContentPosition(newState);
|
|
this.setState(newState, function () {
|
|
_this9.props.onScrollIndexChange && _this9.props.onScrollIndexChange(newState);
|
|
|
|
if (_this9.props.lazy) {
|
|
_this9.props.onLazyLoad && _this9.props.onLazyLoad(newState);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onScroll",
|
|
value: function onScroll(event) {
|
|
var _this10 = this;
|
|
|
|
this.props.onScroll && this.props.onScroll(event);
|
|
|
|
if (this.props.delay) {
|
|
if (this.scrollTimeout) {
|
|
clearTimeout(this.scrollTimeout);
|
|
}
|
|
|
|
if (!this.state.loading && this.props.showLoader) {
|
|
var _this$onScrollPositio2 = this.onScrollPositionChange(event),
|
|
changed = _this$onScrollPositio2.isRangeChanged;
|
|
|
|
changed && this.setState({
|
|
loading: true
|
|
});
|
|
}
|
|
|
|
this.scrollTimeout = setTimeout(function () {
|
|
_this10.onScrollChange(event);
|
|
|
|
if (_this10.state.loading && _this10.props.showLoader && !_this10.props.lazy) {
|
|
_this10.setState({
|
|
loading: false
|
|
});
|
|
}
|
|
}, this.props.delay);
|
|
} else {
|
|
this.onScrollChange(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "getOptions",
|
|
value: function getOptions(renderedIndex) {
|
|
var first = this.state.first;
|
|
var count = (this.props.items || []).length;
|
|
var index = this.isBoth() ? first.rows + renderedIndex : first + renderedIndex;
|
|
return {
|
|
index: index,
|
|
count: count,
|
|
first: index === 0,
|
|
last: index === count - 1,
|
|
even: index % 2 === 0,
|
|
odd: index % 2 !== 0,
|
|
props: this.props
|
|
};
|
|
}
|
|
}, {
|
|
key: "loaderOptions",
|
|
value: function loaderOptions(index, extOptions) {
|
|
var count = this.state.loaderArr.length;
|
|
return _objectSpread$N({
|
|
index: index,
|
|
count: count,
|
|
first: index === 0,
|
|
last: index === count - 1,
|
|
even: index % 2 === 0,
|
|
odd: index % 2 !== 0,
|
|
props: this.props
|
|
}, extOptions);
|
|
}
|
|
}, {
|
|
key: "loadedItems",
|
|
value: function loadedItems() {
|
|
var _this11 = this;
|
|
|
|
var items = this.props.items;
|
|
|
|
if (items && !this.state.loading) {
|
|
var isBoth = this.isBoth();
|
|
var isHorizontal = this.isHorizontal();
|
|
var _this$state3 = this.state,
|
|
first = _this$state3.first,
|
|
last = _this$state3.last;
|
|
if (isBoth) return items.slice(first.rows, last.rows).map(function (item) {
|
|
return _this11.props.columns ? item : item.slice(first.cols, last.cols);
|
|
});else if (isHorizontal && this.props.columns) return items;else return items.slice(first, last);
|
|
}
|
|
|
|
return [];
|
|
}
|
|
}, {
|
|
key: "isPropChanged",
|
|
value: function isPropChanged(prevProps) {
|
|
var _this12 = this;
|
|
|
|
var props = ['itemSize', 'scrollHeight'];
|
|
return props.some(function (p) {
|
|
return !ObjectUtils.equals(prevProps[p], _this12.props[p]);
|
|
});
|
|
}
|
|
}, {
|
|
key: "init",
|
|
value: function init() {
|
|
this.setSize();
|
|
this.calculateOptions();
|
|
this.setSpacerSize();
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.init();
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps, prevState) {
|
|
if (!prevProps.items || prevProps.items.length !== (this.props.items || []).length || this.isPropChanged(prevProps)) {
|
|
this.init();
|
|
}
|
|
|
|
if (this.props.lazy && prevProps.loading !== this.props.loading && this.state.loading !== this.props.loading) {
|
|
this.setState({
|
|
loading: this.props.loading
|
|
});
|
|
}
|
|
|
|
if (prevProps.orientation !== this.props.orientation) {
|
|
this.lastScrollPos = this.isBoth() ? {
|
|
top: 0,
|
|
left: 0
|
|
} : 0;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderLoaderItem",
|
|
value: function renderLoaderItem(index) {
|
|
var extOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
var options = this.loaderOptions(index, extOptions);
|
|
var content = ObjectUtils.getJSXElement(this.props.loadingTemplate, options);
|
|
return /*#__PURE__*/React.createElement(React.Fragment, {
|
|
key: index
|
|
}, content);
|
|
}
|
|
}, {
|
|
key: "renderLoader",
|
|
value: function renderLoader() {
|
|
var _this13 = this;
|
|
|
|
if (!this.props.loaderDisabled && this.props.showLoader && this.state.loading) {
|
|
var className = classNames('p-virtualscroller-loader', {
|
|
'p-component-overlay': !this.props.loadingTemplate
|
|
});
|
|
var content = /*#__PURE__*/React.createElement("i", {
|
|
className: "p-virtualscroller-loading-icon pi pi-spinner pi-spin"
|
|
});
|
|
|
|
if (this.props.loadingTemplate) {
|
|
var isBoth = this.isBoth();
|
|
var numItemsInViewport = this.state.numItemsInViewport;
|
|
content = this.state.loaderArr.map(function (_, index) {
|
|
return _this13.renderLoaderItem(index, isBoth && {
|
|
numCols: numItemsInViewport.cols
|
|
});
|
|
});
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: className
|
|
}, content);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderSpacer",
|
|
value: function renderSpacer() {
|
|
var _this14 = this;
|
|
|
|
if (this.props.showSpacer) {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this14.spacer = el;
|
|
},
|
|
className: "p-virtualscroller-spacer"
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderItem",
|
|
value: function renderItem(item, index) {
|
|
var options = this.getOptions(index);
|
|
var content = ObjectUtils.getJSXElement(this.props.itemTemplate, item, options);
|
|
return /*#__PURE__*/React.createElement(React.Fragment, {
|
|
key: options.index
|
|
}, content);
|
|
}
|
|
}, {
|
|
key: "renderItems",
|
|
value: function renderItems(loadedItems) {
|
|
var _this15 = this;
|
|
|
|
return loadedItems.map(function (item, index) {
|
|
return _this15.renderItem(item, index);
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
var _this16 = this;
|
|
|
|
var loadedItems = this.loadedItems();
|
|
var items = this.renderItems(loadedItems);
|
|
var className = classNames('p-virtualscroller-content', {
|
|
'p-virtualscroller-loading': this.state.loading
|
|
});
|
|
var content = /*#__PURE__*/React.createElement("div", {
|
|
className: className,
|
|
ref: function ref(el) {
|
|
return _this16.content = el;
|
|
}
|
|
}, items);
|
|
|
|
if (this.props.contentTemplate) {
|
|
var defaultOptions = {
|
|
className: className,
|
|
contentRef: function contentRef(el) {
|
|
return _this16.content = el;
|
|
},
|
|
spacerRef: function spacerRef(el) {
|
|
return _this16.spacer = el;
|
|
},
|
|
stickyRef: function stickyRef(el) {
|
|
return _this16.sticky = el;
|
|
},
|
|
items: loadedItems,
|
|
getItemOptions: function getItemOptions(index) {
|
|
return _this16.getOptions(index);
|
|
},
|
|
children: items,
|
|
element: content,
|
|
props: this.props,
|
|
loading: this.state.loading,
|
|
getLoaderOptions: function getLoaderOptions(index, ext) {
|
|
return _this16.loaderOptions(index, ext);
|
|
},
|
|
loadingTemplate: this.props.loadingTemplate,
|
|
itemSize: this.props.itemSize,
|
|
rows: this.getRows(),
|
|
columns: this.getColumns(),
|
|
vertical: this.isVertical(),
|
|
horizontal: this.isHorizontal(),
|
|
both: this.isBoth()
|
|
};
|
|
return ObjectUtils.getJSXElement(this.props.contentTemplate, defaultOptions);
|
|
}
|
|
|
|
return content;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this17 = this;
|
|
|
|
if (this.props.disabled) {
|
|
var content = ObjectUtils.getJSXElement(this.props.contentTemplate, {
|
|
items: this.props.items,
|
|
rows: this.props.items,
|
|
columns: this.props.columns
|
|
});
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, this.props.children, content);
|
|
} else {
|
|
var isBoth = this.isBoth();
|
|
var isHorizontal = this.isHorizontal();
|
|
var className = classNames('p-virtualscroller', {
|
|
'p-both-scroll': isBoth,
|
|
'p-horizontal-scroll': isHorizontal
|
|
}, this.props.className);
|
|
var loader = this.renderLoader();
|
|
|
|
var _content = this.renderContent();
|
|
|
|
var spacer = this.renderSpacer();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this17.el = el;
|
|
},
|
|
className: className,
|
|
tabIndex: 0,
|
|
style: this.props.style,
|
|
onScroll: this.onScroll
|
|
}, _content, spacer, loader);
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return VirtualScroller;
|
|
}(Component);
|
|
|
|
_defineProperty(VirtualScroller, "defaultProps", {
|
|
id: null,
|
|
style: null,
|
|
className: null,
|
|
items: null,
|
|
itemSize: 0,
|
|
scrollHeight: null,
|
|
scrollWidth: null,
|
|
orientation: 'vertical',
|
|
numToleratedItems: null,
|
|
delay: 0,
|
|
lazy: false,
|
|
disabled: false,
|
|
loaderDisabled: false,
|
|
columns: null,
|
|
loading: false,
|
|
showSpacer: true,
|
|
showLoader: false,
|
|
loadingTemplate: null,
|
|
itemTemplate: null,
|
|
contentTemplate: null,
|
|
onScroll: null,
|
|
onScrollIndexChange: null,
|
|
onLazyLoad: null
|
|
});
|
|
|
|
function ownKeys$M(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$M(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$M(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$M(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$2d(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$2d(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$2d() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
var AutoCompletePanelComponent = /*#__PURE__*/function (_Component) {
|
|
_inherits(AutoCompletePanelComponent, _Component);
|
|
|
|
var _super = _createSuper$2d(AutoCompletePanelComponent);
|
|
|
|
function AutoCompletePanelComponent() {
|
|
_classCallCheck(this, AutoCompletePanelComponent);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(AutoCompletePanelComponent, [{
|
|
key: "getOptionGroupRenderKey",
|
|
value: function getOptionGroupRenderKey(optionGroup) {
|
|
return ObjectUtils.resolveFieldData(optionGroup, this.props.optionGroupLabel);
|
|
}
|
|
}, {
|
|
key: "renderGroupChildren",
|
|
value: function renderGroupChildren(optionGroup, i) {
|
|
var _this = this;
|
|
|
|
var groupChildren = this.props.getOptionGroupChildren(optionGroup);
|
|
return groupChildren.map(function (item, j) {
|
|
var itemContent = _this.props.itemTemplate ? ObjectUtils.getJSXElement(_this.props.itemTemplate, item, j) : _this.props.field ? ObjectUtils.resolveFieldData(item, _this.props.field) : item;
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: j + '_item',
|
|
role: "option",
|
|
"aria-selected": _this.props.ariaSelected === item,
|
|
className: "p-autocomplete-item",
|
|
onClick: function onClick(e) {
|
|
return _this.props.onItemClick(e, item);
|
|
},
|
|
"data-group": i,
|
|
"data-index": j
|
|
}, itemContent, /*#__PURE__*/React.createElement(Ripple, null));
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderItem",
|
|
value: function renderItem(suggestion, index) {
|
|
var _this2 = this;
|
|
|
|
if (this.props.optionGroupLabel) {
|
|
var groupContent = this.props.optionGroupTemplate ? ObjectUtils.getJSXElement(this.props.optionGroupTemplate, suggestion, index) : this.props.getOptionGroupLabel(suggestion);
|
|
var groupChildrenContent = this.renderGroupChildren(suggestion, index);
|
|
var key = index + '_' + this.getOptionGroupRenderKey(suggestion);
|
|
return /*#__PURE__*/React.createElement(React.Fragment, {
|
|
key: key
|
|
}, /*#__PURE__*/React.createElement("li", {
|
|
className: "p-autocomplete-item-group"
|
|
}, groupContent), groupChildrenContent);
|
|
} else {
|
|
var itemContent = this.props.itemTemplate ? ObjectUtils.getJSXElement(this.props.itemTemplate, suggestion, index) : this.props.field ? ObjectUtils.resolveFieldData(suggestion, this.props.field) : suggestion;
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: index + '_item',
|
|
role: "option",
|
|
"aria-selected": this.props.ariaSelected === suggestion,
|
|
className: "p-autocomplete-item",
|
|
onClick: function onClick(e) {
|
|
return _this2.props.onItemClick(e, suggestion);
|
|
}
|
|
}, itemContent, /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderItems",
|
|
value: function renderItems() {
|
|
var _this3 = this;
|
|
|
|
if (this.props.suggestions) {
|
|
return this.props.suggestions.map(function (suggestion, index) {
|
|
return _this3.renderItem(suggestion, index);
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
var _this4 = this;
|
|
|
|
if (this.props.virtualScrollerOptions) {
|
|
var virtualScrollerProps = _objectSpread$M(_objectSpread$M({}, this.props.virtualScrollerOptions), {
|
|
style: _objectSpread$M(_objectSpread$M({}, this.props.virtualScrollerOptions.style), {
|
|
height: this.props.scrollHeight
|
|
}),
|
|
items: this.props.suggestions,
|
|
itemTemplate: function itemTemplate(item, options) {
|
|
return item && _this4.renderItem(item, options.index);
|
|
},
|
|
contentTemplate: function contentTemplate(options) {
|
|
var className = classNames('p-autocomplete-items', options.className);
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
ref: options.contentRef,
|
|
className: className,
|
|
role: "listbox",
|
|
id: _this4.props.listId
|
|
}, options.children);
|
|
}
|
|
});
|
|
|
|
return /*#__PURE__*/React.createElement(VirtualScroller, _extends({
|
|
ref: this.props.virtualScrollerRef
|
|
}, virtualScrollerProps));
|
|
} else {
|
|
var items = this.renderItems();
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
className: "p-autocomplete-items",
|
|
role: "listbox",
|
|
id: this.props.listId
|
|
}, items);
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
var panelClassName = classNames('p-autocomplete-panel p-component', this.props.panelClassName);
|
|
|
|
var panelStyle = _objectSpread$M({
|
|
maxHeight: this.props.scrollHeight
|
|
}, this.props.panelStyle);
|
|
|
|
var content = this.renderContent();
|
|
return /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.props.forwardRef,
|
|
classNames: "p-connected-overlay",
|
|
"in": this.props["in"],
|
|
timeout: {
|
|
enter: 120,
|
|
exit: 100
|
|
},
|
|
options: this.props.transitionOptions,
|
|
unmountOnExit: true,
|
|
onEnter: this.props.onEnter,
|
|
onEntering: this.props.onEntering,
|
|
onEntered: this.props.onEntered,
|
|
onExit: this.props.onExit,
|
|
onExited: this.props.onExited
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.props.forwardRef,
|
|
className: panelClassName,
|
|
style: panelStyle,
|
|
onClick: this.props.onClick
|
|
}, content));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var element = this.renderElement();
|
|
return /*#__PURE__*/React.createElement(Portal, {
|
|
element: element,
|
|
appendTo: this.props.appendTo
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return AutoCompletePanelComponent;
|
|
}(Component);
|
|
|
|
var AutoCompletePanel = /*#__PURE__*/React.forwardRef(function (props, ref) {
|
|
return /*#__PURE__*/React.createElement(AutoCompletePanelComponent, _extends({
|
|
forwardRef: ref
|
|
}, props));
|
|
});
|
|
|
|
var OverlayService = EventBus();
|
|
|
|
function ownKeys$L(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$L(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$L(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$L(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createForOfIteratorHelper$g(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$g(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$g(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$g(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$g(o, minLen); }
|
|
|
|
function _arrayLikeToArray$g(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 _createSuper$2c(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$2c(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$2c() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var AutoComplete = /*#__PURE__*/function (_Component) {
|
|
_inherits(AutoComplete, _Component);
|
|
|
|
var _super = _createSuper$2c(AutoComplete);
|
|
|
|
function AutoComplete(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, AutoComplete);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
id: _this.props.id,
|
|
searching: false,
|
|
focused: false,
|
|
overlayVisible: false
|
|
};
|
|
_this.onInputChange = _this.onInputChange.bind(_assertThisInitialized(_this));
|
|
_this.onInputFocus = _this.onInputFocus.bind(_assertThisInitialized(_this));
|
|
_this.onInputBlur = _this.onInputBlur.bind(_assertThisInitialized(_this));
|
|
_this.onInputKeyDown = _this.onInputKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onDropdownClick = _this.onDropdownClick.bind(_assertThisInitialized(_this));
|
|
_this.onMultiContainerClick = _this.onMultiContainerClick.bind(_assertThisInitialized(_this));
|
|
_this.onMultiInputFocus = _this.onMultiInputFocus.bind(_assertThisInitialized(_this));
|
|
_this.onMultiInputBlur = _this.onMultiInputBlur.bind(_assertThisInitialized(_this));
|
|
_this.selectItem = _this.selectItem.bind(_assertThisInitialized(_this));
|
|
_this.getOptionGroupLabel = _this.getOptionGroupLabel.bind(_assertThisInitialized(_this));
|
|
_this.getOptionGroupChildren = _this.getOptionGroupChildren.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEnter = _this.onOverlayEnter.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEntering = _this.onOverlayEntering.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEntered = _this.onOverlayEntered.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExit = _this.onOverlayExit.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExited = _this.onOverlayExited.bind(_assertThisInitialized(_this));
|
|
_this.onPanelClick = _this.onPanelClick.bind(_assertThisInitialized(_this));
|
|
_this.overlayRef = /*#__PURE__*/createRef();
|
|
_this.virtualScrollerRef = /*#__PURE__*/createRef();
|
|
_this.inputRef = /*#__PURE__*/createRef(_this.props.inputRef);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(AutoComplete, [{
|
|
key: "onInputChange",
|
|
value: function onInputChange(event) {
|
|
var _this2 = this;
|
|
|
|
//Cancel the search request if user types within the timeout
|
|
if (this.timeout) {
|
|
clearTimeout(this.timeout);
|
|
}
|
|
|
|
var query = event.target.value;
|
|
|
|
if (!this.props.multiple) {
|
|
this.updateModel(event, query);
|
|
}
|
|
|
|
if (query.length === 0) {
|
|
this.hideOverlay();
|
|
|
|
if (this.props.onClear) {
|
|
this.props.onClear(event);
|
|
}
|
|
} else {
|
|
if (query.length >= this.props.minLength) {
|
|
this.timeout = setTimeout(function () {
|
|
_this2.search(event, query, 'input');
|
|
}, this.props.delay);
|
|
} else {
|
|
this.hideOverlay();
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "search",
|
|
value: function search(event, query, source) {
|
|
//allow empty string but not undefined or null
|
|
if (query === undefined || query === null) {
|
|
return;
|
|
} //do not search blank values on input change
|
|
|
|
|
|
if (source === 'input' && query.trim().length === 0) {
|
|
return;
|
|
}
|
|
|
|
if (this.props.completeMethod) {
|
|
this.setState({
|
|
searching: true
|
|
});
|
|
this.props.completeMethod({
|
|
originalEvent: event,
|
|
query: query
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "selectItem",
|
|
value: function selectItem(event, option, preventInputFocus) {
|
|
if (this.props.multiple) {
|
|
this.inputRef.current.value = '';
|
|
|
|
if (!this.isSelected(option)) {
|
|
var newValue = this.props.value ? [].concat(_toConsumableArray(this.props.value), [option]) : [option];
|
|
this.updateModel(event, newValue);
|
|
}
|
|
} else {
|
|
this.updateInputField(option);
|
|
this.updateModel(event, option);
|
|
}
|
|
|
|
if (this.props.onSelect) {
|
|
this.props.onSelect({
|
|
originalEvent: event,
|
|
value: option
|
|
});
|
|
}
|
|
|
|
if (!preventInputFocus) {
|
|
this.inputRef.current.focus();
|
|
this.hideOverlay();
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateModel",
|
|
value: function updateModel(event, value) {
|
|
if (this.props.onChange) {
|
|
this.props.onChange({
|
|
originalEvent: event,
|
|
value: value,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.state.id,
|
|
value: value
|
|
}
|
|
});
|
|
}
|
|
|
|
this.ariaSelected = value;
|
|
}
|
|
}, {
|
|
key: "formatValue",
|
|
value: function formatValue(value) {
|
|
if (value) {
|
|
if (this.props.selectedItemTemplate && (this.props.multiple ? this.isSelected(value) : this.findOptionIndex(value) > -1)) {
|
|
var resolvedFieldData = ObjectUtils.getJSXElement(this.props.selectedItemTemplate, value);
|
|
return resolvedFieldData ? resolvedFieldData : value;
|
|
} else if (this.props.field) {
|
|
var _resolvedFieldData = ObjectUtils.resolveFieldData(value, this.props.field);
|
|
|
|
return _resolvedFieldData !== null && _resolvedFieldData !== undefined ? _resolvedFieldData : value;
|
|
} else return value;
|
|
} else return '';
|
|
}
|
|
}, {
|
|
key: "updateInputField",
|
|
value: function updateInputField(value) {
|
|
var formattedValue = this.formatValue(value);
|
|
this.inputRef.current.value = formattedValue;
|
|
}
|
|
}, {
|
|
key: "showOverlay",
|
|
value: function showOverlay() {
|
|
this.setState({
|
|
overlayVisible: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "hideOverlay",
|
|
value: function hideOverlay() {
|
|
this.setState({
|
|
overlayVisible: false,
|
|
searching: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "onOverlayEnter",
|
|
value: function onOverlayEnter() {
|
|
ZIndexUtils.set('overlay', this.overlayRef.current, PrimeReact.autoZIndex, PrimeReact.zIndex['overlay']);
|
|
this.alignOverlay();
|
|
}
|
|
}, {
|
|
key: "onOverlayEntering",
|
|
value: function onOverlayEntering() {
|
|
if (this.props.autoHighlight && this.props.suggestions && this.props.suggestions.length) {
|
|
DomHandler.addClass(this.overlayRef.current.firstChild.firstChild, 'p-highlight');
|
|
}
|
|
}
|
|
}, {
|
|
key: "onOverlayEntered",
|
|
value: function onOverlayEntered() {
|
|
this.bindDocumentClickListener();
|
|
this.bindScrollListener();
|
|
this.bindResizeListener();
|
|
this.props.onShow && this.props.onShow();
|
|
}
|
|
}, {
|
|
key: "onOverlayExit",
|
|
value: function onOverlayExit() {
|
|
this.unbindDocumentClickListener();
|
|
this.unbindScrollListener();
|
|
this.unbindResizeListener();
|
|
}
|
|
}, {
|
|
key: "onOverlayExited",
|
|
value: function onOverlayExited() {
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
this.props.onHide && this.props.onHide();
|
|
}
|
|
}, {
|
|
key: "alignOverlay",
|
|
value: function alignOverlay() {
|
|
var target = this.props.multiple ? this.multiContainer : this.inputRef.current;
|
|
DomHandler.alignOverlay(this.overlayRef.current, target, this.props.appendTo || PrimeReact.appendTo);
|
|
}
|
|
}, {
|
|
key: "onPanelClick",
|
|
value: function onPanelClick(event) {
|
|
OverlayService.emit('overlay-click', {
|
|
originalEvent: event,
|
|
target: this.container
|
|
});
|
|
}
|
|
}, {
|
|
key: "onDropdownClick",
|
|
value: function onDropdownClick(event) {
|
|
this.inputRef.current.focus();
|
|
if (this.props.dropdownMode === 'blank') this.search(event, '', 'dropdown');else if (this.props.dropdownMode === 'current') this.search(event, this.inputRef.current.value, 'dropdown');
|
|
|
|
if (this.props.onDropdownClick) {
|
|
this.props.onDropdownClick({
|
|
originalEvent: event,
|
|
query: this.inputRef.current.value
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "removeItem",
|
|
value: function removeItem(event, index) {
|
|
var removedValue = this.props.value[index];
|
|
var newValue = this.props.value.filter(function (val, i) {
|
|
return index !== i;
|
|
});
|
|
this.updateModel(event, newValue);
|
|
|
|
if (this.props.onUnselect) {
|
|
this.props.onUnselect({
|
|
originalEvent: event,
|
|
value: removedValue
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onInputKeyDown",
|
|
value: function onInputKeyDown(event) {
|
|
if (this.state.overlayVisible) {
|
|
var highlightItem = DomHandler.findSingle(this.overlayRef.current, 'li.p-highlight');
|
|
|
|
switch (event.which) {
|
|
//down
|
|
case 40:
|
|
if (highlightItem) {
|
|
var nextElement = this.findNextItem(highlightItem);
|
|
|
|
if (nextElement) {
|
|
DomHandler.addClass(nextElement, 'p-highlight');
|
|
DomHandler.removeClass(highlightItem, 'p-highlight');
|
|
DomHandler.scrollInView(this.overlayRef.current, nextElement);
|
|
}
|
|
} else {
|
|
highlightItem = DomHandler.findSingle(this.overlayRef.current, 'li');
|
|
|
|
if (DomHandler.hasClass(highlightItem, 'p-autocomplete-item-group')) {
|
|
highlightItem = this.findNextItem(highlightItem);
|
|
}
|
|
|
|
if (highlightItem) {
|
|
DomHandler.addClass(highlightItem, 'p-highlight');
|
|
}
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//up
|
|
|
|
case 38:
|
|
if (highlightItem) {
|
|
var previousElement = this.findPrevItem(highlightItem);
|
|
|
|
if (previousElement) {
|
|
DomHandler.addClass(previousElement, 'p-highlight');
|
|
DomHandler.removeClass(highlightItem, 'p-highlight');
|
|
DomHandler.scrollInView(this.overlayRef.current, previousElement);
|
|
}
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//enter
|
|
|
|
case 13:
|
|
if (highlightItem) {
|
|
this.selectHighlightItem(event, highlightItem);
|
|
this.hideOverlay();
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//escape
|
|
|
|
case 27:
|
|
this.hideOverlay();
|
|
event.preventDefault();
|
|
break;
|
|
//tab
|
|
|
|
case 9:
|
|
if (highlightItem) {
|
|
this.selectHighlightItem(event, highlightItem);
|
|
}
|
|
|
|
this.hideOverlay();
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (this.props.multiple) {
|
|
switch (event.which) {
|
|
//backspace
|
|
case 8:
|
|
if (this.props.value && this.props.value.length && !this.inputRef.current.value) {
|
|
var removedValue = this.props.value[this.props.value.length - 1];
|
|
var newValue = this.props.value.slice(0, -1);
|
|
this.updateModel(event, newValue);
|
|
|
|
if (this.props.onUnselect) {
|
|
this.props.onUnselect({
|
|
originalEvent: event,
|
|
value: removedValue
|
|
});
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "selectHighlightItem",
|
|
value: function selectHighlightItem(event, item) {
|
|
if (this.props.optionGroupLabel) {
|
|
var optionGroup = this.props.suggestions[item.dataset.group];
|
|
this.selectItem(event, this.getOptionGroupChildren(optionGroup)[item.dataset.index]);
|
|
} else {
|
|
this.selectItem(event, this.props.suggestions[DomHandler.index(item)]);
|
|
}
|
|
}
|
|
}, {
|
|
key: "findNextItem",
|
|
value: function findNextItem(item) {
|
|
var nextItem = item.nextElementSibling;
|
|
return nextItem ? DomHandler.hasClass(nextItem, 'p-autocomplete-item-group') ? this.findNextItem(nextItem) : nextItem : null;
|
|
}
|
|
}, {
|
|
key: "findPrevItem",
|
|
value: function findPrevItem(item) {
|
|
var prevItem = item.previousElementSibling;
|
|
return prevItem ? DomHandler.hasClass(prevItem, 'p-autocomplete-item-group') ? this.findPrevItem(prevItem) : prevItem : null;
|
|
}
|
|
}, {
|
|
key: "onInputFocus",
|
|
value: function onInputFocus(event) {
|
|
var _this3 = this;
|
|
|
|
event.persist();
|
|
this.setState({
|
|
focused: true
|
|
}, function () {
|
|
if (_this3.props.onFocus) {
|
|
_this3.props.onFocus(event);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "forceItemSelection",
|
|
value: function forceItemSelection(event) {
|
|
var valid = false;
|
|
var inputValue = event.target.value.trim();
|
|
|
|
if (this.props.suggestions) {
|
|
var _iterator = _createForOfIteratorHelper$g(this.props.suggestions),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var item = _step.value;
|
|
var itemValue = this.props.field ? ObjectUtils.resolveFieldData(item, this.props.field) : item;
|
|
|
|
if (itemValue && inputValue === itemValue.trim()) {
|
|
valid = true;
|
|
this.selectItem(event, item, true);
|
|
break;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
}
|
|
|
|
if (!valid) {
|
|
this.inputRef.current.value = '';
|
|
this.updateModel(event, null);
|
|
|
|
if (this.props.onClear) {
|
|
this.props.onClear(event);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onInputBlur",
|
|
value: function onInputBlur(event) {
|
|
var _this4 = this;
|
|
|
|
event.persist();
|
|
this.setState({
|
|
focused: false
|
|
}, function () {
|
|
if (_this4.props.forceSelection) {
|
|
_this4.forceItemSelection(event);
|
|
}
|
|
|
|
if (_this4.props.onBlur) {
|
|
_this4.props.onBlur(event);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onMultiContainerClick",
|
|
value: function onMultiContainerClick(event) {
|
|
this.inputRef.current.focus();
|
|
|
|
if (this.props.onClick) {
|
|
this.props.onClick(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onMultiInputFocus",
|
|
value: function onMultiInputFocus(event) {
|
|
this.onInputFocus(event);
|
|
DomHandler.addClass(this.multiContainer, 'p-focus');
|
|
}
|
|
}, {
|
|
key: "onMultiInputBlur",
|
|
value: function onMultiInputBlur(event) {
|
|
this.onInputBlur(event);
|
|
DomHandler.removeClass(this.multiContainer, 'p-focus');
|
|
}
|
|
}, {
|
|
key: "isSelected",
|
|
value: function isSelected(val) {
|
|
var selected = false;
|
|
|
|
if (this.props.value && this.props.value.length) {
|
|
for (var i = 0; i < this.props.value.length; i++) {
|
|
if (ObjectUtils.equals(this.props.value[i], val)) {
|
|
selected = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return selected;
|
|
}
|
|
}, {
|
|
key: "findOptionIndex",
|
|
value: function findOptionIndex(option) {
|
|
var index = -1;
|
|
|
|
if (this.props.suggestions) {
|
|
for (var i = 0; i < this.props.suggestions.length; i++) {
|
|
if (ObjectUtils.equals(option, this.props.suggestions[i])) {
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return index;
|
|
}
|
|
}, {
|
|
key: "getOptionGroupLabel",
|
|
value: function getOptionGroupLabel(optionGroup) {
|
|
return this.props.optionGroupLabel ? ObjectUtils.resolveFieldData(optionGroup, this.props.optionGroupLabel) : optionGroup;
|
|
}
|
|
}, {
|
|
key: "getOptionGroupChildren",
|
|
value: function getOptionGroupChildren(optionGroup) {
|
|
return ObjectUtils.resolveFieldData(optionGroup, this.props.optionGroupChildren);
|
|
}
|
|
}, {
|
|
key: "bindDocumentClickListener",
|
|
value: function bindDocumentClickListener() {
|
|
var _this5 = this;
|
|
|
|
if (!this.documentClickListener) {
|
|
this.documentClickListener = function (event) {
|
|
if (event.which === 3) {
|
|
// right click
|
|
return;
|
|
}
|
|
|
|
if (_this5.state.overlayVisible && _this5.isOutsideClicked(event)) {
|
|
_this5.hideOverlay();
|
|
}
|
|
};
|
|
|
|
document.addEventListener('click', this.documentClickListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentClickListener",
|
|
value: function unbindDocumentClickListener() {
|
|
if (this.documentClickListener) {
|
|
document.removeEventListener('click', this.documentClickListener);
|
|
this.documentClickListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindScrollListener",
|
|
value: function bindScrollListener() {
|
|
var _this6 = this;
|
|
|
|
if (!this.scrollHandler) {
|
|
this.scrollHandler = new ConnectedOverlayScrollHandler(this.container, function () {
|
|
if (_this6.state.overlayVisible) {
|
|
_this6.hideOverlay();
|
|
}
|
|
});
|
|
}
|
|
|
|
this.scrollHandler.bindScrollListener();
|
|
}
|
|
}, {
|
|
key: "unbindScrollListener",
|
|
value: function unbindScrollListener() {
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.unbindScrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindResizeListener",
|
|
value: function bindResizeListener() {
|
|
var _this7 = this;
|
|
|
|
if (!this.resizeListener) {
|
|
this.resizeListener = function () {
|
|
if (_this7.state.overlayVisible && !DomHandler.isTouchDevice()) {
|
|
_this7.hideOverlay();
|
|
}
|
|
};
|
|
|
|
window.addEventListener('resize', this.resizeListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindResizeListener",
|
|
value: function unbindResizeListener() {
|
|
if (this.resizeListener) {
|
|
window.removeEventListener('resize', this.resizeListener);
|
|
this.resizeListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "isOutsideClicked",
|
|
value: function isOutsideClicked(event) {
|
|
return this.container && this.overlayRef && this.overlayRef.current && !this.overlayRef.current.contains(event.target) && !this.isInputClicked(event);
|
|
}
|
|
}, {
|
|
key: "isInputClicked",
|
|
value: function isInputClicked(event) {
|
|
if (this.props.multiple) return event.target === this.multiContainer || this.multiContainer.contains(event.target);else return event.target === this.inputRef.current;
|
|
}
|
|
}, {
|
|
key: "updateInputRef",
|
|
value: function updateInputRef() {
|
|
var ref = this.props.inputRef;
|
|
|
|
if (ref) {
|
|
if (typeof ref === 'function') {
|
|
ref(this.inputRef.current);
|
|
} else {
|
|
ref.current = this.inputRef.current;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.updateInputRef();
|
|
|
|
if (!this.state.id) {
|
|
this.setState({
|
|
id: UniqueComponentId()
|
|
});
|
|
}
|
|
|
|
if (this.props.autoFocus && this.inputRef && this.inputRef.current) {
|
|
this.inputRef.current.focus();
|
|
}
|
|
|
|
if (this.props.tooltip) {
|
|
this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.suggestions !== this.props.suggestions && this.state.searching) {
|
|
if (this.props.suggestions && this.props.suggestions.length) {
|
|
this.showOverlay();
|
|
} else {
|
|
this.hideOverlay();
|
|
}
|
|
|
|
this.setState({
|
|
searching: false
|
|
});
|
|
}
|
|
|
|
if (this.inputRef && this.inputRef.current && !this.props.multiple) {
|
|
this.updateInputField(this.props.value);
|
|
}
|
|
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$L({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.unbindDocumentClickListener();
|
|
this.unbindResizeListener();
|
|
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.destroy();
|
|
this.scrollHandler = null;
|
|
}
|
|
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
|
|
if (this.timeout) {
|
|
clearTimeout(this.timeout);
|
|
}
|
|
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.container,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderSimpleAutoComplete",
|
|
value: function renderSimpleAutoComplete() {
|
|
var inputClassName = classNames('p-autocomplete-input', this.props.inputClassName, {
|
|
'p-autocomplete-dd-input': this.props.dropdown
|
|
});
|
|
return /*#__PURE__*/React.createElement(InputText, {
|
|
ref: this.inputRef,
|
|
id: this.props.inputId,
|
|
type: this.props.type,
|
|
name: this.props.name,
|
|
defaultValue: this.formatValue(this.props.value),
|
|
role: "searchbox",
|
|
"aria-autocomplete": "list",
|
|
"aria-controls": this.state.id + '_list',
|
|
"aria-labelledby": this.props.ariaLabelledBy,
|
|
className: inputClassName,
|
|
style: this.props.inputStyle,
|
|
autoComplete: "off",
|
|
readOnly: this.props.readOnly,
|
|
disabled: this.props.disabled,
|
|
placeholder: this.props.placeholder,
|
|
size: this.props.size,
|
|
maxLength: this.props.maxLength,
|
|
tabIndex: this.props.tabIndex,
|
|
onBlur: this.onInputBlur,
|
|
onFocus: this.onInputFocus,
|
|
onChange: this.onInputChange,
|
|
onMouseDown: this.props.onMouseDown,
|
|
onKeyUp: this.props.onKeyUp,
|
|
onKeyDown: this.onInputKeyDown,
|
|
onKeyPress: this.props.onKeyPress,
|
|
onContextMenu: this.props.onContextMenu,
|
|
onClick: this.props.onClick,
|
|
onDoubleClick: this.props.onDblClick
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderChips",
|
|
value: function renderChips() {
|
|
var _this8 = this;
|
|
|
|
if (this.props.value && this.props.value.length) {
|
|
return this.props.value.map(function (val, index) {
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: index + 'multi-item',
|
|
className: "p-autocomplete-token p-highlight"
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-autocomplete-token-label"
|
|
}, _this8.formatValue(val)), !_this8.props.disabled && IconUtils.getJSXIcon(_this8.props.removeIcon, {
|
|
className: 'p-autocomplete-token-icon',
|
|
onClick: function onClick(e) {
|
|
return _this8.removeItem(e, index);
|
|
}
|
|
}, {
|
|
props: _this8.props
|
|
}));
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderMultiInput",
|
|
value: function renderMultiInput() {
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
className: "p-autocomplete-input-token"
|
|
}, /*#__PURE__*/React.createElement("input", {
|
|
ref: this.inputRef,
|
|
type: this.props.type,
|
|
disabled: this.props.disabled,
|
|
placeholder: this.props.placeholder,
|
|
role: "searchbox",
|
|
"aria-autocomplete": "list",
|
|
"aria-controls": this.state.id + '_list',
|
|
"aria-labelledby": this.props.ariaLabelledBy,
|
|
autoComplete: "off",
|
|
tabIndex: this.props.tabIndex,
|
|
onChange: this.onInputChange,
|
|
id: this.props.inputId,
|
|
name: this.props.name,
|
|
style: this.props.inputStyle,
|
|
className: this.props.inputClassName,
|
|
maxLength: this.props.maxLength,
|
|
onKeyUp: this.props.onKeyUp,
|
|
onKeyDown: this.onInputKeyDown,
|
|
onKeyPress: this.props.onKeyPress,
|
|
onFocus: this.onMultiInputFocus,
|
|
onBlur: this.onMultiInputBlur
|
|
}));
|
|
}
|
|
}, {
|
|
key: "renderMultipleAutoComplete",
|
|
value: function renderMultipleAutoComplete() {
|
|
var _this9 = this;
|
|
|
|
var multiContainerClass = classNames('p-autocomplete-multiple-container p-component p-inputtext', {
|
|
'p-disabled': this.props.disabled
|
|
});
|
|
var tokens = this.renderChips();
|
|
var input = this.renderMultiInput();
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
ref: function ref(el) {
|
|
_this9.multiContainer = el;
|
|
},
|
|
className: multiContainerClass,
|
|
onContextMenu: this.props.onContextMenu,
|
|
onMouseDown: this.props.onMouseDown,
|
|
onClick: this.onMultiContainerClick,
|
|
onDoubleClick: this.props.onDblClick
|
|
}, tokens, input);
|
|
}
|
|
}, {
|
|
key: "renderDropdown",
|
|
value: function renderDropdown() {
|
|
var _this10 = this;
|
|
|
|
return /*#__PURE__*/React.createElement(Button, {
|
|
ref: function ref(el) {
|
|
return _this10.dropdownButton = el;
|
|
},
|
|
type: "button",
|
|
icon: this.props.dropdownIcon,
|
|
className: "p-autocomplete-dropdown",
|
|
disabled: this.props.disabled,
|
|
onClick: this.onDropdownClick
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderLoader",
|
|
value: function renderLoader() {
|
|
if (this.state.searching) {
|
|
return /*#__PURE__*/React.createElement("i", {
|
|
className: "p-autocomplete-loader pi pi-spinner pi-spin"
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this11 = this;
|
|
|
|
var input, dropdown;
|
|
var className = classNames('p-autocomplete p-component p-inputwrapper', this.props.className, {
|
|
'p-autocomplete-dd': this.props.dropdown,
|
|
'p-autocomplete-multiple': this.props.multiple,
|
|
'p-inputwrapper-filled': this.props.value,
|
|
'p-inputwrapper-focus': this.state.focused
|
|
});
|
|
var loader = this.renderLoader();
|
|
if (this.props.multiple) input = this.renderMultipleAutoComplete();else input = this.renderSimpleAutoComplete();
|
|
|
|
if (this.props.dropdown) {
|
|
dropdown = this.renderDropdown();
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
ref: function ref(el) {
|
|
return _this11.container = el;
|
|
},
|
|
id: this.state.id,
|
|
style: this.props.style,
|
|
className: className,
|
|
"aria-haspopup": "listbox",
|
|
"aria-expanded": this.state.overlayVisible,
|
|
"aria-owns": this.state.id + '_list'
|
|
}, input, loader, dropdown, /*#__PURE__*/React.createElement(AutoCompletePanel, _extends({
|
|
ref: this.overlayRef,
|
|
virtualScrollerRef: this.virtualScrollerRef
|
|
}, this.props, {
|
|
listId: this.state.id + '_list',
|
|
onItemClick: this.selectItem,
|
|
ariaSelected: this.ariaSelected,
|
|
onClick: this.onPanelClick,
|
|
getOptionGroupLabel: this.getOptionGroupLabel,
|
|
getOptionGroupChildren: this.getOptionGroupChildren,
|
|
"in": this.state.overlayVisible,
|
|
onEnter: this.onOverlayEnter,
|
|
onEntering: this.onOverlayEntering,
|
|
onEntered: this.onOverlayEntered,
|
|
onExit: this.onOverlayExit,
|
|
onExited: this.onOverlayExited
|
|
})));
|
|
}
|
|
}]);
|
|
|
|
return AutoComplete;
|
|
}(Component);
|
|
|
|
_defineProperty(AutoComplete, "defaultProps", {
|
|
id: null,
|
|
inputRef: null,
|
|
value: null,
|
|
name: null,
|
|
type: 'text',
|
|
suggestions: null,
|
|
field: null,
|
|
optionGroupLabel: null,
|
|
optionGroupChildren: null,
|
|
optionGroupTemplate: null,
|
|
forceSelection: false,
|
|
autoHighlight: false,
|
|
virtualScrollerOptions: null,
|
|
scrollHeight: '200px',
|
|
dropdown: false,
|
|
dropdownMode: 'blank',
|
|
multiple: false,
|
|
minLength: 1,
|
|
delay: 300,
|
|
style: null,
|
|
className: null,
|
|
inputId: null,
|
|
inputStyle: null,
|
|
inputClassName: null,
|
|
panelClassName: null,
|
|
panelStyle: null,
|
|
placeholder: null,
|
|
readOnly: false,
|
|
disabled: false,
|
|
maxLength: null,
|
|
size: null,
|
|
appendTo: null,
|
|
tabIndex: null,
|
|
autoFocus: false,
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
ariaLabelledBy: null,
|
|
completeMethod: null,
|
|
itemTemplate: null,
|
|
selectedItemTemplate: null,
|
|
transitionOptions: null,
|
|
dropdownIcon: 'pi pi-chevron-down',
|
|
removeIcon: 'pi pi-times-circle',
|
|
onChange: null,
|
|
onFocus: null,
|
|
onBlur: null,
|
|
onSelect: null,
|
|
onUnselect: null,
|
|
onDropdownClick: null,
|
|
onClick: null,
|
|
onDblClick: null,
|
|
onMouseDown: null,
|
|
onKeyUp: null,
|
|
onKeyPress: null,
|
|
onContextMenu: null,
|
|
onClear: null,
|
|
onShow: null,
|
|
onHide: null
|
|
});
|
|
|
|
function _createSuper$2b(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$2b(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$2b() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Avatar = /*#__PURE__*/function (_Component) {
|
|
_inherits(Avatar, _Component);
|
|
|
|
var _super = _createSuper$2b(Avatar);
|
|
|
|
function Avatar() {
|
|
_classCallCheck(this, Avatar);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(Avatar, [{
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
var _this = this;
|
|
|
|
if (this.props.label) {
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: "p-avatar-text"
|
|
}, this.props.label);
|
|
} else if (this.props.icon) {
|
|
return IconUtils.getJSXIcon(this.props.icon, {
|
|
className: 'p-avatar-icon'
|
|
}, {
|
|
props: this.props
|
|
});
|
|
} else if (this.props.image) {
|
|
var onError = function onError(e) {
|
|
if (_this.props.onImageError) {
|
|
_this.props.onImageError(e);
|
|
}
|
|
};
|
|
|
|
return /*#__PURE__*/React.createElement("img", {
|
|
src: this.props.image,
|
|
alt: this.props.imageAlt,
|
|
onError: onError
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var containerClassName = classNames('p-avatar p-component', {
|
|
'p-avatar-image': this.props.image != null,
|
|
'p-avatar-circle': this.props.shape === 'circle',
|
|
'p-avatar-lg': this.props.size === 'large',
|
|
'p-avatar-xl': this.props.size === 'xlarge',
|
|
'p-avatar-clickable': !!this.props.onClick
|
|
}, this.props.className);
|
|
var content = this.props.template ? ObjectUtils.getJSXElement(this.props.template, this.props) : this.renderContent();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: containerClassName,
|
|
style: this.props.style,
|
|
onClick: this.props.onClick
|
|
}, content, this.props.children);
|
|
}
|
|
}]);
|
|
|
|
return Avatar;
|
|
}(Component);
|
|
|
|
_defineProperty(Avatar, "defaultProps", {
|
|
label: null,
|
|
icon: null,
|
|
image: null,
|
|
size: 'normal',
|
|
shape: 'square',
|
|
style: null,
|
|
className: null,
|
|
template: null,
|
|
imageAlt: 'avatar',
|
|
onImageError: null,
|
|
onClick: null
|
|
});
|
|
|
|
function _createSuper$2a(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$2a(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$2a() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var AvatarGroup = /*#__PURE__*/function (_Component) {
|
|
_inherits(AvatarGroup, _Component);
|
|
|
|
var _super = _createSuper$2a(AvatarGroup);
|
|
|
|
function AvatarGroup() {
|
|
_classCallCheck(this, AvatarGroup);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(AvatarGroup, [{
|
|
key: "render",
|
|
value: function render() {
|
|
var containerClassName = classNames('p-avatar-group p-component', this.props.className);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: containerClassName,
|
|
style: this.props.style
|
|
}, this.props.children);
|
|
}
|
|
}]);
|
|
|
|
return AvatarGroup;
|
|
}(Component);
|
|
|
|
_defineProperty(AvatarGroup, "defaultProps", {
|
|
style: null,
|
|
className: null
|
|
});
|
|
|
|
function _createSuper$29(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$29(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$29() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Badge = /*#__PURE__*/function (_Component) {
|
|
_inherits(Badge, _Component);
|
|
|
|
var _super = _createSuper$29(Badge);
|
|
|
|
function Badge() {
|
|
_classCallCheck(this, Badge);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(Badge, [{
|
|
key: "render",
|
|
value: function render() {
|
|
var badgeClassName = classNames('p-badge p-component', {
|
|
'p-badge-no-gutter': this.props.value && String(this.props.value).length === 1,
|
|
'p-badge-dot': !this.props.value,
|
|
'p-badge-lg': this.props.size === 'large',
|
|
'p-badge-xl': this.props.size === 'xlarge',
|
|
'p-badge-info': this.props.severity === 'info',
|
|
'p-badge-success': this.props.severity === 'success',
|
|
'p-badge-warning': this.props.severity === 'warning',
|
|
'p-badge-danger': this.props.severity === 'danger'
|
|
}, this.props.className);
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: badgeClassName,
|
|
style: this.props.style
|
|
}, this.props.value);
|
|
}
|
|
}]);
|
|
|
|
return Badge;
|
|
}(Component);
|
|
|
|
_defineProperty(Badge, "defaultProps", {
|
|
value: null,
|
|
severity: null,
|
|
size: null,
|
|
style: null,
|
|
className: null
|
|
});
|
|
|
|
function _createSuper$28(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$28(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$28() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var BreadCrumb = /*#__PURE__*/function (_Component) {
|
|
_inherits(BreadCrumb, _Component);
|
|
|
|
var _super = _createSuper$28(BreadCrumb);
|
|
|
|
function BreadCrumb() {
|
|
_classCallCheck(this, BreadCrumb);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(BreadCrumb, [{
|
|
key: "itemClick",
|
|
value: function itemClick(event, item) {
|
|
if (item.disabled) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
if (!item.url) {
|
|
event.preventDefault();
|
|
}
|
|
|
|
if (item.command) {
|
|
item.command({
|
|
originalEvent: event,
|
|
item: item
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderHome",
|
|
value: function renderHome() {
|
|
var _this = this;
|
|
|
|
if (this.props.home) {
|
|
var className = classNames('p-breadcrumb-home', {
|
|
'p-disabled': this.props.home.disabled
|
|
}, this.props.home.className);
|
|
var iconClassName = classNames('p-menuitem-icon', this.props.home.icon);
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
className: className,
|
|
style: this.props.home.style
|
|
}, /*#__PURE__*/React.createElement("a", {
|
|
href: this.props.home.url || '#',
|
|
className: "p-menuitem-link",
|
|
"aria-disabled": this.props.home.disabled,
|
|
target: this.props.home.target,
|
|
onClick: function onClick(event) {
|
|
return _this.itemClick(event, _this.props.home);
|
|
}
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
})));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderSeparator",
|
|
value: function renderSeparator() {
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
className: "p-breadcrumb-chevron pi pi-chevron-right"
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderMenuitem",
|
|
value: function renderMenuitem(item) {
|
|
var _this2 = this;
|
|
|
|
var className = classNames(item.className, {
|
|
'p-disabled': item.disabled
|
|
});
|
|
var label = item.label && /*#__PURE__*/React.createElement("span", {
|
|
className: "p-menuitem-text"
|
|
}, item.label);
|
|
var content = /*#__PURE__*/React.createElement("a", {
|
|
href: item.url || '#',
|
|
className: "p-menuitem-link",
|
|
target: item.target,
|
|
onClick: function onClick(event) {
|
|
return _this2.itemClick(event, item);
|
|
},
|
|
"aria-disabled": item.disabled
|
|
}, label);
|
|
|
|
if (item.template) {
|
|
var defaultContentOptions = {
|
|
onClick: function onClick(event) {
|
|
return _this2.itemClick(event, item);
|
|
},
|
|
className: 'p-menuitem-link',
|
|
labelClassName: 'p-menuitem-text',
|
|
element: content,
|
|
props: this.props
|
|
};
|
|
content = ObjectUtils.getJSXElement(item.template, item, defaultContentOptions);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
className: className,
|
|
style: item.style
|
|
}, content);
|
|
}
|
|
}, {
|
|
key: "renderMenuitems",
|
|
value: function renderMenuitems() {
|
|
var _this3 = this;
|
|
|
|
if (this.props.model) {
|
|
var items = this.props.model.map(function (item, index) {
|
|
var menuitem = _this3.renderMenuitem(item);
|
|
|
|
var separator = index === _this3.props.model.length - 1 ? null : _this3.renderSeparator();
|
|
return /*#__PURE__*/React.createElement(React.Fragment, {
|
|
key: item.label + '_' + index
|
|
}, menuitem, separator);
|
|
});
|
|
return items;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-breadcrumb p-component', this.props.className);
|
|
var home = this.renderHome();
|
|
var items = this.renderMenuitems();
|
|
var separator = this.renderSeparator();
|
|
return /*#__PURE__*/React.createElement("nav", {
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style,
|
|
"aria-label": "Breadcrumb"
|
|
}, /*#__PURE__*/React.createElement("ul", null, home, separator, items));
|
|
}
|
|
}]);
|
|
|
|
return BreadCrumb;
|
|
}(Component);
|
|
|
|
_defineProperty(BreadCrumb, "defaultProps", {
|
|
id: null,
|
|
model: null,
|
|
home: null,
|
|
style: null,
|
|
className: null
|
|
});
|
|
|
|
function _createSuper$27(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$27(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$27() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
var CalendarPanelComponent = /*#__PURE__*/function (_Component) {
|
|
_inherits(CalendarPanelComponent, _Component);
|
|
|
|
var _super = _createSuper$27(CalendarPanelComponent);
|
|
|
|
function CalendarPanelComponent() {
|
|
_classCallCheck(this, CalendarPanelComponent);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(CalendarPanelComponent, [{
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
return /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.props.forwardRef,
|
|
classNames: "p-connected-overlay",
|
|
"in": this.props["in"],
|
|
timeout: {
|
|
enter: 120,
|
|
exit: 100
|
|
},
|
|
options: this.props.transitionOptions,
|
|
unmountOnExit: true,
|
|
onEnter: this.props.onEnter,
|
|
onEntered: this.props.onEntered,
|
|
onExit: this.props.onExit,
|
|
onExited: this.props.onExited
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.props.forwardRef,
|
|
className: this.props.className,
|
|
style: this.props.style,
|
|
onClick: this.props.onClick,
|
|
onMouseUp: this.props.onMouseUp
|
|
}, this.props.children));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var element = this.renderElement();
|
|
return this.props.inline ? element : /*#__PURE__*/React.createElement(Portal, {
|
|
element: element,
|
|
appendTo: this.props.appendTo
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return CalendarPanelComponent;
|
|
}(Component);
|
|
|
|
_defineProperty(CalendarPanelComponent, "defaultProps", {
|
|
appendTo: null,
|
|
style: null,
|
|
className: null
|
|
});
|
|
|
|
var CalendarPanel = /*#__PURE__*/React.forwardRef(function (props, ref) {
|
|
return /*#__PURE__*/React.createElement(CalendarPanelComponent, _extends({
|
|
forwardRef: ref
|
|
}, props));
|
|
});
|
|
|
|
function _createForOfIteratorHelper$f(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$f(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$f(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$f(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$f(o, minLen); }
|
|
|
|
function _arrayLikeToArray$f(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 ownKeys$K(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$K(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$K(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$K(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$26(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$26(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$26() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Calendar = /*#__PURE__*/function (_Component) {
|
|
_inherits(Calendar, _Component);
|
|
|
|
var _super = _createSuper$26(Calendar);
|
|
|
|
function Calendar(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Calendar);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
focused: false,
|
|
overlayVisible: false
|
|
};
|
|
|
|
if (!_this.props.onViewDateChange) {
|
|
var viewDate = _this.getViewDate(_this.props.viewDate);
|
|
|
|
_this.validateDate(viewDate);
|
|
|
|
_this.state = _objectSpread$K(_objectSpread$K({}, _this.state), {}, {
|
|
viewDate: viewDate
|
|
});
|
|
}
|
|
|
|
_this.navigation = null;
|
|
_this.onUserInput = _this.onUserInput.bind(_assertThisInitialized(_this));
|
|
_this.onInputFocus = _this.onInputFocus.bind(_assertThisInitialized(_this));
|
|
_this.onInputBlur = _this.onInputBlur.bind(_assertThisInitialized(_this));
|
|
_this.onInputKeyDown = _this.onInputKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onButtonClick = _this.onButtonClick.bind(_assertThisInitialized(_this));
|
|
_this.onPrevButtonClick = _this.onPrevButtonClick.bind(_assertThisInitialized(_this));
|
|
_this.onNextButtonClick = _this.onNextButtonClick.bind(_assertThisInitialized(_this));
|
|
_this.onMonthDropdownChange = _this.onMonthDropdownChange.bind(_assertThisInitialized(_this));
|
|
_this.onYearDropdownChange = _this.onYearDropdownChange.bind(_assertThisInitialized(_this));
|
|
_this.onTodayButtonClick = _this.onTodayButtonClick.bind(_assertThisInitialized(_this));
|
|
_this.onClearButtonClick = _this.onClearButtonClick.bind(_assertThisInitialized(_this));
|
|
_this.onPanelClick = _this.onPanelClick.bind(_assertThisInitialized(_this));
|
|
_this.onPanelMouseUp = _this.onPanelMouseUp.bind(_assertThisInitialized(_this));
|
|
_this.incrementHour = _this.incrementHour.bind(_assertThisInitialized(_this));
|
|
_this.decrementHour = _this.decrementHour.bind(_assertThisInitialized(_this));
|
|
_this.incrementMinute = _this.incrementMinute.bind(_assertThisInitialized(_this));
|
|
_this.decrementMinute = _this.decrementMinute.bind(_assertThisInitialized(_this));
|
|
_this.incrementSecond = _this.incrementSecond.bind(_assertThisInitialized(_this));
|
|
_this.decrementSecond = _this.decrementSecond.bind(_assertThisInitialized(_this));
|
|
_this.toggleAmPm = _this.toggleAmPm.bind(_assertThisInitialized(_this));
|
|
_this.onTimePickerElementMouseDown = _this.onTimePickerElementMouseDown.bind(_assertThisInitialized(_this));
|
|
_this.onTimePickerElementMouseUp = _this.onTimePickerElementMouseUp.bind(_assertThisInitialized(_this));
|
|
_this.onTimePickerElementMouseLeave = _this.onTimePickerElementMouseLeave.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEnter = _this.onOverlayEnter.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEntered = _this.onOverlayEntered.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExit = _this.onOverlayExit.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExited = _this.onOverlayExited.bind(_assertThisInitialized(_this));
|
|
_this.reFocusInputField = _this.reFocusInputField.bind(_assertThisInitialized(_this));
|
|
_this.overlayRef = /*#__PURE__*/createRef();
|
|
_this.inputRef = /*#__PURE__*/createRef(_this.props.inputRef);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Calendar, [{
|
|
key: "updateInputRef",
|
|
value: function updateInputRef() {
|
|
var ref = this.props.inputRef;
|
|
|
|
if (ref) {
|
|
if (typeof ref === 'function') {
|
|
ref(this.inputRef.current);
|
|
} else {
|
|
ref.current = this.inputRef.current;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
var _this2 = this;
|
|
|
|
this.updateInputRef();
|
|
|
|
if (this.props.tooltip) {
|
|
this.renderTooltip();
|
|
}
|
|
|
|
if (this.props.inline) {
|
|
this.initFocusableCell();
|
|
} else if (this.props.mask) {
|
|
mask(this.inputRef.current, {
|
|
mask: this.props.mask,
|
|
readOnly: this.props.readOnlyInput || this.props.disabled,
|
|
onChange: function onChange(e) {
|
|
return _this2.updateValueOnInput(e.originalEvent, e.value);
|
|
}
|
|
});
|
|
}
|
|
|
|
if (this.props.value) {
|
|
this.updateInputfield(this.props.value);
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
var _this3 = this;
|
|
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$K({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
}
|
|
|
|
if (!this.props.onViewDateChange && !this.viewStateChanged) {
|
|
var propValue = this.props.value;
|
|
|
|
if (Array.isArray(propValue)) {
|
|
propValue = propValue[0];
|
|
}
|
|
|
|
var prevPropValue = prevProps.value;
|
|
|
|
if (Array.isArray(prevPropValue)) {
|
|
prevPropValue = prevPropValue[0];
|
|
}
|
|
|
|
if (!prevPropValue && propValue || propValue && propValue instanceof Date && propValue.getTime() !== prevPropValue.getTime()) {
|
|
var viewDate = this.props.viewDate && this.isValidDate(this.props.viewDate) ? this.props.viewDate : propValue && this.isValidDate(propValue) ? propValue : new Date();
|
|
this.validateDate(viewDate);
|
|
this.setState({
|
|
viewDate: viewDate
|
|
}, function () {
|
|
_this3.viewStateChanged = true;
|
|
});
|
|
}
|
|
}
|
|
|
|
if (this.overlayRef && this.overlayRef.current) {
|
|
this.updateFocus();
|
|
}
|
|
|
|
if (prevProps.value !== this.props.value && (!this.viewStateChanged || !this.isVisible()) || this.isOptionChanged(prevProps)) {
|
|
this.updateInputfield(this.props.value);
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.hideTimeout) {
|
|
clearTimeout(this.hideTimeout);
|
|
}
|
|
|
|
if (this.touchUIMask) {
|
|
this.disableModality();
|
|
this.touchUIMask = null;
|
|
}
|
|
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
|
|
this.unbindDocumentClickListener();
|
|
this.unbindDocumentResizeListener();
|
|
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.destroy();
|
|
this.scrollHandler = null;
|
|
}
|
|
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.inputRef.current,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "isVisible",
|
|
value: function isVisible() {
|
|
return this.props.onVisibleChange ? this.props.visible : this.state.overlayVisible;
|
|
}
|
|
}, {
|
|
key: "isOptionChanged",
|
|
value: function isOptionChanged(prevProps) {
|
|
var _this4 = this;
|
|
|
|
var optionProps = ['dateFormat', 'hourFormat', 'timeOnly', 'showSeconds', 'showMillisec'];
|
|
return optionProps.some(function (option) {
|
|
return prevProps[option] !== _this4.props[option];
|
|
});
|
|
}
|
|
}, {
|
|
key: "getDateFormat",
|
|
value: function getDateFormat() {
|
|
return this.props.dateFormat || localeOption('dateFormat', this.props.locale);
|
|
}
|
|
}, {
|
|
key: "onInputFocus",
|
|
value: function onInputFocus(event) {
|
|
var _this5 = this;
|
|
|
|
if (this.ignoreFocusFunctionality) {
|
|
this.setState({
|
|
focused: true
|
|
}, function () {
|
|
_this5.ignoreFocusFunctionality = false;
|
|
});
|
|
} else {
|
|
event.persist();
|
|
|
|
if (this.props.showOnFocus && !this.isVisible()) {
|
|
this.showOverlay();
|
|
}
|
|
|
|
this.setState({
|
|
focused: true
|
|
}, function () {
|
|
if (_this5.props.onFocus) {
|
|
_this5.props.onFocus(event);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onInputBlur",
|
|
value: function onInputBlur(event) {
|
|
var _this6 = this;
|
|
|
|
event.persist();
|
|
this.setState({
|
|
focused: false
|
|
}, function () {
|
|
if (_this6.props.onBlur) {
|
|
_this6.props.onBlur(event);
|
|
}
|
|
|
|
if (!_this6.props.keepInvalid) {
|
|
_this6.updateInputfield(_this6.props.value);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onInputKeyDown",
|
|
value: function onInputKeyDown(event) {
|
|
this.isKeydown = true;
|
|
|
|
switch (event.which) {
|
|
//escape
|
|
case 27:
|
|
{
|
|
this.hideOverlay();
|
|
break;
|
|
}
|
|
//tab
|
|
|
|
case 9:
|
|
{
|
|
if (this.isVisible()) {
|
|
this.trapFocus(event);
|
|
}
|
|
|
|
if (this.props.touchUI) {
|
|
this.disableModality();
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onUserInput",
|
|
value: function onUserInput(event) {
|
|
// IE 11 Workaround for input placeholder
|
|
if (!this.isKeydown) {
|
|
return;
|
|
}
|
|
|
|
this.isKeydown = false;
|
|
this.updateValueOnInput(event, event.target.value);
|
|
|
|
if (this.props.onInput) {
|
|
this.props.onInput(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateValueOnInput",
|
|
value: function updateValueOnInput(event, rawValue) {
|
|
try {
|
|
var value = this.parseValueFromString(rawValue);
|
|
|
|
if (this.isValidSelection(value)) {
|
|
this.updateModel(event, value);
|
|
this.updateViewDate(event, value.length ? value[0] : value);
|
|
}
|
|
} catch (err) {
|
|
//invalid date
|
|
var _value = this.props.keepInvalid ? rawValue : null;
|
|
|
|
this.updateModel(event, _value);
|
|
}
|
|
}
|
|
}, {
|
|
key: "reFocusInputField",
|
|
value: function reFocusInputField() {
|
|
if (!this.props.inline && this.inputRef.current) {
|
|
this.ignoreFocusFunctionality = true;
|
|
this.inputRef.current.focus();
|
|
}
|
|
}
|
|
}, {
|
|
key: "isValidSelection",
|
|
value: function isValidSelection(value) {
|
|
var _this7 = this;
|
|
|
|
var isValid = true;
|
|
|
|
if (this.isSingleSelection()) {
|
|
if (!(this.isSelectable(value.getDate(), value.getMonth(), value.getFullYear(), false) && this.isSelectableTime(value))) {
|
|
isValid = false;
|
|
}
|
|
} else if (value.every(function (v) {
|
|
return _this7.isSelectable(v.getDate(), v.getMonth(), v.getFullYear(), false) && _this7.isSelectableTime(v);
|
|
})) {
|
|
if (this.isRangeSelection()) {
|
|
isValid = value.length > 1 && value[1] > value[0] ? true : false;
|
|
}
|
|
}
|
|
|
|
return isValid;
|
|
}
|
|
}, {
|
|
key: "onButtonClick",
|
|
value: function onButtonClick() {
|
|
if (this.isVisible()) {
|
|
this.hideOverlay();
|
|
} else {
|
|
this.showOverlay();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onPrevButtonClick",
|
|
value: function onPrevButtonClick(event) {
|
|
this.navigation = {
|
|
backward: true,
|
|
button: true
|
|
};
|
|
this.navBackward(event);
|
|
}
|
|
}, {
|
|
key: "onNextButtonClick",
|
|
value: function onNextButtonClick(event) {
|
|
this.navigation = {
|
|
backward: false,
|
|
button: true
|
|
};
|
|
this.navForward(event);
|
|
}
|
|
}, {
|
|
key: "onContainerButtonKeydown",
|
|
value: function onContainerButtonKeydown(event) {
|
|
switch (event.which) {
|
|
//tab
|
|
case 9:
|
|
this.trapFocus(event);
|
|
break;
|
|
//escape
|
|
|
|
case 27:
|
|
this.hideOverlay(null, this.reFocusInputField);
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
}
|
|
}, {
|
|
key: "trapFocus",
|
|
value: function trapFocus(event) {
|
|
event.preventDefault();
|
|
var focusableElements = DomHandler.getFocusableElements(this.overlayRef.current);
|
|
|
|
if (focusableElements && focusableElements.length > 0) {
|
|
if (!document.activeElement) {
|
|
focusableElements[0].focus();
|
|
} else {
|
|
var focusedIndex = focusableElements.indexOf(document.activeElement);
|
|
|
|
if (event.shiftKey) {
|
|
if (focusedIndex === -1 || focusedIndex === 0) focusableElements[focusableElements.length - 1].focus();else focusableElements[focusedIndex - 1].focus();
|
|
} else {
|
|
if (focusedIndex === -1 || focusedIndex === focusableElements.length - 1) focusableElements[0].focus();else focusableElements[focusedIndex + 1].focus();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateFocus",
|
|
value: function updateFocus() {
|
|
var cell;
|
|
|
|
if (this.navigation) {
|
|
if (this.navigation.button) {
|
|
this.initFocusableCell();
|
|
if (this.navigation.backward) DomHandler.findSingle(this.overlayRef.current, '.p-datepicker-prev').focus();else DomHandler.findSingle(this.overlayRef.current, '.p-datepicker-next').focus();
|
|
} else {
|
|
if (this.navigation.backward) {
|
|
var cells = DomHandler.find(this.overlayRef.current, '.p-datepicker-calendar td span:not(.p-disabled)');
|
|
cell = cells[cells.length - 1];
|
|
} else {
|
|
cell = DomHandler.findSingle(this.overlayRef.current, '.p-datepicker-calendar td span:not(.p-disabled)');
|
|
}
|
|
|
|
if (cell) {
|
|
cell.tabIndex = '0';
|
|
cell.focus();
|
|
}
|
|
}
|
|
|
|
this.navigation = null;
|
|
} else {
|
|
this.initFocusableCell();
|
|
}
|
|
}
|
|
}, {
|
|
key: "initFocusableCell",
|
|
value: function initFocusableCell() {
|
|
var cell;
|
|
|
|
if (this.view === 'month') {
|
|
var cells = DomHandler.find(this.overlayRef.current, '.p-monthpicker .p-monthpicker-month');
|
|
var selectedCell = DomHandler.findSingle(this.overlayRef.current, '.p-monthpicker .p-monthpicker-month.p-highlight');
|
|
cells.forEach(function (cell) {
|
|
return cell.tabIndex = -1;
|
|
});
|
|
cell = selectedCell || cells[0];
|
|
} else {
|
|
cell = DomHandler.findSingle(this.overlayRef.current, 'span.p-highlight');
|
|
|
|
if (!cell) {
|
|
var todayCell = DomHandler.findSingle(this.overlayRef.current, 'td.p-datepicker-today span:not(.p-disabled)');
|
|
if (todayCell) cell = todayCell;else cell = DomHandler.findSingle(this.overlayRef.current, '.p-datepicker-calendar td span:not(.p-disabled)');
|
|
}
|
|
}
|
|
|
|
if (cell) {
|
|
cell.tabIndex = '0';
|
|
}
|
|
}
|
|
}, {
|
|
key: "navBackward",
|
|
value: function navBackward(event) {
|
|
if (this.props.disabled) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
var newViewDate = new Date(this.getViewDate().getTime());
|
|
newViewDate.setDate(1);
|
|
|
|
if (this.props.view === 'date') {
|
|
if (newViewDate.getMonth() === 0) {
|
|
newViewDate.setMonth(11);
|
|
newViewDate.setFullYear(newViewDate.getFullYear() - 1);
|
|
} else {
|
|
newViewDate.setMonth(newViewDate.getMonth() - 1);
|
|
}
|
|
} else if (this.props.view === 'month') {
|
|
var currentYear = newViewDate.getFullYear();
|
|
var newYear = currentYear - 1;
|
|
|
|
if (this.props.yearNavigator) {
|
|
var minYear = parseInt(this.props.yearRange.split(':')[0], 10);
|
|
|
|
if (newYear < minYear) {
|
|
newYear = minYear;
|
|
}
|
|
}
|
|
|
|
newViewDate.setFullYear(newYear);
|
|
}
|
|
|
|
this.updateViewDate(event, newViewDate);
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "navForward",
|
|
value: function navForward(event) {
|
|
if (this.props.disabled) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
var newViewDate = new Date(this.getViewDate().getTime());
|
|
newViewDate.setDate(1);
|
|
|
|
if (this.props.view === 'date') {
|
|
if (newViewDate.getMonth() === 11) {
|
|
newViewDate.setMonth(0);
|
|
newViewDate.setFullYear(newViewDate.getFullYear() + 1);
|
|
} else {
|
|
newViewDate.setMonth(newViewDate.getMonth() + 1);
|
|
}
|
|
} else if (this.props.view === 'month') {
|
|
var currentYear = newViewDate.getFullYear();
|
|
var newYear = currentYear + 1;
|
|
|
|
if (this.props.yearNavigator) {
|
|
var maxYear = parseInt(this.props.yearRange.split(':')[1], 10);
|
|
|
|
if (newYear > maxYear) {
|
|
newYear = maxYear;
|
|
}
|
|
}
|
|
|
|
newViewDate.setFullYear(newYear);
|
|
}
|
|
|
|
this.updateViewDate(event, newViewDate);
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onMonthDropdownChange",
|
|
value: function onMonthDropdownChange(event, value) {
|
|
var currentViewDate = this.getViewDate();
|
|
var newViewDate = new Date(currentViewDate.getTime());
|
|
newViewDate.setMonth(parseInt(value, 10));
|
|
this.updateViewDate(event, newViewDate);
|
|
}
|
|
}, {
|
|
key: "onYearDropdownChange",
|
|
value: function onYearDropdownChange(event, value) {
|
|
var currentViewDate = this.getViewDate();
|
|
var newViewDate = new Date(currentViewDate.getTime());
|
|
newViewDate.setFullYear(parseInt(value, 10));
|
|
this.updateViewDate(event, newViewDate);
|
|
}
|
|
}, {
|
|
key: "onTodayButtonClick",
|
|
value: function onTodayButtonClick(event) {
|
|
var today = new Date();
|
|
var dateMeta = {
|
|
day: today.getDate(),
|
|
month: today.getMonth(),
|
|
year: today.getFullYear(),
|
|
today: true,
|
|
selectable: true
|
|
};
|
|
var timeMeta = {
|
|
hours: today.getHours(),
|
|
minutes: today.getMinutes(),
|
|
seconds: today.getSeconds(),
|
|
milliseconds: today.getMilliseconds()
|
|
};
|
|
this.updateViewDate(event, today);
|
|
this.onDateSelect(event, dateMeta, timeMeta);
|
|
|
|
if (this.props.onTodayButtonClick) {
|
|
this.props.onTodayButtonClick(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onClearButtonClick",
|
|
value: function onClearButtonClick(event) {
|
|
this.updateModel(event, null);
|
|
this.updateInputfield(null);
|
|
this.hideOverlay(null, this.reFocusInputField);
|
|
|
|
if (this.props.onClearButtonClick) {
|
|
this.props.onClearButtonClick(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onPanelClick",
|
|
value: function onPanelClick(event) {
|
|
if (!this.props.inline) {
|
|
OverlayService.emit('overlay-click', {
|
|
originalEvent: event,
|
|
target: this.container
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onPanelMouseUp",
|
|
value: function onPanelMouseUp(event) {
|
|
this.onPanelClick(event);
|
|
}
|
|
}, {
|
|
key: "onTimePickerElementMouseDown",
|
|
value: function onTimePickerElementMouseDown(event, type, direction) {
|
|
if (!this.props.disabled) {
|
|
this.repeat(event, null, type, direction);
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onTimePickerElementMouseUp",
|
|
value: function onTimePickerElementMouseUp() {
|
|
if (!this.props.disabled) {
|
|
this.clearTimePickerTimer();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onTimePickerElementMouseLeave",
|
|
value: function onTimePickerElementMouseLeave() {
|
|
if (!this.props.disabled) {
|
|
this.clearTimePickerTimer();
|
|
}
|
|
}
|
|
}, {
|
|
key: "repeat",
|
|
value: function repeat(event, interval, type, direction) {
|
|
var _this8 = this;
|
|
|
|
event.persist();
|
|
var i = interval || 500;
|
|
this.clearTimePickerTimer();
|
|
this.timePickerTimer = setTimeout(function () {
|
|
_this8.repeat(event, 100, type, direction);
|
|
}, i);
|
|
|
|
switch (type) {
|
|
case 0:
|
|
if (direction === 1) this.incrementHour(event);else this.decrementHour(event);
|
|
break;
|
|
|
|
case 1:
|
|
if (direction === 1) this.incrementMinute(event);else this.decrementMinute(event);
|
|
break;
|
|
|
|
case 2:
|
|
if (direction === 1) this.incrementSecond(event);else this.decrementSecond(event);
|
|
break;
|
|
|
|
case 3:
|
|
if (direction === 1) this.incrementMilliSecond(event);else this.decrementMilliSecond(event);
|
|
break;
|
|
}
|
|
}
|
|
}, {
|
|
key: "clearTimePickerTimer",
|
|
value: function clearTimePickerTimer() {
|
|
if (this.timePickerTimer) {
|
|
clearTimeout(this.timePickerTimer);
|
|
}
|
|
}
|
|
}, {
|
|
key: "incrementHour",
|
|
value: function incrementHour(event) {
|
|
var currentTime = this.getCurrentDateTime();
|
|
var currentHour = currentTime.getHours();
|
|
var newHour = currentHour + this.props.stepHour;
|
|
newHour = newHour >= 24 ? newHour - 24 : newHour;
|
|
|
|
if (this.validateHour(newHour, currentTime)) {
|
|
if (this.props.maxDate && this.props.maxDate.toDateString() === currentTime.toDateString() && this.props.maxDate.getHours() === newHour) {
|
|
if (this.props.maxDate.getMinutes() < currentTime.getMinutes()) {
|
|
if (this.props.maxDate.getSeconds() < currentTime.getSeconds()) {
|
|
if (this.props.maxDate.getMilliseconds() < currentTime.getMilliseconds()) {
|
|
this.updateTime(event, newHour, this.props.maxDate.getMinutes(), this.props.maxDate.getSeconds(), this.props.maxDate.getMilliseconds());
|
|
} else {
|
|
this.updateTime(event, newHour, this.props.maxDate.getMinutes(), this.props.maxDate.getSeconds(), currentTime.getMilliseconds());
|
|
}
|
|
} else {
|
|
this.updateTime(event, newHour, this.props.maxDate.getMinutes(), currentTime.getSeconds(), currentTime.getMilliseconds());
|
|
}
|
|
} else if (this.props.maxDate.getMinutes() === currentTime.getMinutes()) {
|
|
if (this.props.maxDate.getSeconds() < currentTime.getSeconds()) {
|
|
if (this.props.maxDate.getMilliseconds() < currentTime.getMilliseconds()) {
|
|
this.updateTime(event, newHour, this.props.maxDate.getMinutes(), this.props.maxDate.getSeconds(), this.props.maxDate.getMilliseconds());
|
|
} else {
|
|
this.updateTime(event, newHour, this.props.maxDate.getMinutes(), this.props.maxDate.getSeconds(), currentTime.getMilliseconds());
|
|
}
|
|
} else {
|
|
this.updateTime(event, newHour, this.props.maxDate.getMinutes(), currentTime.getSeconds(), currentTime.getMilliseconds());
|
|
}
|
|
} else {
|
|
this.updateTime(event, newHour, currentTime.getMinutes(), currentTime.getSeconds(), currentTime.getMilliseconds());
|
|
}
|
|
} else {
|
|
this.updateTime(event, newHour, currentTime.getMinutes(), currentTime.getSeconds(), currentTime.getMilliseconds());
|
|
}
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "decrementHour",
|
|
value: function decrementHour(event) {
|
|
var currentTime = this.getCurrentDateTime();
|
|
var currentHour = currentTime.getHours();
|
|
var newHour = currentHour - this.props.stepHour;
|
|
newHour = newHour < 0 ? newHour + 24 : newHour;
|
|
|
|
if (this.validateHour(newHour, currentTime)) {
|
|
if (this.props.minDate && this.props.minDate.toDateString() === currentTime.toDateString() && this.props.minDate.getHours() === newHour) {
|
|
if (this.props.minDate.getMinutes() > currentTime.getMinutes()) {
|
|
if (this.props.minDate.getSeconds() > currentTime.getSeconds()) {
|
|
if (this.props.minDate.getMilliseconds() > currentTime.getMilliseconds()) {
|
|
this.updateTime(event, newHour, this.props.minDate.getMinutes(), this.props.minDate.getSeconds(), this.props.minDate.getMilliseconds());
|
|
} else {
|
|
this.updateTime(event, newHour, this.props.minDate.getMinutes(), this.props.minDate.getSeconds(), currentTime.getMilliseconds());
|
|
}
|
|
} else {
|
|
this.updateTime(event, newHour, this.props.minDate.getMinutes(), currentTime.getSeconds(), currentTime.getMilliseconds());
|
|
}
|
|
} else if (this.props.minDate.getMinutes() === currentTime.getMinutes()) {
|
|
if (this.props.minDate.getSeconds() > currentTime.getSeconds()) {
|
|
if (this.props.minDate.getMilliseconds() > currentTime.getMilliseconds()) {
|
|
this.updateTime(event, newHour, this.props.minDate.getMinutes(), this.props.minDate.getSeconds(), this.props.minDate.getMilliseconds());
|
|
} else {
|
|
this.updateTime(event, newHour, this.props.minDate.getMinutes(), this.props.minDate.getSeconds(), currentTime.getMilliseconds());
|
|
}
|
|
} else {
|
|
this.updateTime(event, newHour, this.props.minDate.getMinutes(), currentTime.getSeconds(), currentTime.getMilliseconds());
|
|
}
|
|
} else {
|
|
this.updateTime(event, newHour, currentTime.getMinutes(), currentTime.getSeconds(), currentTime.getMilliseconds());
|
|
}
|
|
} else {
|
|
this.updateTime(event, newHour, currentTime.getMinutes(), currentTime.getSeconds(), currentTime.getMilliseconds());
|
|
}
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "doStepMinute",
|
|
value: function doStepMinute(currentMinute, step) {
|
|
if (this.props.stepMinute <= 1) {
|
|
return step ? currentMinute + step : currentMinute;
|
|
}
|
|
|
|
if (!step) {
|
|
step = this.props.stepMinute;
|
|
|
|
if (currentMinute % step === 0) {
|
|
return currentMinute;
|
|
}
|
|
}
|
|
|
|
var newMinute = currentMinute + step;
|
|
newMinute = Math.floor(newMinute / step) * step;
|
|
return newMinute;
|
|
}
|
|
}, {
|
|
key: "incrementMinute",
|
|
value: function incrementMinute(event) {
|
|
var currentTime = this.getCurrentDateTime();
|
|
var currentMinute = currentTime.getMinutes();
|
|
var newMinute = this.doStepMinute(currentMinute, this.props.stepMinute);
|
|
newMinute = newMinute > 59 ? newMinute - 60 : newMinute;
|
|
|
|
if (this.validateMinute(newMinute, currentTime)) {
|
|
if (this.props.maxDate && this.props.maxDate.toDateString() === currentTime.toDateString() && this.props.maxDate.getMinutes() === newMinute) {
|
|
if (this.props.maxDate.getSeconds() < currentTime.getSeconds()) {
|
|
if (this.props.maxDate.getMilliseconds() < currentTime.getMilliseconds()) {
|
|
this.updateTime(event, currentTime.getHours(), newMinute, this.props.maxDate.getSeconds(), this.props.maxDate.getMilliseconds());
|
|
} else {
|
|
this.updateTime(event, currentTime.getHours(), newMinute, this.props.maxDate.getSeconds(), currentTime.getMilliseconds());
|
|
}
|
|
} else {
|
|
this.updateTime(event, currentTime.getHours(), newMinute, currentTime.getSeconds(), currentTime.getMilliseconds());
|
|
}
|
|
} else {
|
|
this.updateTime(event, currentTime.getHours(), newMinute, currentTime.getSeconds(), currentTime.getMilliseconds());
|
|
}
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "decrementMinute",
|
|
value: function decrementMinute(event) {
|
|
var currentTime = this.getCurrentDateTime();
|
|
var currentMinute = currentTime.getMinutes();
|
|
var newMinute = this.doStepMinute(currentMinute, -this.props.stepMinute);
|
|
newMinute = newMinute < 0 ? newMinute + 60 : newMinute;
|
|
|
|
if (this.validateMinute(newMinute, currentTime)) {
|
|
if (this.props.minDate && this.props.minDate.toDateString() === currentTime.toDateString() && this.props.minDate.getMinutes() === newMinute) {
|
|
if (this.props.minDate.getSeconds() > currentTime.getSeconds()) {
|
|
if (this.props.minDate.getMilliseconds() > currentTime.getMilliseconds()) {
|
|
this.updateTime(event, currentTime.getHours(), newMinute, this.props.minDate.getSeconds(), this.props.minDate.getMilliseconds());
|
|
} else {
|
|
this.updateTime(event, currentTime.getHours(), newMinute, this.props.minDate.getSeconds(), currentTime.getMilliseconds());
|
|
}
|
|
} else {
|
|
this.updateTime(event, currentTime.getHours(), newMinute, currentTime.getSeconds(), currentTime.getMilliseconds());
|
|
}
|
|
} else {
|
|
this.updateTime(event, currentTime.getHours(), newMinute, currentTime.getSeconds(), currentTime.getMilliseconds());
|
|
}
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "incrementSecond",
|
|
value: function incrementSecond(event) {
|
|
var currentTime = this.getCurrentDateTime();
|
|
var currentSecond = currentTime.getSeconds();
|
|
var newSecond = currentSecond + this.props.stepSecond;
|
|
newSecond = newSecond > 59 ? newSecond - 60 : newSecond;
|
|
|
|
if (this.validateSecond(newSecond, currentTime)) {
|
|
if (this.props.maxDate && this.props.maxDate.toDateString() === currentTime.toDateString() && this.props.maxDate.getSeconds() === newSecond) {
|
|
if (this.props.maxDate.getMilliseconds() < currentTime.getMilliseconds()) {
|
|
this.updateTime(event, currentTime.getHours(), currentTime.getMinutes(), newSecond, this.props.maxDate.getMilliseconds());
|
|
} else {
|
|
this.updateTime(event, currentTime.getHours(), currentTime.getMinutes(), newSecond, currentTime.getMilliseconds());
|
|
}
|
|
} else {
|
|
this.updateTime(event, currentTime.getHours(), currentTime.getMinutes(), newSecond, currentTime.getMilliseconds());
|
|
}
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "decrementSecond",
|
|
value: function decrementSecond(event) {
|
|
var currentTime = this.getCurrentDateTime();
|
|
var currentSecond = currentTime.getSeconds();
|
|
var newSecond = currentSecond - this.props.stepSecond;
|
|
newSecond = newSecond < 0 ? newSecond + 60 : newSecond;
|
|
|
|
if (this.validateSecond(newSecond, currentTime)) {
|
|
if (this.props.minDate && this.props.minDate.toDateString() === currentTime.toDateString() && this.props.minDate.getSeconds() === newSecond) {
|
|
if (this.props.minDate.getMilliseconds() > currentTime.getMilliseconds()) {
|
|
this.updateTime(event, currentTime.getHours(), currentTime.getMinutes(), newSecond, this.props.minDate.getMilliseconds());
|
|
} else {
|
|
this.updateTime(event, currentTime.getHours(), currentTime.getMinutes(), newSecond, currentTime.getMilliseconds());
|
|
}
|
|
} else {
|
|
this.updateTime(event, currentTime.getHours(), currentTime.getMinutes(), newSecond, currentTime.getMilliseconds());
|
|
}
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "incrementMilliSecond",
|
|
value: function incrementMilliSecond(event) {
|
|
var currentTime = this.getCurrentDateTime();
|
|
var currentMillisecond = currentTime.getMilliseconds();
|
|
var newMillisecond = currentMillisecond + this.props.stepMillisec;
|
|
newMillisecond = newMillisecond > 999 ? newMillisecond - 1000 : newMillisecond;
|
|
|
|
if (this.validateMillisecond(newMillisecond, currentTime)) {
|
|
this.updateTime(event, currentTime.getHours(), currentTime.getMinutes(), currentTime.getSeconds(), newMillisecond);
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "decrementMilliSecond",
|
|
value: function decrementMilliSecond(event) {
|
|
var currentTime = this.getCurrentDateTime();
|
|
var currentMillisecond = currentTime.getMilliseconds();
|
|
var newMillisecond = currentMillisecond - this.props.stepMillisec;
|
|
newMillisecond = newMillisecond < 0 ? newMillisecond + 999 : newMillisecond;
|
|
|
|
if (this.validateMillisecond(newMillisecond, currentTime)) {
|
|
this.updateTime(event, currentTime.getHours(), currentTime.getMinutes(), currentTime.getSeconds(), newMillisecond);
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "toggleAmPm",
|
|
value: function toggleAmPm(event) {
|
|
var currentTime = this.getCurrentDateTime();
|
|
var currentHour = currentTime.getHours();
|
|
var newHour = currentHour >= 12 ? currentHour - 12 : currentHour + 12;
|
|
this.updateTime(event, newHour, currentTime.getMinutes(), currentTime.getSeconds(), currentTime.getMilliseconds());
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "getViewDate",
|
|
value: function getViewDate(date) {
|
|
var propValue = this.props.value;
|
|
var viewDate = date || (this.props.onViewDateChange ? this.props.viewDate : this.state.viewDate);
|
|
|
|
if (Array.isArray(propValue)) {
|
|
propValue = propValue[0];
|
|
}
|
|
|
|
return viewDate && this.isValidDate(viewDate) ? viewDate : propValue && this.isValidDate(propValue) ? propValue : new Date();
|
|
}
|
|
}, {
|
|
key: "getCurrentDateTime",
|
|
value: function getCurrentDateTime() {
|
|
if (this.isSingleSelection()) {
|
|
return this.props.value && this.props.value instanceof Date ? this.props.value : this.getViewDate();
|
|
} else if (this.isMultipleSelection()) {
|
|
if (this.props.value && this.props.value.length) {
|
|
return this.props.value[this.props.value.length - 1];
|
|
}
|
|
} else if (this.isRangeSelection()) {
|
|
if (this.props.value && this.props.value.length) {
|
|
var startDate = this.props.value[0];
|
|
var endDate = this.props.value[1];
|
|
return endDate || startDate;
|
|
}
|
|
}
|
|
|
|
return new Date();
|
|
}
|
|
}, {
|
|
key: "isValidDate",
|
|
value: function isValidDate(date) {
|
|
return date instanceof Date && !isNaN(date);
|
|
}
|
|
}, {
|
|
key: "validateHour",
|
|
value: function validateHour(hour, value) {
|
|
var valid = true;
|
|
var valueDateString = value ? value.toDateString() : null;
|
|
|
|
if (this.props.minDate && valueDateString && this.props.minDate.toDateString() === valueDateString) {
|
|
if (this.props.minDate.getHours() > hour) {
|
|
valid = false;
|
|
}
|
|
}
|
|
|
|
if (this.props.maxDate && valueDateString && this.props.maxDate.toDateString() === valueDateString) {
|
|
if (this.props.maxDate.getHours() < hour) {
|
|
valid = false;
|
|
}
|
|
}
|
|
|
|
return valid;
|
|
}
|
|
}, {
|
|
key: "validateMinute",
|
|
value: function validateMinute(minute, value) {
|
|
var valid = true;
|
|
var valueDateString = value ? value.toDateString() : null;
|
|
|
|
if (this.props.minDate && valueDateString && this.props.minDate.toDateString() === valueDateString) {
|
|
if (value.getHours() === this.props.minDate.getHours()) {
|
|
if (this.props.minDate.getMinutes() > minute) {
|
|
valid = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.props.maxDate && valueDateString && this.props.maxDate.toDateString() === valueDateString) {
|
|
if (value.getHours() === this.props.maxDate.getHours()) {
|
|
if (this.props.maxDate.getMinutes() < minute) {
|
|
valid = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return valid;
|
|
}
|
|
}, {
|
|
key: "validateSecond",
|
|
value: function validateSecond(second, value) {
|
|
var valid = true;
|
|
var valueDateString = value ? value.toDateString() : null;
|
|
|
|
if (this.props.minDate && valueDateString && this.props.minDate.toDateString() === valueDateString) {
|
|
if (value.getHours() === this.props.minDate.getHours() && value.getMinutes() === this.props.minDate.getMinutes()) {
|
|
if (this.props.minDate.getSeconds() > second) {
|
|
valid = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.props.maxDate && valueDateString && this.props.maxDate.toDateString() === valueDateString) {
|
|
if (value.getHours() === this.props.maxDate.getHours() && value.getMinutes() === this.props.maxDate.getMinutes()) {
|
|
if (this.props.maxDate.getSeconds() < second) {
|
|
valid = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return valid;
|
|
}
|
|
}, {
|
|
key: "validateMillisecond",
|
|
value: function validateMillisecond(millisecond, value) {
|
|
var valid = true;
|
|
var valueDateString = value ? value.toDateString() : null;
|
|
|
|
if (this.props.minDate && valueDateString && this.props.minDate.toDateString() === valueDateString) {
|
|
if (value.getHours() === this.props.minDate.getHours() && value.getSeconds() === this.props.minDate.getSeconds() && value.getMinutes() === this.props.minDate.getMinutes()) {
|
|
if (this.props.minDate.getMilliseconds() > millisecond) {
|
|
valid = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.props.maxDate && valueDateString && this.props.maxDate.toDateString() === valueDateString) {
|
|
if (value.getHours() === this.props.maxDate.getHours() && value.getSeconds() === this.props.maxDate.getSeconds() && value.getMinutes() === this.props.maxDate.getMinutes()) {
|
|
if (this.props.maxDate.getMilliseconds() < millisecond) {
|
|
valid = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return valid;
|
|
}
|
|
}, {
|
|
key: "validateDate",
|
|
value: function validateDate(value) {
|
|
if (this.props.yearNavigator) {
|
|
var viewYear = value.getFullYear();
|
|
var minRangeYear = this.props.yearRange ? parseInt(this.props.yearRange.split(':')[0], 10) : null;
|
|
var maxRangeYear = this.props.yearRange ? parseInt(this.props.yearRange.split(':')[1], 10) : null;
|
|
var minYear = this.props.minDate && minRangeYear != null ? Math.max(this.props.minDate.getFullYear(), minRangeYear) : this.props.minDate || minRangeYear;
|
|
var maxYear = this.props.maxDate && maxRangeYear != null ? Math.min(this.props.maxDate.getFullYear(), maxRangeYear) : this.props.maxDate || maxRangeYear;
|
|
|
|
if (minYear && minYear > viewYear) {
|
|
viewYear = minYear;
|
|
}
|
|
|
|
if (maxYear && maxYear < viewYear) {
|
|
viewYear = maxYear;
|
|
}
|
|
|
|
value.setFullYear(viewYear);
|
|
}
|
|
|
|
if (this.props.monthNavigator && this.props.view !== 'month') {
|
|
var viewMonth = value.getMonth();
|
|
var viewMonthWithMinMax = parseInt(this.isInMinYear(value) && Math.max(this.props.minDate.getMonth(), viewMonth).toString() || this.isInMaxYear(value) && Math.min(this.props.maxDate.getMonth(), viewMonth).toString() || viewMonth);
|
|
value.setMonth(viewMonthWithMinMax);
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateTime",
|
|
value: function updateTime(event, hour, minute, second, millisecond) {
|
|
var newDateTime = this.getCurrentDateTime();
|
|
newDateTime.setHours(hour);
|
|
newDateTime.setMinutes(minute);
|
|
newDateTime.setSeconds(second);
|
|
newDateTime.setMilliseconds(millisecond);
|
|
|
|
if (this.isMultipleSelection()) {
|
|
if (this.props.value && this.props.value.length) {
|
|
var value = _toConsumableArray(this.props.value);
|
|
|
|
value[value.length - 1] = newDateTime;
|
|
newDateTime = value;
|
|
} else {
|
|
newDateTime = [newDateTime];
|
|
}
|
|
} else if (this.isRangeSelection()) {
|
|
if (this.props.value && this.props.value.length) {
|
|
var startDate = this.props.value[0];
|
|
var endDate = this.props.value[1];
|
|
newDateTime = endDate ? [startDate, newDateTime] : [newDateTime, null];
|
|
} else {
|
|
newDateTime = [newDateTime, null];
|
|
}
|
|
}
|
|
|
|
this.updateModel(event, newDateTime);
|
|
|
|
if (this.props.onSelect) {
|
|
this.props.onSelect({
|
|
originalEvent: event,
|
|
value: newDateTime
|
|
});
|
|
}
|
|
|
|
this.updateInputfield(newDateTime);
|
|
}
|
|
}, {
|
|
key: "updateViewDate",
|
|
value: function updateViewDate(event, value) {
|
|
this.validateDate(value);
|
|
|
|
if (this.props.onViewDateChange) {
|
|
this.props.onViewDateChange({
|
|
originalEvent: event,
|
|
value: value
|
|
});
|
|
} else {
|
|
this.viewStateChanged = true;
|
|
this.setState({
|
|
viewDate: value
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDateCellKeydown",
|
|
value: function onDateCellKeydown(event, date, groupIndex) {
|
|
var cellContent = event.currentTarget;
|
|
var cell = cellContent.parentElement;
|
|
|
|
switch (event.which) {
|
|
//down arrow
|
|
case 40:
|
|
{
|
|
cellContent.tabIndex = '-1';
|
|
var cellIndex = DomHandler.index(cell);
|
|
var nextRow = cell.parentElement.nextElementSibling;
|
|
|
|
if (nextRow) {
|
|
var focusCell = nextRow.children[cellIndex].children[0];
|
|
|
|
if (DomHandler.hasClass(focusCell, 'p-disabled')) {
|
|
this.navigation = {
|
|
backward: false
|
|
};
|
|
this.navForward(event);
|
|
} else {
|
|
nextRow.children[cellIndex].children[0].tabIndex = '0';
|
|
nextRow.children[cellIndex].children[0].focus();
|
|
}
|
|
} else {
|
|
this.navigation = {
|
|
backward: false
|
|
};
|
|
this.navForward(event);
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
//up arrow
|
|
|
|
case 38:
|
|
{
|
|
cellContent.tabIndex = '-1';
|
|
|
|
var _cellIndex = DomHandler.index(cell);
|
|
|
|
var prevRow = cell.parentElement.previousElementSibling;
|
|
|
|
if (prevRow) {
|
|
var _focusCell = prevRow.children[_cellIndex].children[0];
|
|
|
|
if (DomHandler.hasClass(_focusCell, 'p-disabled')) {
|
|
this.navigation = {
|
|
backward: true
|
|
};
|
|
this.navBackward(event);
|
|
} else {
|
|
_focusCell.tabIndex = '0';
|
|
|
|
_focusCell.focus();
|
|
}
|
|
} else {
|
|
this.navigation = {
|
|
backward: true
|
|
};
|
|
this.navBackward(event);
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
//left arrow
|
|
|
|
case 37:
|
|
{
|
|
cellContent.tabIndex = '-1';
|
|
var prevCell = cell.previousElementSibling;
|
|
|
|
if (prevCell) {
|
|
var _focusCell2 = prevCell.children[0];
|
|
|
|
if (DomHandler.hasClass(_focusCell2, 'p-disabled')) {
|
|
this.navigateToMonth(true, groupIndex, event);
|
|
} else {
|
|
_focusCell2.tabIndex = '0';
|
|
|
|
_focusCell2.focus();
|
|
}
|
|
} else {
|
|
this.navigateToMonth(true, groupIndex, event);
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
//right arrow
|
|
|
|
case 39:
|
|
{
|
|
cellContent.tabIndex = '-1';
|
|
var nextCell = cell.nextElementSibling;
|
|
|
|
if (nextCell) {
|
|
var _focusCell3 = nextCell.children[0];
|
|
|
|
if (DomHandler.hasClass(_focusCell3, 'p-disabled')) {
|
|
this.navigateToMonth(false, groupIndex, event);
|
|
} else {
|
|
_focusCell3.tabIndex = '0';
|
|
|
|
_focusCell3.focus();
|
|
}
|
|
} else {
|
|
this.navigateToMonth(false, groupIndex, event);
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
//enter
|
|
|
|
case 13:
|
|
{
|
|
this.onDateSelect(event, date);
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
//escape
|
|
|
|
case 27:
|
|
{
|
|
this.hideOverlay(null, this.reFocusInputField);
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
//tab
|
|
|
|
case 9:
|
|
{
|
|
this.trapFocus(event);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "navigateToMonth",
|
|
value: function navigateToMonth(prev, groupIndex, event) {
|
|
if (prev) {
|
|
if (this.props.numberOfMonths === 1 || groupIndex === 0) {
|
|
this.navigation = {
|
|
backward: true
|
|
};
|
|
this.navBackward(event);
|
|
} else {
|
|
var prevMonthContainer = this.overlayRef.current.children[groupIndex - 1];
|
|
var cells = DomHandler.find(prevMonthContainer, '.p-datepicker-calendar td span:not(.p-disabled)');
|
|
var focusCell = cells[cells.length - 1];
|
|
focusCell.tabIndex = '0';
|
|
focusCell.focus();
|
|
}
|
|
} else {
|
|
if (this.props.numberOfMonths === 1 || groupIndex === this.props.numberOfMonths - 1) {
|
|
this.navigation = {
|
|
backward: false
|
|
};
|
|
this.navForward(event);
|
|
} else {
|
|
var nextMonthContainer = this.overlayRef.current.children[groupIndex + 1];
|
|
|
|
var _focusCell4 = DomHandler.findSingle(nextMonthContainer, '.p-datepicker-calendar td span:not(.p-disabled)');
|
|
|
|
_focusCell4.tabIndex = '0';
|
|
|
|
_focusCell4.focus();
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onMonthCellKeydown",
|
|
value: function onMonthCellKeydown(event, index) {
|
|
var cell = event.currentTarget;
|
|
|
|
switch (event.which) {
|
|
//arrows
|
|
case 38:
|
|
case 40:
|
|
{
|
|
cell.tabIndex = '-1';
|
|
var cells = cell.parentElement.children;
|
|
var cellIndex = DomHandler.index(cell);
|
|
var nextCell = cells[event.which === 40 ? cellIndex + 3 : cellIndex - 3];
|
|
|
|
if (nextCell) {
|
|
nextCell.tabIndex = '0';
|
|
nextCell.focus();
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
//left arrow
|
|
|
|
case 37:
|
|
{
|
|
cell.tabIndex = '-1';
|
|
var prevCell = cell.previousElementSibling;
|
|
|
|
if (prevCell) {
|
|
prevCell.tabIndex = '0';
|
|
prevCell.focus();
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
//right arrow
|
|
|
|
case 39:
|
|
{
|
|
cell.tabIndex = '-1';
|
|
var _nextCell = cell.nextElementSibling;
|
|
|
|
if (_nextCell) {
|
|
_nextCell.tabIndex = '0';
|
|
|
|
_nextCell.focus();
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
//enter
|
|
|
|
case 13:
|
|
{
|
|
this.onMonthSelect(event, index);
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
//escape
|
|
|
|
case 27:
|
|
{
|
|
this.hideOverlay(null, this.reFocusInputField);
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
//tab
|
|
|
|
case 9:
|
|
{
|
|
this.trapFocus(event);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDateSelect",
|
|
value: function onDateSelect(event, dateMeta, timeMeta) {
|
|
var _this9 = this;
|
|
|
|
if (this.props.disabled || !dateMeta.selectable) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
DomHandler.find(this.overlayRef.current, '.p-datepicker-calendar td span:not(.p-disabled)').forEach(function (cell) {
|
|
return cell.tabIndex = -1;
|
|
});
|
|
event.currentTarget.focus();
|
|
|
|
if (this.isMultipleSelection()) {
|
|
if (this.isSelected(dateMeta)) {
|
|
var value = this.props.value.filter(function (date, i) {
|
|
return !_this9.isDateEquals(date, dateMeta);
|
|
});
|
|
this.updateModel(event, value);
|
|
this.updateInputfield(value);
|
|
} else if (!this.props.maxDateCount || !this.props.value || this.props.maxDateCount > this.props.value.length) {
|
|
this.selectDate(event, dateMeta, timeMeta);
|
|
}
|
|
} else {
|
|
this.selectDate(event, dateMeta, timeMeta);
|
|
}
|
|
|
|
if (!this.props.inline && this.isSingleSelection() && (!this.props.showTime || this.props.hideOnDateTimeSelect)) {
|
|
setTimeout(function () {
|
|
_this9.hideOverlay('dateselect');
|
|
}, 100);
|
|
|
|
if (this.touchUIMask) {
|
|
this.disableModality();
|
|
}
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "selectTime",
|
|
value: function selectTime(date, timeMeta) {
|
|
if (this.props.showTime) {
|
|
var hours, minutes, seconds, milliseconds;
|
|
|
|
if (timeMeta) {
|
|
hours = timeMeta.hours;
|
|
minutes = timeMeta.minutes;
|
|
seconds = timeMeta.seconds;
|
|
milliseconds = timeMeta.milliseconds;
|
|
} else {
|
|
var time = this.getCurrentDateTime();
|
|
var _ref = [time.getHours(), time.getMinutes(), time.getSeconds(), time.getMilliseconds()];
|
|
hours = _ref[0];
|
|
minutes = _ref[1];
|
|
seconds = _ref[2];
|
|
milliseconds = _ref[3];
|
|
}
|
|
|
|
date.setHours(hours);
|
|
date.setMinutes(minutes);
|
|
date.setSeconds(seconds);
|
|
date.setMilliseconds(milliseconds);
|
|
}
|
|
}
|
|
}, {
|
|
key: "selectDate",
|
|
value: function selectDate(event, dateMeta, timeMeta) {
|
|
var date = new Date(dateMeta.year, dateMeta.month, dateMeta.day);
|
|
this.selectTime(date, timeMeta);
|
|
|
|
if (this.props.minDate && this.props.minDate > date) {
|
|
date = this.props.minDate;
|
|
}
|
|
|
|
if (this.props.maxDate && this.props.maxDate < date) {
|
|
date = this.props.maxDate;
|
|
}
|
|
|
|
var selectedValues = date;
|
|
|
|
if (this.isSingleSelection()) {
|
|
this.updateModel(event, date);
|
|
} else if (this.isMultipleSelection()) {
|
|
selectedValues = this.props.value ? [].concat(_toConsumableArray(this.props.value), [date]) : [date];
|
|
this.updateModel(event, selectedValues);
|
|
} else if (this.isRangeSelection()) {
|
|
if (this.props.value && this.props.value.length) {
|
|
var startDate = this.props.value[0];
|
|
var endDate = this.props.value[1];
|
|
|
|
if (!endDate) {
|
|
if (date.getTime() >= startDate.getTime()) {
|
|
endDate = date;
|
|
} else {
|
|
endDate = startDate;
|
|
startDate = date;
|
|
}
|
|
} else {
|
|
startDate = date;
|
|
endDate = null;
|
|
}
|
|
|
|
selectedValues = [startDate, endDate];
|
|
this.updateModel(event, selectedValues);
|
|
} else {
|
|
selectedValues = [date, null];
|
|
this.updateModel(event, selectedValues);
|
|
}
|
|
}
|
|
|
|
if (this.props.onSelect) {
|
|
this.props.onSelect({
|
|
originalEvent: event,
|
|
value: date
|
|
});
|
|
}
|
|
|
|
this.updateInputfield(selectedValues);
|
|
}
|
|
}, {
|
|
key: "onMonthSelect",
|
|
value: function onMonthSelect(event, month) {
|
|
this.onDateSelect(event, {
|
|
year: this.getViewDate().getFullYear(),
|
|
month: month,
|
|
day: 1,
|
|
selectable: true
|
|
});
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "updateModel",
|
|
value: function updateModel(event, value) {
|
|
if (this.props.onChange) {
|
|
var newValue = value && value instanceof Date ? new Date(value.getTime()) : value;
|
|
this.viewStateChanged = true;
|
|
this.props.onChange({
|
|
originalEvent: event,
|
|
value: newValue,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: newValue
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "showOverlay",
|
|
value: function showOverlay(type) {
|
|
var _this10 = this;
|
|
|
|
if (this.props.onVisibleChange) {
|
|
this.props.onVisibleChange({
|
|
visible: true,
|
|
type: type
|
|
});
|
|
} else {
|
|
this.setState({
|
|
overlayVisible: true
|
|
}, function () {
|
|
_this10.overlayEventListener = function (e) {
|
|
if (!_this10.isOutsideClicked(e.target)) {
|
|
_this10.isOverlayClicked = true;
|
|
}
|
|
};
|
|
|
|
OverlayService.on('overlay-click', _this10.overlayEventListener);
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "hideOverlay",
|
|
value: function hideOverlay(type, callback) {
|
|
var _this11 = this;
|
|
|
|
var _hideCallback = function _hideCallback() {
|
|
_this11.viewStateChanged = false;
|
|
_this11.ignoreFocusFunctionality = false;
|
|
_this11.isOverlayClicked = false;
|
|
|
|
if (callback) {
|
|
callback();
|
|
}
|
|
|
|
OverlayService.off('overlay-click', _this11.overlayEventListener);
|
|
_this11.overlayEventListener = null;
|
|
};
|
|
|
|
if (this.props.onVisibleChange) this.props.onVisibleChange({
|
|
visible: false,
|
|
type: type,
|
|
callback: _hideCallback
|
|
});else this.setState({
|
|
overlayVisible: false
|
|
}, _hideCallback);
|
|
}
|
|
}, {
|
|
key: "onOverlayEnter",
|
|
value: function onOverlayEnter() {
|
|
if (this.props.autoZIndex) {
|
|
var key = this.props.touchUI ? 'modal' : 'overlay';
|
|
ZIndexUtils.set(key, this.overlayRef.current, PrimeReact.autoZIndex, this.props.baseZIndex || PrimeReact.zIndex[key]);
|
|
}
|
|
|
|
this.alignOverlay();
|
|
}
|
|
}, {
|
|
key: "onOverlayEntered",
|
|
value: function onOverlayEntered() {
|
|
this.bindDocumentClickListener();
|
|
this.bindDocumentResizeListener();
|
|
this.bindScrollListener();
|
|
this.props.onShow && this.props.onShow();
|
|
}
|
|
}, {
|
|
key: "onOverlayExit",
|
|
value: function onOverlayExit() {
|
|
this.unbindDocumentClickListener();
|
|
this.unbindDocumentResizeListener();
|
|
this.unbindScrollListener();
|
|
}
|
|
}, {
|
|
key: "onOverlayExited",
|
|
value: function onOverlayExited() {
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
this.props.onHide && this.props.onHide();
|
|
}
|
|
}, {
|
|
key: "bindDocumentClickListener",
|
|
value: function bindDocumentClickListener() {
|
|
var _this12 = this;
|
|
|
|
if (!this.documentClickListener) {
|
|
this.documentClickListener = function (event) {
|
|
if (!_this12.isOverlayClicked && _this12.isVisible() && _this12.isOutsideClicked(event.target)) {
|
|
_this12.hideOverlay('outside');
|
|
}
|
|
|
|
_this12.isOverlayClicked = false;
|
|
};
|
|
|
|
document.addEventListener('click', this.documentClickListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentClickListener",
|
|
value: function unbindDocumentClickListener() {
|
|
if (this.documentClickListener) {
|
|
document.removeEventListener('click', this.documentClickListener);
|
|
this.documentClickListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindDocumentResizeListener",
|
|
value: function bindDocumentResizeListener() {
|
|
if (!this.documentResizeListener && !this.props.touchUI) {
|
|
this.documentResizeListener = this.onWindowResize.bind(this);
|
|
window.addEventListener('resize', this.documentResizeListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentResizeListener",
|
|
value: function unbindDocumentResizeListener() {
|
|
if (this.documentResizeListener) {
|
|
window.removeEventListener('resize', this.documentResizeListener);
|
|
this.documentResizeListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindScrollListener",
|
|
value: function bindScrollListener() {
|
|
var _this13 = this;
|
|
|
|
if (!this.scrollHandler) {
|
|
this.scrollHandler = new ConnectedOverlayScrollHandler(this.container, function () {
|
|
if (_this13.isVisible()) {
|
|
_this13.hideOverlay();
|
|
}
|
|
});
|
|
}
|
|
|
|
this.scrollHandler.bindScrollListener();
|
|
}
|
|
}, {
|
|
key: "unbindScrollListener",
|
|
value: function unbindScrollListener() {
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.unbindScrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "isOutsideClicked",
|
|
value: function isOutsideClicked(target) {
|
|
return this.container && !(this.container.isSameNode(target) || this.isNavIconClicked(target) || this.container.contains(target) || this.overlayRef && this.overlayRef.current.contains(target));
|
|
}
|
|
}, {
|
|
key: "isNavIconClicked",
|
|
value: function isNavIconClicked(target) {
|
|
return DomHandler.hasClass(target, 'p-datepicker-prev') || DomHandler.hasClass(target, 'p-datepicker-prev-icon') || DomHandler.hasClass(target, 'p-datepicker-next') || DomHandler.hasClass(target, 'p-datepicker-next-icon');
|
|
}
|
|
}, {
|
|
key: "onWindowResize",
|
|
value: function onWindowResize() {
|
|
if (this.isVisible() && !DomHandler.isTouchDevice()) {
|
|
this.hideOverlay();
|
|
}
|
|
}
|
|
}, {
|
|
key: "alignOverlay",
|
|
value: function alignOverlay() {
|
|
if (this.props.touchUI) {
|
|
this.enableModality();
|
|
} else {
|
|
DomHandler.alignOverlay(this.overlayRef.current, this.inputRef.current.parentElement, this.props.appendTo || PrimeReact.appendTo);
|
|
}
|
|
}
|
|
}, {
|
|
key: "enableModality",
|
|
value: function enableModality() {
|
|
var _this14 = this;
|
|
|
|
if (!this.touchUIMask) {
|
|
this.touchUIMask = document.createElement('div');
|
|
this.touchUIMask.style.zIndex = String(ZIndexUtils.get(this.overlayRef.current) - 1);
|
|
DomHandler.addMultipleClasses(this.touchUIMask, 'p-component-overlay p-datepicker-mask p-datepicker-mask-scrollblocker p-component-overlay-enter');
|
|
|
|
this.touchUIMaskClickListener = function () {
|
|
_this14.disableModality();
|
|
};
|
|
|
|
this.touchUIMask.addEventListener('click', this.touchUIMaskClickListener);
|
|
document.body.appendChild(this.touchUIMask);
|
|
DomHandler.addClass(document.body, 'p-overflow-hidden');
|
|
}
|
|
}
|
|
}, {
|
|
key: "disableModality",
|
|
value: function disableModality() {
|
|
var _this15 = this;
|
|
|
|
if (this.touchUIMask) {
|
|
DomHandler.addClass(this.touchUIMask, 'p-component-overlay-leave');
|
|
this.touchUIMask.addEventListener('animationend', function () {
|
|
_this15.destroyMask();
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "destroyMask",
|
|
value: function destroyMask() {
|
|
this.touchUIMask.removeEventListener('click', this.touchUIMaskClickListener);
|
|
this.touchUIMaskClickListener = null;
|
|
document.body.removeChild(this.touchUIMask);
|
|
this.touchUIMask = null;
|
|
var bodyChildren = document.body.children;
|
|
var hasBlockerMasks;
|
|
|
|
for (var i = 0; i < bodyChildren.length; i++) {
|
|
var bodyChild = bodyChildren[i];
|
|
|
|
if (DomHandler.hasClass(bodyChild, 'p-datepicker-mask-scrollblocker')) {
|
|
hasBlockerMasks = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!hasBlockerMasks) {
|
|
DomHandler.removeClass(document.body, 'p-overflow-hidden');
|
|
}
|
|
}
|
|
}, {
|
|
key: "getFirstDayOfMonthIndex",
|
|
value: function getFirstDayOfMonthIndex(month, year) {
|
|
var day = new Date();
|
|
day.setDate(1);
|
|
day.setMonth(month);
|
|
day.setFullYear(year);
|
|
var dayIndex = day.getDay() + this.getSundayIndex();
|
|
return dayIndex >= 7 ? dayIndex - 7 : dayIndex;
|
|
}
|
|
}, {
|
|
key: "getDaysCountInMonth",
|
|
value: function getDaysCountInMonth(month, year) {
|
|
return 32 - this.daylightSavingAdjust(new Date(year, month, 32)).getDate();
|
|
}
|
|
}, {
|
|
key: "getDaysCountInPrevMonth",
|
|
value: function getDaysCountInPrevMonth(month, year) {
|
|
var prev = this.getPreviousMonthAndYear(month, year);
|
|
return this.getDaysCountInMonth(prev.month, prev.year);
|
|
}
|
|
}, {
|
|
key: "daylightSavingAdjust",
|
|
value: function daylightSavingAdjust(date) {
|
|
if (!date) {
|
|
return null;
|
|
}
|
|
|
|
date.setHours(date.getHours() > 12 ? date.getHours() + 2 : 0);
|
|
return date;
|
|
}
|
|
}, {
|
|
key: "getPreviousMonthAndYear",
|
|
value: function getPreviousMonthAndYear(month, year) {
|
|
var m, y;
|
|
|
|
if (month === 0) {
|
|
m = 11;
|
|
y = year - 1;
|
|
} else {
|
|
m = month - 1;
|
|
y = year;
|
|
}
|
|
|
|
return {
|
|
'month': m,
|
|
'year': y
|
|
};
|
|
}
|
|
}, {
|
|
key: "getNextMonthAndYear",
|
|
value: function getNextMonthAndYear(month, year) {
|
|
var m, y;
|
|
|
|
if (month === 11) {
|
|
m = 0;
|
|
y = year + 1;
|
|
} else {
|
|
m = month + 1;
|
|
y = year;
|
|
}
|
|
|
|
return {
|
|
'month': m,
|
|
'year': y
|
|
};
|
|
}
|
|
}, {
|
|
key: "getSundayIndex",
|
|
value: function getSundayIndex() {
|
|
var firstDayOfWeek = localeOption('firstDayOfWeek', this.props.locale);
|
|
return firstDayOfWeek > 0 ? 7 - firstDayOfWeek : 0;
|
|
}
|
|
}, {
|
|
key: "createWeekDays",
|
|
value: function createWeekDays() {
|
|
var weekDays = [];
|
|
|
|
var _localeOptions = localeOptions(this.props.locale),
|
|
dayIndex = _localeOptions.firstDayOfWeek,
|
|
dayNamesMin = _localeOptions.dayNamesMin;
|
|
|
|
for (var i = 0; i < 7; i++) {
|
|
weekDays.push(dayNamesMin[dayIndex]);
|
|
dayIndex = dayIndex === 6 ? 0 : ++dayIndex;
|
|
}
|
|
|
|
return weekDays;
|
|
}
|
|
}, {
|
|
key: "createMonths",
|
|
value: function createMonths(month, year) {
|
|
var months = [];
|
|
|
|
for (var i = 0; i < this.props.numberOfMonths; i++) {
|
|
var m = month + i;
|
|
var y = year;
|
|
|
|
if (m > 11) {
|
|
m = m % 11 - 1;
|
|
y = year + 1;
|
|
}
|
|
|
|
months.push(this.createMonth(m, y));
|
|
}
|
|
|
|
return months;
|
|
}
|
|
}, {
|
|
key: "createMonth",
|
|
value: function createMonth(month, year) {
|
|
var dates = [];
|
|
var firstDay = this.getFirstDayOfMonthIndex(month, year);
|
|
var daysLength = this.getDaysCountInMonth(month, year);
|
|
var prevMonthDaysLength = this.getDaysCountInPrevMonth(month, year);
|
|
var dayNo = 1;
|
|
var today = new Date();
|
|
var weekNumbers = [];
|
|
var monthRows = Math.ceil((daysLength + firstDay) / 7);
|
|
|
|
for (var i = 0; i < monthRows; i++) {
|
|
var week = [];
|
|
|
|
if (i === 0) {
|
|
for (var j = prevMonthDaysLength - firstDay + 1; j <= prevMonthDaysLength; j++) {
|
|
var prev = this.getPreviousMonthAndYear(month, year);
|
|
week.push({
|
|
day: j,
|
|
month: prev.month,
|
|
year: prev.year,
|
|
otherMonth: true,
|
|
today: this.isToday(today, j, prev.month, prev.year),
|
|
selectable: this.isSelectable(j, prev.month, prev.year, true)
|
|
});
|
|
}
|
|
|
|
var remainingDaysLength = 7 - week.length;
|
|
|
|
for (var _j = 0; _j < remainingDaysLength; _j++) {
|
|
week.push({
|
|
day: dayNo,
|
|
month: month,
|
|
year: year,
|
|
today: this.isToday(today, dayNo, month, year),
|
|
selectable: this.isSelectable(dayNo, month, year, false)
|
|
});
|
|
dayNo++;
|
|
}
|
|
} else {
|
|
for (var _j2 = 0; _j2 < 7; _j2++) {
|
|
if (dayNo > daysLength) {
|
|
var next = this.getNextMonthAndYear(month, year);
|
|
week.push({
|
|
day: dayNo - daysLength,
|
|
month: next.month,
|
|
year: next.year,
|
|
otherMonth: true,
|
|
today: this.isToday(today, dayNo - daysLength, next.month, next.year),
|
|
selectable: this.isSelectable(dayNo - daysLength, next.month, next.year, true)
|
|
});
|
|
} else {
|
|
week.push({
|
|
day: dayNo,
|
|
month: month,
|
|
year: year,
|
|
today: this.isToday(today, dayNo, month, year),
|
|
selectable: this.isSelectable(dayNo, month, year, false)
|
|
});
|
|
}
|
|
|
|
dayNo++;
|
|
}
|
|
}
|
|
|
|
if (this.props.showWeek) {
|
|
weekNumbers.push(this.getWeekNumber(new Date(week[0].year, week[0].month, week[0].day)));
|
|
}
|
|
|
|
dates.push(week);
|
|
}
|
|
|
|
return {
|
|
month: month,
|
|
year: year,
|
|
dates: dates,
|
|
weekNumbers: weekNumbers
|
|
};
|
|
}
|
|
}, {
|
|
key: "getWeekNumber",
|
|
value: function getWeekNumber(date) {
|
|
var checkDate = new Date(date.getTime());
|
|
checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));
|
|
var time = checkDate.getTime();
|
|
checkDate.setMonth(0);
|
|
checkDate.setDate(1);
|
|
return Math.floor(Math.round((time - checkDate.getTime()) / 86400000) / 7) + 1;
|
|
}
|
|
}, {
|
|
key: "isSelectable",
|
|
value: function isSelectable(day, month, year, otherMonth) {
|
|
var validMin = true;
|
|
var validMax = true;
|
|
var validDate = true;
|
|
var validDay = true;
|
|
var validMonth = true;
|
|
|
|
if (this.props.minDate) {
|
|
if (this.props.minDate.getFullYear() > year) {
|
|
validMin = false;
|
|
} else if (this.props.minDate.getFullYear() === year) {
|
|
if (this.props.minDate.getMonth() > month) {
|
|
validMin = false;
|
|
} else if (this.props.minDate.getMonth() === month) {
|
|
if (this.props.minDate.getDate() > day) {
|
|
validMin = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.props.maxDate) {
|
|
if (this.props.maxDate.getFullYear() < year) {
|
|
validMax = false;
|
|
} else if (this.props.maxDate.getFullYear() === year) {
|
|
if (this.props.maxDate.getMonth() < month) {
|
|
validMax = false;
|
|
} else if (this.props.maxDate.getMonth() === month) {
|
|
if (this.props.maxDate.getDate() < day) {
|
|
validMax = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.props.disabledDates) {
|
|
validDate = !this.isDateDisabled(day, month, year);
|
|
}
|
|
|
|
if (this.props.disabledDays) {
|
|
validDay = !this.isDayDisabled(day, month, year);
|
|
}
|
|
|
|
if (this.props.selectOtherMonths === false && otherMonth) {
|
|
validMonth = false;
|
|
}
|
|
|
|
return validMin && validMax && validDate && validDay && validMonth;
|
|
}
|
|
}, {
|
|
key: "isSelectableTime",
|
|
value: function isSelectableTime(value) {
|
|
var validMin = true;
|
|
var validMax = true;
|
|
|
|
if (this.props.minDate && this.props.minDate.toDateString() === value.toDateString()) {
|
|
if (this.props.minDate.getHours() > value.getHours()) {
|
|
validMin = false;
|
|
} else if (this.props.minDate.getHours() === value.getHours()) {
|
|
if (this.props.minDate.getMinutes() > value.getMinutes()) {
|
|
validMin = false;
|
|
} else if (this.props.minDate.getMinutes() === value.getMinutes()) {
|
|
if (this.props.minDate.getSeconds() > value.getSeconds()) {
|
|
validMin = false;
|
|
} else if (this.props.minDate.getSeconds() === value.getSeconds()) {
|
|
if (this.props.minDate.getMilliseconds() > value.getMilliseconds()) {
|
|
validMin = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.props.maxDate && this.props.maxDate.toDateString() === value.toDateString()) {
|
|
if (this.props.maxDate.getHours() < value.getHours()) {
|
|
validMax = false;
|
|
} else if (this.props.maxDate.getHours() === value.getHours()) {
|
|
if (this.props.maxDate.getMinutes() < value.getMinutes()) {
|
|
validMax = false;
|
|
} else if (this.props.maxDate.getMinutes() === value.getMinutes()) {
|
|
if (this.props.maxDate.getSeconds() < value.getSeconds()) {
|
|
validMax = false;
|
|
} else if (this.props.maxDate.getSeconds() === value.getSeconds()) {
|
|
if (this.props.maxDate.getMilliseconds() < value.getMilliseconds()) {
|
|
validMax = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return validMin && validMax;
|
|
}
|
|
}, {
|
|
key: "isSelected",
|
|
value: function isSelected(dateMeta) {
|
|
if (this.props.value) {
|
|
if (this.isSingleSelection()) {
|
|
return this.isDateEquals(this.props.value, dateMeta);
|
|
} else if (this.isMultipleSelection()) {
|
|
var selected = false;
|
|
|
|
var _iterator = _createForOfIteratorHelper$f(this.props.value),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var date = _step.value;
|
|
selected = this.isDateEquals(date, dateMeta);
|
|
|
|
if (selected) {
|
|
break;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
|
|
return selected;
|
|
} else if (this.isRangeSelection()) {
|
|
if (this.props.value[1]) return this.isDateEquals(this.props.value[0], dateMeta) || this.isDateEquals(this.props.value[1], dateMeta) || this.isDateBetween(this.props.value[0], this.props.value[1], dateMeta);else {
|
|
return this.isDateEquals(this.props.value[0], dateMeta);
|
|
}
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}, {
|
|
key: "isMonthSelected",
|
|
value: function isMonthSelected(month) {
|
|
var viewDate = this.getViewDate();
|
|
if (this.props.value && this.props.value instanceof Date) return this.props.value.getDate() === 1 && this.props.value.getMonth() === month && this.props.value.getFullYear() === viewDate.getFullYear();else return false;
|
|
}
|
|
}, {
|
|
key: "isDateEquals",
|
|
value: function isDateEquals(value, dateMeta) {
|
|
if (value && value instanceof Date) return value.getDate() === dateMeta.day && value.getMonth() === dateMeta.month && value.getFullYear() === dateMeta.year;else return false;
|
|
}
|
|
}, {
|
|
key: "isDateBetween",
|
|
value: function isDateBetween(start, end, dateMeta) {
|
|
var between = false;
|
|
|
|
if (start && end) {
|
|
var date = new Date(dateMeta.year, dateMeta.month, dateMeta.day);
|
|
return start.getTime() <= date.getTime() && end.getTime() >= date.getTime();
|
|
}
|
|
|
|
return between;
|
|
}
|
|
}, {
|
|
key: "isSingleSelection",
|
|
value: function isSingleSelection() {
|
|
return this.props.selectionMode === 'single';
|
|
}
|
|
}, {
|
|
key: "isRangeSelection",
|
|
value: function isRangeSelection() {
|
|
return this.props.selectionMode === 'range';
|
|
}
|
|
}, {
|
|
key: "isMultipleSelection",
|
|
value: function isMultipleSelection() {
|
|
return this.props.selectionMode === 'multiple';
|
|
}
|
|
}, {
|
|
key: "isToday",
|
|
value: function isToday(today, day, month, year) {
|
|
return today.getDate() === day && today.getMonth() === month && today.getFullYear() === year;
|
|
}
|
|
}, {
|
|
key: "isDateDisabled",
|
|
value: function isDateDisabled(day, month, year) {
|
|
if (this.props.disabledDates) {
|
|
for (var i = 0; i < this.props.disabledDates.length; i++) {
|
|
var disabledDate = this.props.disabledDates[i];
|
|
|
|
if (disabledDate.getFullYear() === year && disabledDate.getMonth() === month && disabledDate.getDate() === day) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "isDayDisabled",
|
|
value: function isDayDisabled(day, month, year) {
|
|
if (this.props.disabledDays) {
|
|
var weekday = new Date(year, month, day);
|
|
var weekdayNumber = weekday.getDay();
|
|
return this.props.disabledDays.indexOf(weekdayNumber) !== -1;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "updateInputfield",
|
|
value: function updateInputfield(value) {
|
|
if (!(this.inputRef && this.inputRef.current)) {
|
|
return;
|
|
}
|
|
|
|
var formattedValue = '';
|
|
|
|
if (value) {
|
|
try {
|
|
if (this.isSingleSelection()) {
|
|
formattedValue = this.isValidDate(value) ? this.formatDateTime(value) : '';
|
|
} else if (this.isMultipleSelection()) {
|
|
for (var i = 0; i < value.length; i++) {
|
|
var selectedValue = value[i];
|
|
var dateAsString = this.isValidDate(selectedValue) ? this.formatDateTime(selectedValue) : '';
|
|
formattedValue += dateAsString;
|
|
|
|
if (i !== value.length - 1) {
|
|
formattedValue += ', ';
|
|
}
|
|
}
|
|
} else if (this.isRangeSelection()) {
|
|
if (value && value.length) {
|
|
var startDate = value[0];
|
|
var endDate = value[1];
|
|
formattedValue = this.isValidDate(startDate) ? this.formatDateTime(startDate) : '';
|
|
|
|
if (endDate) {
|
|
formattedValue += this.isValidDate(endDate) ? ' - ' + this.formatDateTime(endDate) : '';
|
|
}
|
|
}
|
|
}
|
|
} catch (err) {
|
|
formattedValue = value;
|
|
}
|
|
}
|
|
|
|
this.inputRef.current.value = formattedValue;
|
|
}
|
|
}, {
|
|
key: "formatDateTime",
|
|
value: function formatDateTime(date) {
|
|
var formattedValue = null;
|
|
|
|
if (date) {
|
|
if (this.props.timeOnly) {
|
|
formattedValue = this.formatTime(date);
|
|
} else {
|
|
formattedValue = this.formatDate(date, this.getDateFormat());
|
|
|
|
if (this.props.showTime) {
|
|
formattedValue += ' ' + this.formatTime(date);
|
|
}
|
|
}
|
|
}
|
|
|
|
return formattedValue;
|
|
}
|
|
}, {
|
|
key: "formatDate",
|
|
value: function formatDate(date, format) {
|
|
if (!date) {
|
|
return '';
|
|
}
|
|
|
|
var iFormat;
|
|
|
|
var lookAhead = function lookAhead(match) {
|
|
var matches = iFormat + 1 < format.length && format.charAt(iFormat + 1) === match;
|
|
|
|
if (matches) {
|
|
iFormat++;
|
|
}
|
|
|
|
return matches;
|
|
},
|
|
formatNumber = function formatNumber(match, value, len) {
|
|
var num = '' + value;
|
|
|
|
if (lookAhead(match)) {
|
|
while (num.length < len) {
|
|
num = '0' + num;
|
|
}
|
|
}
|
|
|
|
return num;
|
|
},
|
|
formatName = function formatName(match, value, shortNames, longNames) {
|
|
return lookAhead(match) ? longNames[value] : shortNames[value];
|
|
};
|
|
|
|
var output = '';
|
|
var literal = false;
|
|
|
|
var _localeOptions2 = localeOptions(this.props.locale),
|
|
dayNamesShort = _localeOptions2.dayNamesShort,
|
|
dayNames = _localeOptions2.dayNames,
|
|
monthNamesShort = _localeOptions2.monthNamesShort,
|
|
monthNames = _localeOptions2.monthNames;
|
|
|
|
if (date) {
|
|
for (iFormat = 0; iFormat < format.length; iFormat++) {
|
|
if (literal) {
|
|
if (format.charAt(iFormat) === '\'' && !lookAhead('\'')) {
|
|
literal = false;
|
|
} else {
|
|
output += format.charAt(iFormat);
|
|
}
|
|
} else {
|
|
switch (format.charAt(iFormat)) {
|
|
case 'd':
|
|
output += formatNumber('d', date.getDate(), 2);
|
|
break;
|
|
|
|
case 'D':
|
|
output += formatName('D', date.getDay(), dayNamesShort, dayNames);
|
|
break;
|
|
|
|
case 'o':
|
|
output += formatNumber('o', Math.round((new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime() - new Date(date.getFullYear(), 0, 0).getTime()) / 86400000), 3);
|
|
break;
|
|
|
|
case 'm':
|
|
output += formatNumber('m', date.getMonth() + 1, 2);
|
|
break;
|
|
|
|
case 'M':
|
|
output += formatName('M', date.getMonth(), monthNamesShort, monthNames);
|
|
break;
|
|
|
|
case 'y':
|
|
output += lookAhead('y') ? date.getFullYear() : (date.getFullYear() % 100 < 10 ? '0' : '') + date.getFullYear() % 100;
|
|
break;
|
|
|
|
case '@':
|
|
output += date.getTime();
|
|
break;
|
|
|
|
case '!':
|
|
output += date.getTime() * 10000 + this.ticksTo1970;
|
|
break;
|
|
|
|
case '\'':
|
|
if (lookAhead('\'')) {
|
|
output += '\'';
|
|
} else {
|
|
literal = true;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
output += format.charAt(iFormat);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return output;
|
|
}
|
|
}, {
|
|
key: "formatTime",
|
|
value: function formatTime(date) {
|
|
if (!date) {
|
|
return '';
|
|
}
|
|
|
|
var output = '';
|
|
var hours = date.getHours();
|
|
var minutes = date.getMinutes();
|
|
var seconds = date.getSeconds();
|
|
var milliseconds = date.getMilliseconds();
|
|
|
|
if (this.props.hourFormat === '12' && hours > 11 && hours !== 12) {
|
|
hours -= 12;
|
|
}
|
|
|
|
if (this.props.hourFormat === '12') {
|
|
output += hours === 0 ? 12 : hours < 10 ? '0' + hours : hours;
|
|
} else {
|
|
output += hours < 10 ? '0' + hours : hours;
|
|
}
|
|
|
|
output += ':';
|
|
output += minutes < 10 ? '0' + minutes : minutes;
|
|
|
|
if (this.props.showSeconds) {
|
|
output += ':';
|
|
output += seconds < 10 ? '0' + seconds : seconds;
|
|
}
|
|
|
|
if (this.props.showMillisec) {
|
|
output += '.';
|
|
output += milliseconds < 100 ? (milliseconds < 10 ? '00' : '0') + milliseconds : milliseconds;
|
|
}
|
|
|
|
if (this.props.hourFormat === '12') {
|
|
output += date.getHours() > 11 ? ' PM' : ' AM';
|
|
}
|
|
|
|
return output;
|
|
}
|
|
}, {
|
|
key: "parseValueFromString",
|
|
value: function parseValueFromString(text) {
|
|
if (!text || text.trim().length === 0) {
|
|
return null;
|
|
}
|
|
|
|
var value;
|
|
|
|
if (this.isSingleSelection()) {
|
|
value = this.parseDateTime(text);
|
|
} else if (this.isMultipleSelection()) {
|
|
var tokens = text.split(',');
|
|
value = [];
|
|
|
|
var _iterator2 = _createForOfIteratorHelper$f(tokens),
|
|
_step2;
|
|
|
|
try {
|
|
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
|
|
var token = _step2.value;
|
|
value.push(this.parseDateTime(token.trim()));
|
|
}
|
|
} catch (err) {
|
|
_iterator2.e(err);
|
|
} finally {
|
|
_iterator2.f();
|
|
}
|
|
} else if (this.isRangeSelection()) {
|
|
var _tokens = text.split(' - ');
|
|
|
|
value = [];
|
|
|
|
for (var i = 0; i < _tokens.length; i++) {
|
|
value[i] = this.parseDateTime(_tokens[i].trim());
|
|
}
|
|
}
|
|
|
|
return value;
|
|
}
|
|
}, {
|
|
key: "parseDateTime",
|
|
value: function parseDateTime(text) {
|
|
var date;
|
|
var parts = text.split(' ');
|
|
|
|
if (this.props.timeOnly) {
|
|
date = new Date();
|
|
this.populateTime(date, parts[0], parts[1]);
|
|
} else {
|
|
if (this.props.showTime) {
|
|
date = this.parseDate(parts[0], this.getDateFormat());
|
|
this.populateTime(date, parts[1], parts[2]);
|
|
} else {
|
|
date = this.parseDate(text, this.getDateFormat());
|
|
}
|
|
}
|
|
|
|
return date;
|
|
}
|
|
}, {
|
|
key: "populateTime",
|
|
value: function populateTime(value, timeString, ampm) {
|
|
if (this.props.hourFormat === '12' && ampm !== 'PM' && ampm !== 'AM') {
|
|
throw new Error('Invalid Time');
|
|
}
|
|
|
|
var time = this.parseTime(timeString, ampm);
|
|
value.setHours(time.hour);
|
|
value.setMinutes(time.minute);
|
|
value.setSeconds(time.second);
|
|
value.setMilliseconds(time.millisecond);
|
|
}
|
|
}, {
|
|
key: "parseTime",
|
|
value: function parseTime(value, ampm) {
|
|
value = this.props.showMillisec ? value.replace('.', ':') : value;
|
|
var tokens = value.split(':');
|
|
var validTokenLength = this.props.showSeconds ? 3 : 2;
|
|
validTokenLength = this.props.showMillisec ? validTokenLength + 1 : validTokenLength;
|
|
|
|
if (tokens.length !== validTokenLength || tokens[0].length !== 2 || tokens[1].length !== 2 || this.props.showSeconds && tokens[2].length !== 2 || this.props.showMillisec && tokens[3].length !== 3) {
|
|
throw new Error('Invalid time');
|
|
}
|
|
|
|
var h = parseInt(tokens[0], 10);
|
|
var m = parseInt(tokens[1], 10);
|
|
var s = this.props.showSeconds ? parseInt(tokens[2], 10) : null;
|
|
var ms = this.props.showMillisec ? parseInt(tokens[3], 10) : null;
|
|
|
|
if (isNaN(h) || isNaN(m) || h > 23 || m > 59 || this.props.hourFormat === '12' && h > 12 || this.props.showSeconds && (isNaN(s) || s > 59) || this.props.showMillisec && (isNaN(s) || s > 1000)) {
|
|
throw new Error('Invalid time');
|
|
} else {
|
|
if (this.props.hourFormat === '12' && h !== 12 && ampm === 'PM') {
|
|
h += 12;
|
|
}
|
|
|
|
return {
|
|
hour: h,
|
|
minute: m,
|
|
second: s,
|
|
millisecond: ms
|
|
};
|
|
}
|
|
} // Ported from jquery-ui datepicker parseDate
|
|
|
|
}, {
|
|
key: "parseDate",
|
|
value: function parseDate(value, format) {
|
|
if (format == null || value == null) {
|
|
throw new Error('Invalid arguments');
|
|
}
|
|
|
|
value = _typeof(value) === "object" ? value.toString() : value + "";
|
|
|
|
if (value === "") {
|
|
return null;
|
|
}
|
|
|
|
var iFormat,
|
|
dim,
|
|
extra,
|
|
iValue = 0,
|
|
shortYearCutoff = typeof this.props.shortYearCutoff !== "string" ? this.props.shortYearCutoff : new Date().getFullYear() % 100 + parseInt(this.props.shortYearCutoff, 10),
|
|
year = -1,
|
|
month = -1,
|
|
day = -1,
|
|
doy = -1,
|
|
literal = false,
|
|
date,
|
|
lookAhead = function lookAhead(match) {
|
|
var matches = iFormat + 1 < format.length && format.charAt(iFormat + 1) === match;
|
|
|
|
if (matches) {
|
|
iFormat++;
|
|
}
|
|
|
|
return matches;
|
|
},
|
|
getNumber = function getNumber(match) {
|
|
var isDoubled = lookAhead(match),
|
|
size = match === "@" ? 14 : match === "!" ? 20 : match === "y" && isDoubled ? 4 : match === "o" ? 3 : 2,
|
|
minSize = match === "y" ? size : 1,
|
|
digits = new RegExp("^\\d{" + minSize + "," + size + "}"),
|
|
num = value.substring(iValue).match(digits);
|
|
|
|
if (!num) {
|
|
throw new Error('Missing number at position ' + iValue);
|
|
}
|
|
|
|
iValue += num[0].length;
|
|
return parseInt(num[0], 10);
|
|
},
|
|
getName = function getName(match, shortNames, longNames) {
|
|
var index = -1;
|
|
var arr = lookAhead(match) ? longNames : shortNames;
|
|
var names = [];
|
|
|
|
for (var i = 0; i < arr.length; i++) {
|
|
names.push([i, arr[i]]);
|
|
}
|
|
|
|
names.sort(function (a, b) {
|
|
return -(a[1].length - b[1].length);
|
|
});
|
|
|
|
for (var _i = 0; _i < names.length; _i++) {
|
|
var name = names[_i][1];
|
|
|
|
if (value.substr(iValue, name.length).toLowerCase() === name.toLowerCase()) {
|
|
index = names[_i][0];
|
|
iValue += name.length;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (index !== -1) {
|
|
return index + 1;
|
|
} else {
|
|
throw new Error('Unknown name at position ' + iValue);
|
|
}
|
|
},
|
|
checkLiteral = function checkLiteral() {
|
|
if (value.charAt(iValue) !== format.charAt(iFormat)) {
|
|
throw new Error('Unexpected literal at position ' + iValue);
|
|
}
|
|
|
|
iValue++;
|
|
};
|
|
|
|
if (this.props.view === 'month') {
|
|
day = 1;
|
|
}
|
|
|
|
var _localeOptions3 = localeOptions(this.props.locale),
|
|
dayNamesShort = _localeOptions3.dayNamesShort,
|
|
dayNames = _localeOptions3.dayNames,
|
|
monthNamesShort = _localeOptions3.monthNamesShort,
|
|
monthNames = _localeOptions3.monthNames;
|
|
|
|
for (iFormat = 0; iFormat < format.length; iFormat++) {
|
|
if (literal) {
|
|
if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
|
|
literal = false;
|
|
} else {
|
|
checkLiteral();
|
|
}
|
|
} else {
|
|
switch (format.charAt(iFormat)) {
|
|
case "d":
|
|
day = getNumber("d");
|
|
break;
|
|
|
|
case "D":
|
|
getName("D", dayNamesShort, dayNames);
|
|
break;
|
|
|
|
case "o":
|
|
doy = getNumber("o");
|
|
break;
|
|
|
|
case "m":
|
|
month = getNumber("m");
|
|
break;
|
|
|
|
case "M":
|
|
month = getName("M", monthNamesShort, monthNames);
|
|
break;
|
|
|
|
case "y":
|
|
year = getNumber("y");
|
|
break;
|
|
|
|
case "@":
|
|
date = new Date(getNumber("@"));
|
|
year = date.getFullYear();
|
|
month = date.getMonth() + 1;
|
|
day = date.getDate();
|
|
break;
|
|
|
|
case "!":
|
|
date = new Date((getNumber("!") - this.ticksTo1970) / 10000);
|
|
year = date.getFullYear();
|
|
month = date.getMonth() + 1;
|
|
day = date.getDate();
|
|
break;
|
|
|
|
case "'":
|
|
if (lookAhead("'")) {
|
|
checkLiteral();
|
|
} else {
|
|
literal = true;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
checkLiteral();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (iValue < value.length) {
|
|
extra = value.substr(iValue);
|
|
|
|
if (!/^\s+/.test(extra)) {
|
|
throw new Error('Extra/unparsed characters found in date: ' + extra);
|
|
}
|
|
}
|
|
|
|
if (year === -1) {
|
|
year = new Date().getFullYear();
|
|
} else if (year < 100) {
|
|
year += new Date().getFullYear() - new Date().getFullYear() % 100 + (year <= shortYearCutoff ? 0 : -100);
|
|
}
|
|
|
|
if (doy > -1) {
|
|
month = 1;
|
|
day = doy;
|
|
|
|
do {
|
|
dim = this.getDaysCountInMonth(year, month - 1);
|
|
|
|
if (day <= dim) {
|
|
break;
|
|
}
|
|
|
|
month++;
|
|
day -= dim;
|
|
} while (true);
|
|
}
|
|
|
|
date = this.daylightSavingAdjust(new Date(year, month - 1, day));
|
|
|
|
if (date.getFullYear() !== year || date.getMonth() + 1 !== month || date.getDate() !== day) {
|
|
throw new Error('Invalid date'); // E.g. 31/02/00
|
|
}
|
|
|
|
return date;
|
|
}
|
|
}, {
|
|
key: "renderBackwardNavigator",
|
|
value: function renderBackwardNavigator(isVisible) {
|
|
var _this16 = this;
|
|
|
|
var navigatorProps = isVisible ? {
|
|
'onClick': this.onPrevButtonClick,
|
|
'onKeyDown': function onKeyDown(e) {
|
|
return _this16.onContainerButtonKeydown(e);
|
|
}
|
|
} : {
|
|
'style': {
|
|
visibility: 'hidden'
|
|
}
|
|
};
|
|
return /*#__PURE__*/React.createElement("button", _extends({
|
|
type: "button",
|
|
className: "p-datepicker-prev p-link"
|
|
}, navigatorProps), /*#__PURE__*/React.createElement("span", {
|
|
className: "p-datepicker-prev-icon pi pi-chevron-left"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
}, {
|
|
key: "renderForwardNavigator",
|
|
value: function renderForwardNavigator(isVisible) {
|
|
var _this17 = this;
|
|
|
|
var navigatorProps = isVisible ? {
|
|
'onClick': this.onNextButtonClick,
|
|
'onKeyDown': function onKeyDown(e) {
|
|
return _this17.onContainerButtonKeydown(e);
|
|
}
|
|
} : {
|
|
'style': {
|
|
visibility: 'hidden'
|
|
}
|
|
};
|
|
return /*#__PURE__*/React.createElement("button", _extends({
|
|
type: "button",
|
|
className: "p-datepicker-next p-link"
|
|
}, navigatorProps), /*#__PURE__*/React.createElement("span", {
|
|
className: "p-datepicker-next-icon pi pi-chevron-right"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
}, {
|
|
key: "isInMinYear",
|
|
value: function isInMinYear(viewDate) {
|
|
return this.props.minDate && this.props.minDate.getFullYear() === viewDate.getFullYear();
|
|
}
|
|
}, {
|
|
key: "isInMaxYear",
|
|
value: function isInMaxYear(viewDate) {
|
|
return this.props.maxDate && this.props.maxDate.getFullYear() === viewDate.getFullYear();
|
|
}
|
|
}, {
|
|
key: "renderTitleMonthElement",
|
|
value: function renderTitleMonthElement(month) {
|
|
var _this18 = this;
|
|
|
|
var monthNames = localeOption('monthNames', this.props.locale);
|
|
|
|
if (this.props.monthNavigator && this.props.view !== 'month') {
|
|
var viewDate = this.getViewDate();
|
|
var viewMonth = viewDate.getMonth();
|
|
var displayedMonthOptions = monthNames.map(function (month, index) {
|
|
return (!_this18.isInMinYear(viewDate) || index >= _this18.props.minDate.getMonth()) && (!_this18.isInMaxYear(viewDate) || index <= _this18.props.maxDate.getMonth()) ? {
|
|
label: month,
|
|
value: index,
|
|
index: index
|
|
} : null;
|
|
}).filter(function (option) {
|
|
return !!option;
|
|
});
|
|
var displayedMonthNames = displayedMonthOptions.map(function (option) {
|
|
return option.label;
|
|
});
|
|
var content = /*#__PURE__*/React.createElement("select", {
|
|
className: "p-datepicker-month",
|
|
onChange: function onChange(e) {
|
|
return _this18.onMonthDropdownChange(e, e.target.value);
|
|
},
|
|
value: viewMonth
|
|
}, displayedMonthOptions.map(function (option) {
|
|
return /*#__PURE__*/React.createElement("option", {
|
|
key: option.label,
|
|
value: option.value
|
|
}, option.label);
|
|
}));
|
|
|
|
if (this.props.monthNavigatorTemplate) {
|
|
var defaultContentOptions = {
|
|
onChange: this.onMonthDropdownChange,
|
|
className: 'p-datepicker-month',
|
|
value: viewMonth,
|
|
names: displayedMonthNames,
|
|
options: displayedMonthOptions,
|
|
element: content,
|
|
props: this.props
|
|
};
|
|
return ObjectUtils.getJSXElement(this.props.monthNavigatorTemplate, defaultContentOptions);
|
|
}
|
|
|
|
return content;
|
|
} else {
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: "p-datepicker-month"
|
|
}, monthNames[month]);
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderTitleYearElement",
|
|
value: function renderTitleYearElement(year) {
|
|
var _this19 = this;
|
|
|
|
if (this.props.yearNavigator) {
|
|
var yearOptions = [];
|
|
var years = this.props.yearRange.split(':');
|
|
var yearStart = parseInt(years[0], 10);
|
|
var yearEnd = parseInt(years[1], 10);
|
|
|
|
for (var i = yearStart; i <= yearEnd; i++) {
|
|
yearOptions.push(i);
|
|
}
|
|
|
|
var viewDate = this.getViewDate();
|
|
var viewYear = viewDate.getFullYear();
|
|
var displayedYearNames = yearOptions.filter(function (year) {
|
|
return !(_this19.props.minDate && _this19.props.minDate.getFullYear() > year) && !(_this19.props.maxDate && _this19.props.maxDate.getFullYear() < year);
|
|
});
|
|
var content = /*#__PURE__*/React.createElement("select", {
|
|
className: "p-datepicker-year",
|
|
onChange: function onChange(e) {
|
|
return _this19.onYearDropdownChange(e, e.target.value);
|
|
},
|
|
value: viewYear
|
|
}, displayedYearNames.map(function (year) {
|
|
return /*#__PURE__*/React.createElement("option", {
|
|
key: year,
|
|
value: year
|
|
}, year);
|
|
}));
|
|
|
|
if (this.props.yearNavigatorTemplate) {
|
|
var options = displayedYearNames.map(function (name, i) {
|
|
return {
|
|
label: name,
|
|
value: name,
|
|
index: i
|
|
};
|
|
});
|
|
var defaultContentOptions = {
|
|
onChange: this.onYearDropdownChange,
|
|
className: 'p-datepicker-year',
|
|
value: viewYear,
|
|
names: displayedYearNames,
|
|
options: options,
|
|
element: content,
|
|
props: this.props
|
|
};
|
|
return ObjectUtils.getJSXElement(this.props.yearNavigatorTemplate, defaultContentOptions);
|
|
}
|
|
|
|
return content;
|
|
} else {
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: "p-datepicker-year"
|
|
}, year);
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderTitle",
|
|
value: function renderTitle(monthMetaData) {
|
|
var month = this.renderTitleMonthElement(monthMetaData.month);
|
|
var year = this.renderTitleYearElement(monthMetaData.year);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-datepicker-title"
|
|
}, month, year);
|
|
}
|
|
}, {
|
|
key: "renderDayNames",
|
|
value: function renderDayNames(weekDays) {
|
|
var dayNames = weekDays.map(function (weekDay, index) {
|
|
return /*#__PURE__*/React.createElement("th", {
|
|
key: "".concat(weekDay, "-").concat(index),
|
|
scope: "col"
|
|
}, /*#__PURE__*/React.createElement("span", null, weekDay));
|
|
});
|
|
|
|
if (this.props.showWeek) {
|
|
var weekHeader = /*#__PURE__*/React.createElement("th", {
|
|
scope: "col",
|
|
key: 'wn',
|
|
className: "p-datepicker-weekheader p-disabled"
|
|
}, /*#__PURE__*/React.createElement("span", null, localeOption('weekHeader', this.props.locale)));
|
|
return [weekHeader].concat(_toConsumableArray(dayNames));
|
|
} else {
|
|
return dayNames;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderDateCellContent",
|
|
value: function renderDateCellContent(date, className, groupIndex) {
|
|
var _this20 = this;
|
|
|
|
var content = this.props.dateTemplate ? this.props.dateTemplate(date) : date.day;
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: className,
|
|
onClick: function onClick(e) {
|
|
return _this20.onDateSelect(e, date);
|
|
},
|
|
onKeyDown: function onKeyDown(e) {
|
|
return _this20.onDateCellKeydown(e, date, groupIndex);
|
|
}
|
|
}, content, /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
}, {
|
|
key: "renderWeek",
|
|
value: function renderWeek(weekDates, weekNumber, groupIndex) {
|
|
var _this21 = this;
|
|
|
|
var week = weekDates.map(function (date) {
|
|
var selected = _this21.isSelected(date);
|
|
|
|
var cellClassName = classNames({
|
|
'p-datepicker-other-month': date.otherMonth,
|
|
'p-datepicker-today': date.today
|
|
});
|
|
var dateClassName = classNames({
|
|
'p-highlight': selected,
|
|
'p-disabled': !date.selectable
|
|
});
|
|
var content = date.otherMonth && !_this21.props.showOtherMonths ? null : _this21.renderDateCellContent(date, dateClassName, groupIndex);
|
|
return /*#__PURE__*/React.createElement("td", {
|
|
key: date.day,
|
|
className: cellClassName
|
|
}, content);
|
|
});
|
|
|
|
if (this.props.showWeek) {
|
|
var weekNumberCell = /*#__PURE__*/React.createElement("td", {
|
|
key: 'wn' + weekNumber,
|
|
className: "p-datepicker-weeknumber"
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-disabled"
|
|
}, weekNumber));
|
|
return [weekNumberCell].concat(_toConsumableArray(week));
|
|
} else {
|
|
return week;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderDates",
|
|
value: function renderDates(monthMetaData, groupIndex) {
|
|
var _this22 = this;
|
|
|
|
return monthMetaData.dates.map(function (weekDates, index) {
|
|
return /*#__PURE__*/React.createElement("tr", {
|
|
key: index
|
|
}, _this22.renderWeek(weekDates, monthMetaData.weekNumbers[index], groupIndex));
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderDateViewGrid",
|
|
value: function renderDateViewGrid(monthMetaData, weekDays, groupIndex) {
|
|
var dayNames = this.renderDayNames(weekDays);
|
|
var dates = this.renderDates(monthMetaData, groupIndex);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-datepicker-calendar-container"
|
|
}, /*#__PURE__*/React.createElement("table", {
|
|
className: "p-datepicker-calendar"
|
|
}, /*#__PURE__*/React.createElement("thead", null, /*#__PURE__*/React.createElement("tr", null, dayNames)), /*#__PURE__*/React.createElement("tbody", null, dates)));
|
|
}
|
|
}, {
|
|
key: "renderMonth",
|
|
value: function renderMonth(monthMetaData, index) {
|
|
var weekDays = this.createWeekDays();
|
|
var backwardNavigator = this.renderBackwardNavigator(index === 0);
|
|
var forwardNavigator = this.renderForwardNavigator(this.props.numberOfMonths === 1 || index === this.props.numberOfMonths - 1);
|
|
var title = this.renderTitle(monthMetaData);
|
|
var dateViewGrid = this.renderDateViewGrid(monthMetaData, weekDays, index);
|
|
var header = this.props.headerTemplate ? this.props.headerTemplate() : null;
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
key: monthMetaData.month,
|
|
className: "p-datepicker-group"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-datepicker-header"
|
|
}, header, backwardNavigator, title, forwardNavigator), dateViewGrid);
|
|
}
|
|
}, {
|
|
key: "renderMonths",
|
|
value: function renderMonths(monthsMetaData) {
|
|
var _this23 = this;
|
|
|
|
var groups = monthsMetaData.map(function (monthMetaData, index) {
|
|
return _this23.renderMonth(monthMetaData, index);
|
|
});
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-datepicker-group-container"
|
|
}, groups);
|
|
}
|
|
}, {
|
|
key: "renderDateView",
|
|
value: function renderDateView() {
|
|
var viewDate = this.getViewDate();
|
|
var monthsMetaData = this.createMonths(viewDate.getMonth(), viewDate.getFullYear());
|
|
var months = this.renderMonths(monthsMetaData);
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, months);
|
|
}
|
|
}, {
|
|
key: "renderMonthViewMonth",
|
|
value: function renderMonthViewMonth(index) {
|
|
var _this24 = this;
|
|
|
|
var className = classNames('p-monthpicker-month', {
|
|
'p-highlight': this.isMonthSelected(index)
|
|
});
|
|
var monthNamesShort = localeOption('monthNamesShort', this.props.locale);
|
|
var monthName = monthNamesShort[index];
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
key: monthName,
|
|
className: className,
|
|
onClick: function onClick(event) {
|
|
return _this24.onMonthSelect(event, index);
|
|
},
|
|
onKeyDown: function onKeyDown(event) {
|
|
return _this24.onMonthCellKeydown(event, index);
|
|
}
|
|
}, monthName, /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
}, {
|
|
key: "renderMonthViewMonths",
|
|
value: function renderMonthViewMonths() {
|
|
var months = [];
|
|
|
|
for (var i = 0; i <= 11; i++) {
|
|
months.push(this.renderMonthViewMonth(i));
|
|
}
|
|
|
|
return months;
|
|
}
|
|
}, {
|
|
key: "renderMonthView",
|
|
value: function renderMonthView() {
|
|
var backwardNavigator = this.renderBackwardNavigator(true);
|
|
var forwardNavigator = this.renderForwardNavigator(true);
|
|
var yearElement = this.renderTitleYearElement(this.getViewDate().getFullYear());
|
|
var months = this.renderMonthViewMonths();
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-datepicker-group-container"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-datepicker-group"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-datepicker-header"
|
|
}, backwardNavigator, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-datepicker-title"
|
|
}, yearElement), forwardNavigator))), /*#__PURE__*/React.createElement("div", {
|
|
className: "p-monthpicker"
|
|
}, months));
|
|
}
|
|
}, {
|
|
key: "renderDatePicker",
|
|
value: function renderDatePicker() {
|
|
if (!this.props.timeOnly) {
|
|
if (this.props.view === 'date') {
|
|
return this.renderDateView();
|
|
} else if (this.props.view === 'month') {
|
|
return this.renderMonthView();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderHourPicker",
|
|
value: function renderHourPicker() {
|
|
var _this25 = this;
|
|
|
|
var currentTime = this.getCurrentDateTime();
|
|
var hour = currentTime.getHours();
|
|
|
|
if (this.props.hourFormat === '12') {
|
|
if (hour === 0) hour = 12;else if (hour > 11 && hour !== 12) hour = hour - 12;
|
|
}
|
|
|
|
var hourDisplay = hour < 10 ? '0' + hour : hour;
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-hour-picker"
|
|
}, /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "p-link",
|
|
onMouseDown: function onMouseDown(e) {
|
|
return _this25.onTimePickerElementMouseDown(e, 0, 1);
|
|
},
|
|
onMouseUp: this.onTimePickerElementMouseUp,
|
|
onMouseLeave: this.onTimePickerElementMouseLeave,
|
|
onKeyDown: function onKeyDown(e) {
|
|
return _this25.onContainerButtonKeydown(e);
|
|
}
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "pi pi-chevron-up"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null)), /*#__PURE__*/React.createElement("span", null, hourDisplay), /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "p-link",
|
|
onMouseDown: function onMouseDown(e) {
|
|
return _this25.onTimePickerElementMouseDown(e, 0, -1);
|
|
},
|
|
onMouseUp: this.onTimePickerElementMouseUp,
|
|
onMouseLeave: this.onTimePickerElementMouseLeave,
|
|
onKeyDown: function onKeyDown(e) {
|
|
return _this25.onContainerButtonKeydown(e);
|
|
}
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "pi pi-chevron-down"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null)));
|
|
}
|
|
}, {
|
|
key: "renderMinutePicker",
|
|
value: function renderMinutePicker() {
|
|
var _this26 = this;
|
|
|
|
var currentTime = this.getCurrentDateTime();
|
|
var minute = currentTime.getMinutes();
|
|
var minuteDisplay = minute < 10 ? '0' + minute : minute;
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-minute-picker"
|
|
}, /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "p-link",
|
|
onMouseDown: function onMouseDown(e) {
|
|
return _this26.onTimePickerElementMouseDown(e, 1, 1);
|
|
},
|
|
onMouseUp: this.onTimePickerElementMouseUp,
|
|
onMouseLeave: this.onTimePickerElementMouseLeave,
|
|
onKeyDown: function onKeyDown(e) {
|
|
return _this26.onContainerButtonKeydown(e);
|
|
}
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "pi pi-chevron-up"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null)), /*#__PURE__*/React.createElement("span", null, minuteDisplay), /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "p-link",
|
|
onMouseDown: function onMouseDown(e) {
|
|
return _this26.onTimePickerElementMouseDown(e, 1, -1);
|
|
},
|
|
onMouseUp: this.onTimePickerElementMouseUp,
|
|
onMouseLeave: this.onTimePickerElementMouseLeave,
|
|
onKeyDown: function onKeyDown(e) {
|
|
return _this26.onContainerButtonKeydown(e);
|
|
}
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "pi pi-chevron-down"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null)));
|
|
}
|
|
}, {
|
|
key: "renderSecondPicker",
|
|
value: function renderSecondPicker() {
|
|
var _this27 = this;
|
|
|
|
if (this.props.showSeconds) {
|
|
var currentTime = this.getCurrentDateTime();
|
|
var second = currentTime.getSeconds();
|
|
var secondDisplay = second < 10 ? '0' + second : second;
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-second-picker"
|
|
}, /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "p-link",
|
|
onMouseDown: function onMouseDown(e) {
|
|
return _this27.onTimePickerElementMouseDown(e, 2, 1);
|
|
},
|
|
onMouseUp: this.onTimePickerElementMouseUp,
|
|
onMouseLeave: this.onTimePickerElementMouseLeave,
|
|
onKeyDown: function onKeyDown(e) {
|
|
return _this27.onContainerButtonKeydown(e);
|
|
}
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "pi pi-chevron-up"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null)), /*#__PURE__*/React.createElement("span", null, secondDisplay), /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "p-link",
|
|
onMouseDown: function onMouseDown(e) {
|
|
return _this27.onTimePickerElementMouseDown(e, 2, -1);
|
|
},
|
|
onMouseUp: this.onTimePickerElementMouseUp,
|
|
onMouseLeave: this.onTimePickerElementMouseLeave,
|
|
onKeyDown: function onKeyDown(e) {
|
|
return _this27.onContainerButtonKeydown(e);
|
|
}
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "pi pi-chevron-down"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null)));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderMiliSecondPicker",
|
|
value: function renderMiliSecondPicker() {
|
|
var _this28 = this;
|
|
|
|
if (this.props.showMillisec) {
|
|
var currentTime = this.getCurrentDateTime();
|
|
var millisecond = currentTime.getMilliseconds();
|
|
var millisecondDisplay = millisecond < 100 ? (millisecond < 10 ? '00' : '0') + millisecond : millisecond;
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-millisecond-picker"
|
|
}, /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "p-link",
|
|
onMouseDown: function onMouseDown(e) {
|
|
return _this28.onTimePickerElementMouseDown(e, 3, 1);
|
|
},
|
|
onMouseUp: this.onTimePickerElementMouseUp,
|
|
onMouseLeave: this.onTimePickerElementMouseLeave,
|
|
onKeyDown: function onKeyDown(e) {
|
|
return _this28.onContainerButtonKeydown(e);
|
|
}
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "pi pi-chevron-up"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null)), /*#__PURE__*/React.createElement("span", null, millisecondDisplay), /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "p-link",
|
|
onMouseDown: function onMouseDown(e) {
|
|
return _this28.onTimePickerElementMouseDown(e, 3, -1);
|
|
},
|
|
onMouseUp: this.onTimePickerElementMouseUp,
|
|
onMouseLeave: this.onTimePickerElementMouseLeave,
|
|
onKeyDown: function onKeyDown(e) {
|
|
return _this28.onContainerButtonKeydown(e);
|
|
}
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "pi pi-chevron-down"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null)));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderAmPmPicker",
|
|
value: function renderAmPmPicker() {
|
|
if (this.props.hourFormat === '12') {
|
|
var currentTime = this.getCurrentDateTime();
|
|
var hour = currentTime.getHours();
|
|
var display = hour > 11 ? 'PM' : 'AM';
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-ampm-picker"
|
|
}, /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "p-link",
|
|
onClick: this.toggleAmPm
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "pi pi-chevron-up"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null)), /*#__PURE__*/React.createElement("span", null, display), /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "p-link",
|
|
onClick: this.toggleAmPm
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "pi pi-chevron-down"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null)));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderSeparator",
|
|
value: function renderSeparator(separator) {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-separator"
|
|
}, /*#__PURE__*/React.createElement("span", null, separator));
|
|
}
|
|
}, {
|
|
key: "renderTimePicker",
|
|
value: function renderTimePicker() {
|
|
if (this.props.showTime || this.props.timeOnly) {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-timepicker"
|
|
}, this.renderHourPicker(), this.renderSeparator(':'), this.renderMinutePicker(), this.props.showSeconds && this.renderSeparator(':'), this.renderSecondPicker(), this.props.showMillisec && this.renderSeparator('.'), this.renderMiliSecondPicker(), this.props.hourFormat === '12' && this.renderSeparator(':'), this.renderAmPmPicker());
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderInputElement",
|
|
value: function renderInputElement() {
|
|
if (!this.props.inline) {
|
|
return /*#__PURE__*/React.createElement(InputText, {
|
|
ref: this.inputRef,
|
|
id: this.props.inputId,
|
|
name: this.props.name,
|
|
type: "text",
|
|
className: this.props.inputClassName,
|
|
style: this.props.inputStyle,
|
|
readOnly: this.props.readOnlyInput,
|
|
disabled: this.props.disabled,
|
|
required: this.props.required,
|
|
autoComplete: "off",
|
|
placeholder: this.props.placeholder,
|
|
tabIndex: this.props.tabIndex,
|
|
onInput: this.onUserInput,
|
|
onFocus: this.onInputFocus,
|
|
onBlur: this.onInputBlur,
|
|
onKeyDown: this.onInputKeyDown,
|
|
"aria-labelledby": this.props.ariaLabelledBy,
|
|
inputMode: this.props.inputMode
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderButton",
|
|
value: function renderButton() {
|
|
if (this.props.showIcon) {
|
|
return /*#__PURE__*/React.createElement(Button, {
|
|
type: "button",
|
|
icon: this.props.icon,
|
|
onClick: this.onButtonClick,
|
|
tabIndex: "-1",
|
|
disabled: this.props.disabled,
|
|
className: "p-datepicker-trigger"
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
var input = this.renderInputElement();
|
|
var button = this.renderButton();
|
|
|
|
if (this.props.iconPos === 'left') {
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, button, input);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, input, button);
|
|
}
|
|
}, {
|
|
key: "renderButtonBar",
|
|
value: function renderButtonBar() {
|
|
var _this29 = this;
|
|
|
|
if (this.props.showButtonBar) {
|
|
var todayClassName = classNames('p-button-text', this.props.todayButtonClassName);
|
|
var clearClassName = classNames('p-button-text', this.props.clearButtonClassName);
|
|
|
|
var _localeOptions4 = localeOptions(this.props.locale),
|
|
today = _localeOptions4.today,
|
|
clear = _localeOptions4.clear;
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-datepicker-buttonbar"
|
|
}, /*#__PURE__*/React.createElement(Button, {
|
|
type: "button",
|
|
label: today,
|
|
onClick: this.onTodayButtonClick,
|
|
onKeyDown: function onKeyDown(e) {
|
|
return _this29.onContainerButtonKeydown(e);
|
|
},
|
|
className: todayClassName
|
|
}), /*#__PURE__*/React.createElement(Button, {
|
|
type: "button",
|
|
label: clear,
|
|
onClick: this.onClearButtonClick,
|
|
onKeyDown: function onKeyDown(e) {
|
|
return _this29.onContainerButtonKeydown(e);
|
|
},
|
|
className: clearClassName
|
|
}));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderFooter",
|
|
value: function renderFooter() {
|
|
if (this.props.footerTemplate) {
|
|
var content = this.props.footerTemplate();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-datepicker-footer"
|
|
}, content);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _classNames,
|
|
_this30 = this;
|
|
|
|
var className = classNames('p-calendar p-component p-inputwrapper', this.props.className, (_classNames = {}, _defineProperty(_classNames, "p-calendar-w-btn p-calendar-w-btn-".concat(this.props.iconPos), this.props.showIcon), _defineProperty(_classNames, 'p-calendar-disabled', this.props.disabled), _defineProperty(_classNames, 'p-calendar-timeonly', this.props.timeOnly), _defineProperty(_classNames, 'p-inputwrapper-filled', this.props.value || DomHandler.hasClass(this.inputRef.current, 'p-filled') && this.inputRef.current.value !== ''), _defineProperty(_classNames, 'p-inputwrapper-focus', this.state.focused), _classNames));
|
|
var panelClassName = classNames('p-datepicker p-component', this.props.panelClassName, {
|
|
'p-datepicker-inline': this.props.inline,
|
|
'p-disabled': this.props.disabled,
|
|
'p-datepicker-timeonly': this.props.timeOnly,
|
|
'p-datepicker-multiple-month': this.props.numberOfMonths > 1,
|
|
'p-datepicker-monthpicker': this.props.view === 'month',
|
|
'p-datepicker-touch-ui': this.props.touchUI
|
|
});
|
|
var content = this.renderContent();
|
|
var datePicker = this.renderDatePicker();
|
|
var timePicker = this.renderTimePicker();
|
|
var buttonBar = this.renderButtonBar();
|
|
var footer = this.renderFooter();
|
|
var isVisible = this.props.inline || this.isVisible();
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
ref: function ref(el) {
|
|
return _this30.container = el;
|
|
},
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, content, /*#__PURE__*/React.createElement(CalendarPanel, {
|
|
ref: this.overlayRef,
|
|
className: panelClassName,
|
|
style: this.props.panelStyle,
|
|
appendTo: this.props.appendTo,
|
|
inline: this.props.inline,
|
|
onClick: this.onPanelClick,
|
|
onMouseUp: this.onPanelMouseUp,
|
|
"in": isVisible,
|
|
onEnter: this.onOverlayEnter,
|
|
onEntered: this.onOverlayEntered,
|
|
onExit: this.onOverlayExit,
|
|
onExited: this.onOverlayExited,
|
|
transitionOptions: this.props.transitionOptions
|
|
}, datePicker, timePicker, buttonBar, footer));
|
|
}
|
|
}]);
|
|
|
|
return Calendar;
|
|
}(Component);
|
|
|
|
_defineProperty(Calendar, "defaultProps", {
|
|
id: null,
|
|
inputRef: null,
|
|
name: null,
|
|
value: null,
|
|
visible: false,
|
|
viewDate: null,
|
|
style: null,
|
|
className: null,
|
|
inline: false,
|
|
selectionMode: 'single',
|
|
inputId: null,
|
|
inputStyle: null,
|
|
inputClassName: null,
|
|
inputMode: 'none',
|
|
required: false,
|
|
readOnlyInput: false,
|
|
keepInvalid: false,
|
|
mask: null,
|
|
disabled: false,
|
|
tabIndex: null,
|
|
placeholder: null,
|
|
showIcon: false,
|
|
icon: 'pi pi-calendar',
|
|
iconPos: 'right',
|
|
showOnFocus: true,
|
|
numberOfMonths: 1,
|
|
view: 'date',
|
|
touchUI: false,
|
|
showTime: false,
|
|
timeOnly: false,
|
|
showSeconds: false,
|
|
showMillisec: false,
|
|
hourFormat: '24',
|
|
stepHour: 1,
|
|
stepMinute: 1,
|
|
stepSecond: 1,
|
|
stepMillisec: 1,
|
|
shortYearCutoff: '+10',
|
|
hideOnDateTimeSelect: false,
|
|
showWeek: false,
|
|
locale: null,
|
|
dateFormat: null,
|
|
panelStyle: null,
|
|
panelClassName: null,
|
|
monthNavigator: false,
|
|
yearNavigator: false,
|
|
yearRange: null,
|
|
disabledDates: null,
|
|
disabledDays: null,
|
|
minDate: null,
|
|
maxDate: null,
|
|
maxDateCount: null,
|
|
showOtherMonths: true,
|
|
selectOtherMonths: false,
|
|
showButtonBar: false,
|
|
todayButtonClassName: 'p-button-secondary',
|
|
clearButtonClassName: 'p-button-secondary',
|
|
autoZIndex: true,
|
|
baseZIndex: 0,
|
|
appendTo: null,
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
ariaLabelledBy: null,
|
|
dateTemplate: null,
|
|
headerTemplate: null,
|
|
footerTemplate: null,
|
|
monthNavigatorTemplate: null,
|
|
yearNavigatorTemplate: null,
|
|
transitionOptions: null,
|
|
onVisibleChange: null,
|
|
onFocus: null,
|
|
onBlur: null,
|
|
onInput: null,
|
|
onSelect: null,
|
|
onChange: null,
|
|
onViewDateChange: null,
|
|
onTodayButtonClick: null,
|
|
onClearButtonClick: null,
|
|
onShow: null,
|
|
onHide: null
|
|
});
|
|
|
|
function _createSuper$25(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$25(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$25() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Captcha = /*#__PURE__*/function (_Component) {
|
|
_inherits(Captcha, _Component);
|
|
|
|
var _super = _createSuper$25(Captcha);
|
|
|
|
function Captcha() {
|
|
_classCallCheck(this, Captcha);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(Captcha, [{
|
|
key: "init",
|
|
value: function init() {
|
|
var _this = this;
|
|
|
|
this._instance = window.grecaptcha.render(this.targetEL, {
|
|
'sitekey': this.props.siteKey,
|
|
'theme': this.props.theme,
|
|
'type': this.props.type,
|
|
'size': this.props.size,
|
|
'tabindex': this.props.tabIndex,
|
|
'hl': this.props.language,
|
|
'callback': function callback(response) {
|
|
_this.recaptchaCallback(response);
|
|
},
|
|
'expired-callback': function expiredCallback() {
|
|
_this.recaptchaExpiredCallback();
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "reset",
|
|
value: function reset() {
|
|
if (this._instance === null) return;
|
|
window.grecaptcha.reset(this._instance);
|
|
}
|
|
}, {
|
|
key: "getResponse",
|
|
value: function getResponse() {
|
|
if (this._instance === null) return null;
|
|
return window.grecaptcha.getResponse(this._instance);
|
|
}
|
|
}, {
|
|
key: "recaptchaCallback",
|
|
value: function recaptchaCallback(response) {
|
|
if (this.props.onResponse) {
|
|
this.props.onResponse({
|
|
response: response
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "recaptchaExpiredCallback",
|
|
value: function recaptchaExpiredCallback() {
|
|
if (this.props.onExpire) {
|
|
this.props.onExpire();
|
|
}
|
|
}
|
|
}, {
|
|
key: "addRecaptchaScript",
|
|
value: function addRecaptchaScript() {
|
|
var _this2 = this;
|
|
|
|
this.recaptchaScript = null;
|
|
|
|
if (!window.grecaptcha) {
|
|
var head = document.head || document.getElementsByTagName('head')[0];
|
|
this.recaptchaScript = document.createElement('script');
|
|
this.recaptchaScript.src = "https://www.google.com/recaptcha/api.js?render=explicit";
|
|
this.recaptchaScript.async = true;
|
|
this.recaptchaScript.defer = true;
|
|
|
|
this.recaptchaScript.onload = function () {
|
|
if (!window.grecaptcha) {
|
|
console.warn("Recaptcha is not loaded");
|
|
return;
|
|
}
|
|
|
|
window.grecaptcha.ready(function () {
|
|
_this2.init();
|
|
});
|
|
};
|
|
|
|
head.appendChild(this.recaptchaScript);
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.addRecaptchaScript();
|
|
|
|
if (window.grecaptcha) {
|
|
this.init();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.recaptchaScript) {
|
|
this.recaptchaScript.parentNode.removeChild(this.recaptchaScript);
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this3 = this;
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
ref: function ref(el) {
|
|
return _this3.targetEL = el;
|
|
}
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return Captcha;
|
|
}(Component);
|
|
|
|
_defineProperty(Captcha, "defaultProps", {
|
|
id: null,
|
|
siteKey: null,
|
|
theme: "light",
|
|
type: "image",
|
|
size: "normal",
|
|
tabIndex: 0,
|
|
language: "en",
|
|
onResponse: null,
|
|
onExpire: null
|
|
});
|
|
|
|
function _createSuper$24(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$24(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$24() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Card = /*#__PURE__*/function (_Component) {
|
|
_inherits(Card, _Component);
|
|
|
|
var _super = _createSuper$24(Card);
|
|
|
|
function Card() {
|
|
_classCallCheck(this, Card);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(Card, [{
|
|
key: "renderHeader",
|
|
value: function renderHeader() {
|
|
if (this.props.header) {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-card-header"
|
|
}, ObjectUtils.getJSXElement(this.props.header, this.props));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderBody",
|
|
value: function renderBody() {
|
|
var title = this.props.title && /*#__PURE__*/React.createElement("div", {
|
|
className: "p-card-title"
|
|
}, ObjectUtils.getJSXElement(this.props.title, this.props));
|
|
var subTitle = this.props.subTitle && /*#__PURE__*/React.createElement("div", {
|
|
className: "p-card-subtitle"
|
|
}, ObjectUtils.getJSXElement(this.props.subTitle, this.props));
|
|
var children = this.props.children && /*#__PURE__*/React.createElement("div", {
|
|
className: "p-card-content"
|
|
}, this.props.children);
|
|
var footer = this.props.footer && /*#__PURE__*/React.createElement("div", {
|
|
className: "p-card-footer"
|
|
}, ObjectUtils.getJSXElement(this.props.footer, this.props));
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-card-body"
|
|
}, title, subTitle, children, footer);
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var header = this.renderHeader();
|
|
var body = this.renderBody();
|
|
var className = classNames('p-card p-component', this.props.className);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: className,
|
|
style: this.props.style,
|
|
id: this.props.id
|
|
}, header, body);
|
|
}
|
|
}]);
|
|
|
|
return Card;
|
|
}(Component);
|
|
|
|
_defineProperty(Card, "defaultProps", {
|
|
id: null,
|
|
header: null,
|
|
footer: null,
|
|
title: null,
|
|
subTitle: null,
|
|
style: null,
|
|
className: null
|
|
});
|
|
|
|
function ownKeys$J(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$J(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$J(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$J(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$23(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$23(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$23() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
var CarouselItem = /*#__PURE__*/function (_Component) {
|
|
_inherits(CarouselItem, _Component);
|
|
|
|
var _super = _createSuper$23(CarouselItem);
|
|
|
|
function CarouselItem() {
|
|
_classCallCheck(this, CarouselItem);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(CarouselItem, [{
|
|
key: "render",
|
|
value: function render() {
|
|
var content = this.props.template(this.props.item);
|
|
var itemClassName = classNames(this.props.className, 'p-carousel-item', {
|
|
'p-carousel-item-active': this.props.active,
|
|
'p-carousel-item-start': this.props.start,
|
|
'p-carousel-item-end': this.props.end
|
|
});
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: itemClassName
|
|
}, content);
|
|
}
|
|
}]);
|
|
|
|
return CarouselItem;
|
|
}(Component);
|
|
|
|
_defineProperty(CarouselItem, "defaultProps", {
|
|
template: null,
|
|
item: null,
|
|
active: false,
|
|
start: false,
|
|
end: false,
|
|
className: null
|
|
});
|
|
|
|
var Carousel = /*#__PURE__*/function (_Component2) {
|
|
_inherits(Carousel, _Component2);
|
|
|
|
var _super2 = _createSuper$23(Carousel);
|
|
|
|
function Carousel(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Carousel);
|
|
|
|
_this = _super2.call(this, props);
|
|
_this.state = {
|
|
numVisible: props.numVisible,
|
|
numScroll: props.numScroll,
|
|
totalShiftedItems: props.page * props.numScroll * -1
|
|
};
|
|
|
|
if (!_this.props.onPageChange) {
|
|
_this.state = _objectSpread$J(_objectSpread$J({}, _this.state), {}, {
|
|
page: props.page
|
|
});
|
|
}
|
|
|
|
_this.navBackward = _this.navBackward.bind(_assertThisInitialized(_this));
|
|
_this.navForward = _this.navForward.bind(_assertThisInitialized(_this));
|
|
_this.onTransitionEnd = _this.onTransitionEnd.bind(_assertThisInitialized(_this));
|
|
_this.onTouchStart = _this.onTouchStart.bind(_assertThisInitialized(_this));
|
|
_this.onTouchMove = _this.onTouchMove.bind(_assertThisInitialized(_this));
|
|
_this.onTouchEnd = _this.onTouchEnd.bind(_assertThisInitialized(_this));
|
|
_this.totalIndicators = 0;
|
|
_this.remainingItems = 0;
|
|
_this.allowAutoplay = !!_this.props.autoplayInterval;
|
|
_this.circular = _this.props.circular || _this.allowAutoplay;
|
|
_this.attributeSelector = UniqueComponentId();
|
|
_this.swipeThreshold = 20;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Carousel, [{
|
|
key: "step",
|
|
value: function step(dir, page) {
|
|
var totalShiftedItems = this.state.totalShiftedItems;
|
|
var isCircular = this.isCircular();
|
|
|
|
if (page != null) {
|
|
totalShiftedItems = this.state.numScroll * page * -1;
|
|
|
|
if (isCircular) {
|
|
totalShiftedItems -= this.state.numVisible;
|
|
}
|
|
|
|
this.isRemainingItemsAdded = false;
|
|
} else {
|
|
totalShiftedItems += this.state.numScroll * dir;
|
|
|
|
if (this.isRemainingItemsAdded) {
|
|
totalShiftedItems += this.remainingItems - this.state.numScroll * dir;
|
|
this.isRemainingItemsAdded = false;
|
|
}
|
|
|
|
var originalShiftedItems = isCircular ? totalShiftedItems + this.state.numVisible : totalShiftedItems;
|
|
page = Math.abs(Math.floor(originalShiftedItems / this.state.numScroll));
|
|
}
|
|
|
|
if (isCircular && this.state.page === this.totalIndicators - 1 && dir === -1) {
|
|
totalShiftedItems = -1 * (this.props.value.length + this.state.numVisible);
|
|
page = 0;
|
|
} else if (isCircular && this.state.page === 0 && dir === 1) {
|
|
totalShiftedItems = 0;
|
|
page = this.totalIndicators - 1;
|
|
} else if (page === this.totalIndicators - 1 && this.remainingItems > 0) {
|
|
totalShiftedItems += this.remainingItems * -1 - this.state.numScroll * dir;
|
|
this.isRemainingItemsAdded = true;
|
|
}
|
|
|
|
if (this.itemsContainer) {
|
|
DomHandler.removeClass(this.itemsContainer, 'p-items-hidden');
|
|
this.changePosition(totalShiftedItems);
|
|
this.itemsContainer.style.transition = 'transform 500ms ease 0s';
|
|
}
|
|
|
|
if (this.props.onPageChange) {
|
|
this.setState({
|
|
totalShiftedItems: totalShiftedItems
|
|
});
|
|
this.props.onPageChange({
|
|
page: page
|
|
});
|
|
} else {
|
|
this.setState({
|
|
page: page,
|
|
totalShiftedItems: totalShiftedItems
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "calculatePosition",
|
|
value: function calculatePosition() {
|
|
if (this.itemsContainer && this.responsiveOptions) {
|
|
var windowWidth = window.innerWidth;
|
|
var matchedResponsiveData = {
|
|
numVisible: this.props.numVisible,
|
|
numScroll: this.props.numScroll
|
|
};
|
|
|
|
for (var i = 0; i < this.responsiveOptions.length; i++) {
|
|
var res = this.responsiveOptions[i];
|
|
|
|
if (parseInt(res.breakpoint, 10) >= windowWidth) {
|
|
matchedResponsiveData = res;
|
|
}
|
|
}
|
|
|
|
var state = {};
|
|
|
|
if (this.state.numScroll !== matchedResponsiveData.numScroll) {
|
|
var page = this.getPage();
|
|
page = Math.floor(page * this.state.numScroll / matchedResponsiveData.numScroll);
|
|
var totalShiftedItems = matchedResponsiveData.numScroll * page * -1;
|
|
|
|
if (this.isCircular()) {
|
|
totalShiftedItems -= matchedResponsiveData.numVisible;
|
|
}
|
|
|
|
state = {
|
|
totalShiftedItems: totalShiftedItems,
|
|
numScroll: matchedResponsiveData.numScroll
|
|
};
|
|
|
|
if (this.props.onPageChange) {
|
|
this.props.onPageChange({
|
|
page: page
|
|
});
|
|
} else {
|
|
state = _objectSpread$J(_objectSpread$J({}, state), {}, {
|
|
page: page
|
|
});
|
|
}
|
|
}
|
|
|
|
if (this.state.numVisible !== matchedResponsiveData.numVisible) {
|
|
state = _objectSpread$J(_objectSpread$J({}, state), {}, {
|
|
numVisible: matchedResponsiveData.numVisible
|
|
});
|
|
}
|
|
|
|
if (Object.keys(state).length) {
|
|
this.setState(state);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "navBackward",
|
|
value: function navBackward(e, page) {
|
|
if (this.circular || this.getPage() !== 0) {
|
|
this.step(1, page);
|
|
}
|
|
|
|
this.allowAutoplay = false;
|
|
|
|
if (e.cancelable) {
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "navForward",
|
|
value: function navForward(e, page) {
|
|
if (this.circular || this.getPage() < this.totalIndicators - 1) {
|
|
this.step(-1, page);
|
|
}
|
|
|
|
this.allowAutoplay = false;
|
|
|
|
if (e.cancelable) {
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDotClick",
|
|
value: function onDotClick(e, page) {
|
|
var currentPage = this.getPage();
|
|
|
|
if (page > currentPage) {
|
|
this.navForward(e, page);
|
|
} else if (page < currentPage) {
|
|
this.navBackward(e, page);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onTransitionEnd",
|
|
value: function onTransitionEnd(e) {
|
|
if (this.itemsContainer && e.propertyName === 'transform') {
|
|
DomHandler.addClass(this.itemsContainer, 'p-items-hidden');
|
|
this.itemsContainer.style.transition = '';
|
|
|
|
if ((this.state.page === 0 || this.state.page === this.totalIndicators - 1) && this.isCircular()) {
|
|
this.changePosition(this.state.totalShiftedItems);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onTouchStart",
|
|
value: function onTouchStart(e) {
|
|
var touchobj = e.changedTouches[0];
|
|
this.startPos = {
|
|
x: touchobj.pageX,
|
|
y: touchobj.pageY
|
|
};
|
|
}
|
|
}, {
|
|
key: "onTouchMove",
|
|
value: function onTouchMove(e) {
|
|
if (e.cancelable) {
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onTouchEnd",
|
|
value: function onTouchEnd(e) {
|
|
var touchobj = e.changedTouches[0];
|
|
|
|
if (this.isVertical()) {
|
|
this.changePageOnTouch(e, touchobj.pageY - this.startPos.y);
|
|
} else {
|
|
this.changePageOnTouch(e, touchobj.pageX - this.startPos.x);
|
|
}
|
|
}
|
|
}, {
|
|
key: "changePageOnTouch",
|
|
value: function changePageOnTouch(e, diff) {
|
|
if (Math.abs(diff) > this.swipeThreshold) {
|
|
if (diff < 0) {
|
|
// left
|
|
this.navForward(e);
|
|
} else {
|
|
// right
|
|
this.navBackward(e);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindDocumentListeners",
|
|
value: function bindDocumentListeners() {
|
|
var _this2 = this;
|
|
|
|
if (!this.documentResizeListener) {
|
|
this.documentResizeListener = function () {
|
|
_this2.calculatePosition();
|
|
};
|
|
|
|
window.addEventListener('resize', this.documentResizeListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentListeners",
|
|
value: function unbindDocumentListeners() {
|
|
if (this.documentResizeListener) {
|
|
window.removeEventListener('resize', this.documentResizeListener);
|
|
this.documentResizeListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "isVertical",
|
|
value: function isVertical() {
|
|
return this.props.orientation === 'vertical';
|
|
}
|
|
}, {
|
|
key: "isCircular",
|
|
value: function isCircular() {
|
|
return this.circular && this.props.value.length >= this.state.numVisible;
|
|
}
|
|
}, {
|
|
key: "getPage",
|
|
value: function getPage() {
|
|
return this.props.onPageChange ? this.props.page : this.state.page;
|
|
}
|
|
}, {
|
|
key: "getTotalIndicators",
|
|
value: function getTotalIndicators() {
|
|
return this.props.value ? Math.ceil((this.props.value.length - this.state.numVisible) / this.state.numScroll) + 1 : 0;
|
|
}
|
|
}, {
|
|
key: "isAutoplay",
|
|
value: function isAutoplay() {
|
|
return this.props.autoplayInterval && this.allowAutoplay;
|
|
}
|
|
}, {
|
|
key: "startAutoplay",
|
|
value: function startAutoplay() {
|
|
var _this3 = this;
|
|
|
|
this.interval = setInterval(function () {
|
|
if (_this3.state.page === _this3.totalIndicators - 1) {
|
|
_this3.step(-1, 0);
|
|
} else {
|
|
_this3.step(-1, _this3.state.page + 1);
|
|
}
|
|
}, this.props.autoplayInterval);
|
|
}
|
|
}, {
|
|
key: "stopAutoplay",
|
|
value: function stopAutoplay() {
|
|
if (this.interval) {
|
|
clearInterval(this.interval);
|
|
}
|
|
}
|
|
}, {
|
|
key: "createStyle",
|
|
value: function createStyle() {
|
|
if (!this.carouselStyle) {
|
|
this.carouselStyle = DomHandler.createInlineStyle(PrimeReact.nonce);
|
|
}
|
|
|
|
var innerHTML = "\n .p-carousel[".concat(this.attributeSelector, "] .p-carousel-item {\n flex: 1 0 ").concat(100 / this.state.numVisible, "%\n }\n ");
|
|
|
|
if (this.props.responsiveOptions) {
|
|
this.responsiveOptions = _toConsumableArray(this.props.responsiveOptions);
|
|
this.responsiveOptions.sort(function (data1, data2) {
|
|
var value1 = data1.breakpoint;
|
|
var value2 = data2.breakpoint;
|
|
var result = null;
|
|
if (value1 == null && value2 != null) result = -1;else if (value1 != null && value2 == null) result = 1;else if (value1 == null && value2 == null) result = 0;else if (typeof value1 === 'string' && typeof value2 === 'string') result = value1.localeCompare(value2, undefined, {
|
|
numeric: true
|
|
});else result = value1 < value2 ? -1 : value1 > value2 ? 1 : 0;
|
|
return -1 * result;
|
|
});
|
|
|
|
for (var i = 0; i < this.responsiveOptions.length; i++) {
|
|
var res = this.responsiveOptions[i];
|
|
innerHTML += "\n @media screen and (max-width: ".concat(res.breakpoint, ") {\n .p-carousel[").concat(this.attributeSelector, "] .p-carousel-item {\n flex: 1 0 ").concat(100 / res.numVisible, "%\n }\n }\n ");
|
|
}
|
|
}
|
|
|
|
this.carouselStyle.innerHTML = innerHTML;
|
|
}
|
|
}, {
|
|
key: "changePosition",
|
|
value: function changePosition(totalShiftedItems) {
|
|
if (this.itemsContainer) {
|
|
this.itemsContainer.style.transform = this.isVertical() ? "translate3d(0, ".concat(totalShiftedItems * (100 / this.state.numVisible), "%, 0)") : "translate3d(".concat(totalShiftedItems * (100 / this.state.numVisible), "%, 0, 0)");
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (this.container) {
|
|
this.container.setAttribute(this.attributeSelector, '');
|
|
}
|
|
|
|
this.createStyle();
|
|
this.calculatePosition();
|
|
this.changePosition(this.state.totalShiftedItems);
|
|
|
|
if (this.props.responsiveOptions) {
|
|
this.bindDocumentListeners();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps, prevState) {
|
|
var isCircular = this.isCircular();
|
|
var stateChanged = false;
|
|
var totalShiftedItems = this.state.totalShiftedItems;
|
|
|
|
if (this.props.autoplayInterval) {
|
|
this.stopAutoplay();
|
|
}
|
|
|
|
if (prevState.numScroll !== this.state.numScroll || prevState.numVisible !== this.state.numVisible || this.props.value && prevProps.value && prevProps.value.length !== this.props.value.length) {
|
|
this.remainingItems = (this.props.value.length - this.state.numVisible) % this.state.numScroll;
|
|
var page = this.getPage();
|
|
|
|
if (this.totalIndicators !== 0 && page >= this.totalIndicators) {
|
|
page = this.totalIndicators - 1;
|
|
|
|
if (this.props.onPageChange) {
|
|
this.props.onPageChange({
|
|
page: page
|
|
});
|
|
} else {
|
|
this.setState({
|
|
page: page
|
|
});
|
|
}
|
|
|
|
stateChanged = true;
|
|
}
|
|
|
|
totalShiftedItems = page * this.state.numScroll * -1;
|
|
|
|
if (isCircular) {
|
|
totalShiftedItems -= this.state.numVisible;
|
|
}
|
|
|
|
if (page === this.totalIndicators - 1 && this.remainingItems > 0) {
|
|
totalShiftedItems += -1 * this.remainingItems + this.state.numScroll;
|
|
this.isRemainingItemsAdded = true;
|
|
} else {
|
|
this.isRemainingItemsAdded = false;
|
|
}
|
|
|
|
if (totalShiftedItems !== this.state.totalShiftedItems) {
|
|
this.setState({
|
|
totalShiftedItems: totalShiftedItems
|
|
});
|
|
stateChanged = true;
|
|
}
|
|
|
|
this.changePosition(totalShiftedItems);
|
|
}
|
|
|
|
if (isCircular) {
|
|
if (this.state.page === 0) {
|
|
totalShiftedItems = -1 * this.state.numVisible;
|
|
} else if (totalShiftedItems === 0) {
|
|
totalShiftedItems = -1 * this.props.value.length;
|
|
|
|
if (this.remainingItems > 0) {
|
|
this.isRemainingItemsAdded = true;
|
|
}
|
|
}
|
|
|
|
if (totalShiftedItems !== this.state.totalShiftedItems) {
|
|
this.setState({
|
|
totalShiftedItems: totalShiftedItems
|
|
});
|
|
stateChanged = true;
|
|
}
|
|
}
|
|
|
|
if (prevProps.page !== this.props.page) {
|
|
if (this.props.page > prevProps.page && this.props.page <= this.totalIndicators - 1) {
|
|
this.step(-1, this.props.page);
|
|
} else if (this.props.page < prevProps.page) {
|
|
this.step(1, this.props.page);
|
|
}
|
|
}
|
|
|
|
if (!stateChanged && this.isAutoplay()) {
|
|
this.startAutoplay();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.props.responsiveOptions) {
|
|
this.unbindDocumentListeners();
|
|
}
|
|
|
|
if (this.props.autoplayInterval) {
|
|
this.stopAutoplay();
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderItems",
|
|
value: function renderItems() {
|
|
var _this4 = this;
|
|
|
|
if (this.props.value && this.props.value.length) {
|
|
var isCircular = this.isCircular();
|
|
var clonedItemsForStarting = null;
|
|
var clonedItemsForFinishing = null;
|
|
|
|
if (isCircular) {
|
|
var clonedElements = null;
|
|
clonedElements = this.props.value.slice(-1 * this.state.numVisible);
|
|
clonedItemsForStarting = clonedElements.map(function (item, index) {
|
|
var isActive = _this4.state.totalShiftedItems * -1 === _this4.props.value.length + _this4.state.numVisible,
|
|
start = index === 0,
|
|
end = index === clonedElements.length - 1;
|
|
return /*#__PURE__*/React.createElement(CarouselItem, {
|
|
key: index + '_scloned',
|
|
className: "p-carousel-item-cloned",
|
|
template: _this4.props.itemTemplate,
|
|
item: item,
|
|
active: isActive,
|
|
start: start,
|
|
end: end
|
|
});
|
|
});
|
|
clonedElements = this.props.value.slice(0, this.state.numVisible);
|
|
clonedItemsForFinishing = clonedElements.map(function (item, index) {
|
|
var isActive = _this4.state.totalShiftedItems === 0,
|
|
start = index === 0,
|
|
end = index === clonedElements.length - 1;
|
|
return /*#__PURE__*/React.createElement(CarouselItem, {
|
|
key: index + '_fcloned',
|
|
className: "p-carousel-item-cloned",
|
|
template: _this4.props.itemTemplate,
|
|
item: item,
|
|
active: isActive,
|
|
start: start,
|
|
end: end
|
|
});
|
|
});
|
|
}
|
|
|
|
var items = this.props.value.map(function (item, index) {
|
|
var firstIndex = isCircular ? -1 * (_this4.state.totalShiftedItems + _this4.state.numVisible) : _this4.state.totalShiftedItems * -1,
|
|
lastIndex = firstIndex + _this4.state.numVisible - 1,
|
|
isActive = firstIndex <= index && lastIndex >= index,
|
|
start = firstIndex === index,
|
|
end = lastIndex === index;
|
|
return /*#__PURE__*/React.createElement(CarouselItem, {
|
|
key: index,
|
|
template: _this4.props.itemTemplate,
|
|
item: item,
|
|
active: isActive,
|
|
start: start,
|
|
end: end
|
|
});
|
|
});
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, clonedItemsForStarting, items, clonedItemsForFinishing);
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderHeader",
|
|
value: function renderHeader() {
|
|
if (this.props.header) {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-carousel-header"
|
|
}, this.props.header);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderFooter",
|
|
value: function renderFooter() {
|
|
if (this.props.footer) {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-carousel-footer"
|
|
}, this.props.footer);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
var _this5 = this;
|
|
|
|
var items = this.renderItems();
|
|
var height = this.isVertical() ? this.props.verticalViewPortHeight : 'auto';
|
|
var backwardNavigator = this.renderBackwardNavigator();
|
|
var forwardNavigator = this.renderForwardNavigator();
|
|
var containerClassName = classNames('p-carousel-container', this.props.containerClassName);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: containerClassName
|
|
}, backwardNavigator, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-carousel-items-content",
|
|
style: {
|
|
'height': height
|
|
},
|
|
onTouchStart: this.onTouchStart,
|
|
onTouchMove: this.onTouchMove,
|
|
onTouchEnd: this.onTouchEnd
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this5.itemsContainer = el;
|
|
},
|
|
className: "p-carousel-items-container",
|
|
onTransitionEnd: this.onTransitionEnd
|
|
}, items)), forwardNavigator);
|
|
}
|
|
}, {
|
|
key: "renderBackwardNavigator",
|
|
value: function renderBackwardNavigator() {
|
|
var isDisabled = (!this.circular || this.props.value && this.props.value.length < this.state.numVisible) && this.getPage() === 0;
|
|
var buttonClassName = classNames('p-carousel-prev p-link', {
|
|
'p-disabled': isDisabled
|
|
}),
|
|
iconClassName = classNames('p-carousel-prev-icon pi', {
|
|
'pi-chevron-left': !this.isVertical(),
|
|
'pi-chevron-up': this.isVertical()
|
|
});
|
|
return /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: buttonClassName,
|
|
onClick: this.navBackward,
|
|
disabled: isDisabled
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
}, {
|
|
key: "renderForwardNavigator",
|
|
value: function renderForwardNavigator() {
|
|
var isDisabled = (!this.circular || this.props.value && this.props.value.length < this.state.numVisible) && (this.getPage() === this.totalIndicators - 1 || this.totalIndicators === 0);
|
|
var buttonClassName = classNames('p-carousel-next p-link', {
|
|
'p-disabled': isDisabled
|
|
}),
|
|
iconClassName = classNames('p-carousel-next-icon pi', {
|
|
'pi-chevron-right': !this.isVertical(),
|
|
'pi-chevron-down': this.isVertical()
|
|
});
|
|
return /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: buttonClassName,
|
|
onClick: this.navForward,
|
|
disabled: isDisabled
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
}, {
|
|
key: "renderIndicator",
|
|
value: function renderIndicator(index) {
|
|
var _this6 = this;
|
|
|
|
var isActive = this.getPage() === index,
|
|
indicatorItemClassName = classNames('p-carousel-indicator', {
|
|
'p-highlight': isActive
|
|
});
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
className: indicatorItemClassName,
|
|
key: 'p-carousel-indicator-' + index
|
|
}, /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "p-link",
|
|
onClick: function onClick(e) {
|
|
return _this6.onDotClick(e, index);
|
|
}
|
|
}, /*#__PURE__*/React.createElement(Ripple, null)));
|
|
}
|
|
}, {
|
|
key: "renderIndicators",
|
|
value: function renderIndicators() {
|
|
var indicatorsContentClassName = classNames('p-carousel-indicators p-reset', this.props.indicatorsContentClassName);
|
|
var indicators = [];
|
|
|
|
for (var i = 0; i < this.totalIndicators; i++) {
|
|
indicators.push(this.renderIndicator(i));
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
className: indicatorsContentClassName
|
|
}, indicators);
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this7 = this;
|
|
|
|
var className = classNames('p-carousel p-component', {
|
|
'p-carousel-vertical': this.isVertical(),
|
|
'p-carousel-horizontal': !this.isVertical()
|
|
}, this.props.className);
|
|
var contentClassName = classNames('p-carousel-content', this.props.contentClassName);
|
|
this.totalIndicators = this.getTotalIndicators();
|
|
var content = this.renderContent();
|
|
var indicators = this.renderIndicators();
|
|
var header = this.renderHeader();
|
|
var footer = this.renderFooter();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this7.container = el;
|
|
},
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, header, /*#__PURE__*/React.createElement("div", {
|
|
className: contentClassName
|
|
}, content, indicators), footer);
|
|
}
|
|
}]);
|
|
|
|
return Carousel;
|
|
}(Component);
|
|
|
|
_defineProperty(Carousel, "defaultProps", {
|
|
id: null,
|
|
value: null,
|
|
page: 0,
|
|
header: null,
|
|
footer: null,
|
|
style: null,
|
|
className: null,
|
|
itemTemplate: null,
|
|
circular: false,
|
|
autoplayInterval: 0,
|
|
numVisible: 1,
|
|
numScroll: 1,
|
|
responsiveOptions: null,
|
|
orientation: "horizontal",
|
|
verticalViewPortHeight: "300px",
|
|
contentClassName: null,
|
|
containerClassName: null,
|
|
indicatorsContentClassName: null,
|
|
onPageChange: null
|
|
});
|
|
|
|
function _createForOfIteratorHelper$e(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$e(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$e(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$e(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$e(o, minLen); }
|
|
|
|
function _arrayLikeToArray$e(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 _createSuper$22(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$22(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$22() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var CascadeSelectSub = /*#__PURE__*/function (_Component) {
|
|
_inherits(CascadeSelectSub, _Component);
|
|
|
|
var _super = _createSuper$22(CascadeSelectSub);
|
|
|
|
function CascadeSelectSub(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, CascadeSelectSub);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
activeOption: null
|
|
};
|
|
_this.onOptionSelect = _this.onOptionSelect.bind(_assertThisInitialized(_this));
|
|
_this.onOptionGroupSelect = _this.onOptionGroupSelect.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(CascadeSelectSub, [{
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (this.props.selectionPath && this.props.options && !this.props.dirty) {
|
|
var _iterator = _createForOfIteratorHelper$e(this.props.options),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var option = _step.value;
|
|
|
|
if (this.props.selectionPath.includes(option)) {
|
|
this.setState({
|
|
activeOption: option
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
}
|
|
|
|
if (!this.props.root) {
|
|
this.position();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.parentActive !== this.props.parentActive) {
|
|
this.setState({
|
|
activeOption: null
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "position",
|
|
value: function position() {
|
|
var parentItem = this.element.parentElement;
|
|
var containerOffset = DomHandler.getOffset(parentItem);
|
|
var viewport = DomHandler.getViewport();
|
|
var sublistWidth = this.element.offsetParent ? this.element.offsetWidth : DomHandler.getHiddenElementOuterWidth(this.element);
|
|
var itemOuterWidth = DomHandler.getOuterWidth(parentItem.children[0]);
|
|
|
|
if (parseInt(containerOffset.left, 10) + itemOuterWidth + sublistWidth > viewport.width - DomHandler.calculateScrollbarWidth()) {
|
|
this.element.style.left = '-100%';
|
|
}
|
|
}
|
|
}, {
|
|
key: "onOptionSelect",
|
|
value: function onOptionSelect(event) {
|
|
if (this.props.onOptionSelect) {
|
|
this.props.onOptionSelect(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event, option) {
|
|
var listItem = event.currentTarget.parentElement;
|
|
|
|
switch (event.key) {
|
|
case 'Down':
|
|
case 'ArrowDown':
|
|
var nextItem = this.findNextItem(listItem);
|
|
|
|
if (nextItem) {
|
|
nextItem.children[0].focus();
|
|
}
|
|
|
|
break;
|
|
|
|
case 'Up':
|
|
case 'ArrowUp':
|
|
var prevItem = this.findPrevItem(listItem);
|
|
|
|
if (prevItem) {
|
|
prevItem.children[0].focus();
|
|
}
|
|
|
|
break;
|
|
|
|
case 'Right':
|
|
case 'ArrowRight':
|
|
if (this.isOptionGroup(option)) {
|
|
if (this.state.activeOption === option) {
|
|
listItem.children[1].children[0].children[0].focus();
|
|
} else {
|
|
this.setState({
|
|
activeOption: option
|
|
});
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case 'Left':
|
|
case 'ArrowLeft':
|
|
this.setState({
|
|
activeOption: null
|
|
});
|
|
var parentList = event.currentTarget.parentElement.parentElement.previousElementSibling;
|
|
|
|
if (parentList) {
|
|
parentList.focus();
|
|
}
|
|
|
|
break;
|
|
|
|
case 'Enter':
|
|
this.onOptionClick(event, option);
|
|
break;
|
|
|
|
case 'Tab':
|
|
case 'Escape':
|
|
if (this.props.onPanelHide) {
|
|
this.props.onPanelHide();
|
|
event.preventDefault();
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "findNextItem",
|
|
value: function findNextItem(item) {
|
|
var nextItem = item.nextElementSibling;
|
|
if (nextItem) return DomHandler.hasClass(nextItem, 'p-disabled') || !DomHandler.hasClass(nextItem, 'p-cascadeselect-item') ? this.findNextItem(nextItem) : nextItem;else return null;
|
|
}
|
|
}, {
|
|
key: "findPrevItem",
|
|
value: function findPrevItem(item) {
|
|
var prevItem = item.previousElementSibling;
|
|
if (prevItem) return DomHandler.hasClass(prevItem, 'p-disabled') || !DomHandler.hasClass(prevItem, 'p-cascadeselect-item') ? this.findPrevItem(prevItem) : prevItem;else return null;
|
|
}
|
|
}, {
|
|
key: "onOptionClick",
|
|
value: function onOptionClick(event, option) {
|
|
if (this.isOptionGroup(option)) {
|
|
this.setState({
|
|
activeOption: this.state.activeOption === option ? null : option
|
|
});
|
|
|
|
if (this.props.onOptionGroupSelect) {
|
|
this.props.onOptionGroupSelect({
|
|
originalEvent: event,
|
|
value: option
|
|
});
|
|
}
|
|
} else {
|
|
if (this.props.onOptionSelect) {
|
|
this.props.onOptionSelect({
|
|
originalEvent: event,
|
|
value: this.getOptionValue(option)
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onOptionGroupSelect",
|
|
value: function onOptionGroupSelect(event) {
|
|
if (this.props.onOptionGroupSelect) {
|
|
this.props.onOptionGroupSelect(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "getOptionLabel",
|
|
value: function getOptionLabel(option) {
|
|
return this.props.optionLabel ? ObjectUtils.resolveFieldData(option, this.props.optionLabel) : option;
|
|
}
|
|
}, {
|
|
key: "getOptionValue",
|
|
value: function getOptionValue(option) {
|
|
return this.props.optionValue ? ObjectUtils.resolveFieldData(option, this.props.optionValue) : option;
|
|
}
|
|
}, {
|
|
key: "getOptionGroupLabel",
|
|
value: function getOptionGroupLabel(optionGroup) {
|
|
return this.props.optionGroupLabel ? ObjectUtils.resolveFieldData(optionGroup, this.props.optionGroupLabel) : null;
|
|
}
|
|
}, {
|
|
key: "getOptionGroupChildren",
|
|
value: function getOptionGroupChildren(optionGroup) {
|
|
return ObjectUtils.resolveFieldData(optionGroup, this.props.optionGroupChildren[this.props.level]);
|
|
}
|
|
}, {
|
|
key: "isOptionGroup",
|
|
value: function isOptionGroup(option) {
|
|
return Object.prototype.hasOwnProperty.call(option, this.props.optionGroupChildren[this.props.level]);
|
|
}
|
|
}, {
|
|
key: "getOptionLabelToRender",
|
|
value: function getOptionLabelToRender(option) {
|
|
return this.isOptionGroup(option) ? this.getOptionGroupLabel(option) : this.getOptionLabel(option);
|
|
}
|
|
}, {
|
|
key: "renderSubmenu",
|
|
value: function renderSubmenu(option) {
|
|
if (this.isOptionGroup(option) && this.state.activeOption === option) {
|
|
return /*#__PURE__*/React.createElement(CascadeSelectSub, {
|
|
options: this.getOptionGroupChildren(option),
|
|
className: "p-cascadeselect-sublist",
|
|
selectionPath: this.props.selectionPath,
|
|
optionLabel: this.props.optionLabel,
|
|
optionValue: this.props.optionValue,
|
|
level: this.props.level + 1,
|
|
onOptionSelect: this.onOptionSelect,
|
|
onOptionGroupSelect: this.onOptionGroupSelect,
|
|
parentActive: this.state.activeOption === option,
|
|
optionGroupLabel: this.props.optionGroupLabel,
|
|
optionGroupChildren: this.props.optionGroupChildren,
|
|
dirty: this.props.dirty,
|
|
template: this.props.template,
|
|
onPanelHide: this.props.onPanelHide
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderOption",
|
|
value: function renderOption(option, index) {
|
|
var _this2 = this;
|
|
|
|
var className = classNames('p-cascadeselect-item', {
|
|
'p-cascadeselect-item-group': this.isOptionGroup(option),
|
|
'p-cascadeselect-item-active p-highlight': this.state.activeOption === option
|
|
}, option.className);
|
|
var submenu = this.renderSubmenu(option);
|
|
var content = this.props.template ? ObjectUtils.getJSXElement(this.props.template, this.getOptionValue(option)) : /*#__PURE__*/React.createElement("span", {
|
|
className: "p-cascadeselect-item-text"
|
|
}, this.getOptionLabelToRender(option));
|
|
var optionGroup = this.isOptionGroup(option) && /*#__PURE__*/React.createElement("span", {
|
|
className: "p-cascadeselect-group-icon pi pi-angle-right"
|
|
});
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: this.getOptionLabelToRender(option) + '_' + index,
|
|
className: className,
|
|
style: option.style,
|
|
role: "none"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-cascadeselect-item-content",
|
|
onClick: function onClick(event) {
|
|
return _this2.onOptionClick(event, option);
|
|
},
|
|
tabIndex: 0,
|
|
onKeyDown: function onKeyDown(event) {
|
|
return _this2.onKeyDown(event, option);
|
|
}
|
|
}, content, optionGroup, /*#__PURE__*/React.createElement(Ripple, null)), submenu);
|
|
}
|
|
}, {
|
|
key: "renderMenu",
|
|
value: function renderMenu() {
|
|
var _this3 = this;
|
|
|
|
if (this.props.options) {
|
|
return this.props.options.map(function (option, index) {
|
|
return _this3.renderOption(option, index);
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this4 = this;
|
|
|
|
var className = classNames('p-cascadeselect-panel p-cascadeselect-items', this.props.className);
|
|
var submenu = this.renderMenu();
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
ref: function ref(el) {
|
|
return _this4.element = el;
|
|
},
|
|
className: className,
|
|
role: "listbox",
|
|
"aria-orientation": "horizontal"
|
|
}, submenu);
|
|
}
|
|
}]);
|
|
|
|
return CascadeSelectSub;
|
|
}(Component);
|
|
|
|
_defineProperty(CascadeSelectSub, "defaultProps", {
|
|
options: null,
|
|
selectionPath: false,
|
|
className: null,
|
|
optionLabel: null,
|
|
optionValue: null,
|
|
level: null,
|
|
optionGroupLabel: null,
|
|
optionGroupChildren: null,
|
|
parentActive: null,
|
|
dirty: null,
|
|
root: null,
|
|
template: null,
|
|
onOptionSelect: null,
|
|
onOptionGroupSelect: null
|
|
});
|
|
|
|
function _createForOfIteratorHelper$d(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$d(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$d(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$d(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$d(o, minLen); }
|
|
|
|
function _arrayLikeToArray$d(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 _createSuper$21(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$21(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$21() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var CascadeSelect = /*#__PURE__*/function (_Component) {
|
|
_inherits(CascadeSelect, _Component);
|
|
|
|
var _super = _createSuper$21(CascadeSelect);
|
|
|
|
function CascadeSelect(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, CascadeSelect);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
focused: false,
|
|
overlayVisible: false
|
|
};
|
|
_this.dirty = false;
|
|
_this.selectionPath = null;
|
|
_this.overlayRef = /*#__PURE__*/createRef();
|
|
_this.inputRef = /*#__PURE__*/createRef(_this.props.inputRef);
|
|
_this.hide = _this.hide.bind(_assertThisInitialized(_this));
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onInputFocus = _this.onInputFocus.bind(_assertThisInitialized(_this));
|
|
_this.onInputBlur = _this.onInputBlur.bind(_assertThisInitialized(_this));
|
|
_this.onInputKeyDown = _this.onInputKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEnter = _this.onOverlayEnter.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEntered = _this.onOverlayEntered.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExit = _this.onOverlayExit.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExited = _this.onOverlayExited.bind(_assertThisInitialized(_this));
|
|
_this.onOptionSelect = _this.onOptionSelect.bind(_assertThisInitialized(_this));
|
|
_this.onOptionGroupSelect = _this.onOptionGroupSelect.bind(_assertThisInitialized(_this));
|
|
_this.onPanelClick = _this.onPanelClick.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(CascadeSelect, [{
|
|
key: "onOptionSelect",
|
|
value: function onOptionSelect(event) {
|
|
if (this.props.onChange) {
|
|
this.props.onChange({
|
|
originalEvent: event,
|
|
value: event.value
|
|
});
|
|
}
|
|
|
|
this.updateSelectionPath();
|
|
this.hide();
|
|
this.inputRef.current.focus();
|
|
}
|
|
}, {
|
|
key: "onOptionGroupSelect",
|
|
value: function onOptionGroupSelect(event) {
|
|
this.dirty = true;
|
|
|
|
if (this.props.onGroupChange) {
|
|
this.props.onGroupChange(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "getOptionLabel",
|
|
value: function getOptionLabel(option) {
|
|
return this.props.optionLabel ? ObjectUtils.resolveFieldData(option, this.props.optionLabel) : option;
|
|
}
|
|
}, {
|
|
key: "getOptionValue",
|
|
value: function getOptionValue(option) {
|
|
return this.props.optionValue ? ObjectUtils.resolveFieldData(option, this.props.optionValue) : option;
|
|
}
|
|
}, {
|
|
key: "getOptionGroupChildren",
|
|
value: function getOptionGroupChildren(optionGroup, level) {
|
|
return ObjectUtils.resolveFieldData(optionGroup, this.props.optionGroupChildren[level]);
|
|
}
|
|
}, {
|
|
key: "isOptionGroup",
|
|
value: function isOptionGroup(option, level) {
|
|
return Object.prototype.hasOwnProperty.call(option, this.props.optionGroupChildren[level]);
|
|
}
|
|
}, {
|
|
key: "updateSelectionPath",
|
|
value: function updateSelectionPath() {
|
|
var path;
|
|
|
|
if (this.props.value != null && this.props.options) {
|
|
var _iterator = _createForOfIteratorHelper$d(this.props.options),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var option = _step.value;
|
|
path = this.findModelOptionInGroup(option, 0);
|
|
|
|
if (path) {
|
|
break;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
}
|
|
|
|
this.selectionPath = path;
|
|
}
|
|
}, {
|
|
key: "findModelOptionInGroup",
|
|
value: function findModelOptionInGroup(option, level) {
|
|
if (this.isOptionGroup(option, level)) {
|
|
var selectedOption;
|
|
|
|
var _iterator2 = _createForOfIteratorHelper$d(this.getOptionGroupChildren(option, level)),
|
|
_step2;
|
|
|
|
try {
|
|
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
|
|
var childOption = _step2.value;
|
|
selectedOption = this.findModelOptionInGroup(childOption, level + 1);
|
|
|
|
if (selectedOption) {
|
|
selectedOption.unshift(option);
|
|
return selectedOption;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator2.e(err);
|
|
} finally {
|
|
_iterator2.f();
|
|
}
|
|
} else if (ObjectUtils.equals(this.props.value, this.getOptionValue(option), this.props.dataKey)) {
|
|
return [option];
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
if (this.props.disabled) {
|
|
return;
|
|
}
|
|
|
|
var overlay = this.overlayRef ? this.overlayRef.current : null;
|
|
|
|
if (!overlay || !overlay.contains(event.target)) {
|
|
this.inputRef.current.focus();
|
|
|
|
if (this.state.overlayVisible) {
|
|
this.hide();
|
|
} else {
|
|
this.show();
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onInputFocus",
|
|
value: function onInputFocus() {
|
|
this.setState({
|
|
focused: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "onInputBlur",
|
|
value: function onInputBlur() {
|
|
this.setState({
|
|
focused: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "onInputKeyDown",
|
|
value: function onInputKeyDown(event) {
|
|
switch (event.which) {
|
|
//down
|
|
case 40:
|
|
if (this.state.overlayVisible) {
|
|
DomHandler.findSingle(this.overlayRef.current, '.p-cascadeselect-item').children[0].focus();
|
|
} else if (event.altKey && this.props.options && this.props.options.length) {
|
|
this.show();
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//space
|
|
|
|
case 32:
|
|
if (this.state.overlayVisible) this.hide();else this.show();
|
|
event.preventDefault();
|
|
break;
|
|
//tab
|
|
|
|
case 9:
|
|
this.hide();
|
|
break;
|
|
}
|
|
}
|
|
}, {
|
|
key: "onPanelClick",
|
|
value: function onPanelClick(event) {
|
|
OverlayService.emit('overlay-click', {
|
|
originalEvent: event,
|
|
target: this.container
|
|
});
|
|
}
|
|
}, {
|
|
key: "show",
|
|
value: function show() {
|
|
if (this.props.onBeforeShow) {
|
|
this.props.onBeforeShow();
|
|
}
|
|
|
|
this.setState({
|
|
overlayVisible: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "hide",
|
|
value: function hide() {
|
|
var _this2 = this;
|
|
|
|
if (this.props.onBeforeHide) {
|
|
this.props.onBeforeHide();
|
|
}
|
|
|
|
this.setState({
|
|
overlayVisible: false
|
|
}, function () {
|
|
_this2.inputRef.current.focus();
|
|
});
|
|
}
|
|
}, {
|
|
key: "onOverlayEnter",
|
|
value: function onOverlayEnter() {
|
|
ZIndexUtils.set('overlay', this.overlayRef.current, PrimeReact.autoZIndex, PrimeReact.zIndex['overlay']);
|
|
this.alignOverlay();
|
|
}
|
|
}, {
|
|
key: "onOverlayEntered",
|
|
value: function onOverlayEntered() {
|
|
this.bindOutsideClickListener();
|
|
this.bindScrollListener();
|
|
this.bindResizeListener();
|
|
this.props.onShow && this.props.onShow();
|
|
}
|
|
}, {
|
|
key: "onOverlayExit",
|
|
value: function onOverlayExit() {
|
|
this.unbindOutsideClickListener();
|
|
this.unbindScrollListener();
|
|
this.unbindResizeListener();
|
|
this.dirty = false;
|
|
}
|
|
}, {
|
|
key: "onOverlayExited",
|
|
value: function onOverlayExited() {
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
this.props.onHide && this.props.onHide();
|
|
}
|
|
}, {
|
|
key: "alignOverlay",
|
|
value: function alignOverlay() {
|
|
DomHandler.alignOverlay(this.overlayRef.current, this.label.parentElement, this.props.appendTo || PrimeReact.appendTo);
|
|
}
|
|
}, {
|
|
key: "bindOutsideClickListener",
|
|
value: function bindOutsideClickListener() {
|
|
var _this3 = this;
|
|
|
|
if (!this.outsideClickListener) {
|
|
this.outsideClickListener = function (event) {
|
|
if (_this3.state.overlayVisible && _this3.isOutsideClicked(event)) {
|
|
_this3.hide();
|
|
}
|
|
};
|
|
|
|
document.addEventListener('click', this.outsideClickListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindOutsideClickListener",
|
|
value: function unbindOutsideClickListener() {
|
|
if (this.outsideClickListener) {
|
|
document.removeEventListener('click', this.outsideClickListener);
|
|
this.outsideClickListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindScrollListener",
|
|
value: function bindScrollListener() {
|
|
var _this4 = this;
|
|
|
|
if (!this.scrollHandler) {
|
|
this.scrollHandler = new ConnectedOverlayScrollHandler(this.container, function () {
|
|
if (_this4.state.overlayVisible) {
|
|
_this4.hide();
|
|
}
|
|
});
|
|
}
|
|
|
|
this.scrollHandler.bindScrollListener();
|
|
}
|
|
}, {
|
|
key: "unbindScrollListener",
|
|
value: function unbindScrollListener() {
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.unbindScrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindResizeListener",
|
|
value: function bindResizeListener() {
|
|
var _this5 = this;
|
|
|
|
if (!this.resizeListener) {
|
|
this.resizeListener = function () {
|
|
if (_this5.state.overlayVisible && !DomHandler.isTouchDevice()) {
|
|
_this5.hide();
|
|
}
|
|
};
|
|
|
|
window.addEventListener('resize', this.resizeListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindResizeListener",
|
|
value: function unbindResizeListener() {
|
|
if (this.resizeListener) {
|
|
window.removeEventListener('resize', this.resizeListener);
|
|
this.resizeListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "isOutsideClicked",
|
|
value: function isOutsideClicked(event) {
|
|
return this.container && !(this.container.isSameNode(event.target) || this.container.contains(event.target) || this.overlayRef && this.overlayRef.current.contains(event.target));
|
|
}
|
|
}, {
|
|
key: "updateInputRef",
|
|
value: function updateInputRef() {
|
|
var ref = this.props.inputRef;
|
|
|
|
if (ref) {
|
|
if (typeof ref === 'function') {
|
|
ref(this.inputRef.current);
|
|
} else {
|
|
ref.current = this.inputRef.current;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.updateInputRef();
|
|
this.updateSelectionPath();
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.unbindOutsideClickListener();
|
|
this.unbindResizeListener();
|
|
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.destroy();
|
|
this.scrollHandler = null;
|
|
}
|
|
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.value !== this.props.value) {
|
|
this.updateSelectionPath();
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderKeyboardHelper",
|
|
value: function renderKeyboardHelper() {
|
|
var value = this.props.value ? this.getOptionLabel(this.props.value) : null;
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-hidden-accessible"
|
|
}, /*#__PURE__*/React.createElement("input", {
|
|
ref: this.inputRef,
|
|
type: "text",
|
|
id: this.props.inputId,
|
|
name: this.props.name,
|
|
defaultValue: value,
|
|
readOnly: true,
|
|
disabled: this.props.disabled,
|
|
onFocus: this.onInputFocus,
|
|
onBlur: this.onInputBlur,
|
|
onKeyDown: this.onInputKeyDown,
|
|
tabIndex: this.props.tabIndex,
|
|
"aria-haspopup": "listbox",
|
|
"aria-labelledby": this.props.ariaLabelledBy
|
|
}));
|
|
}
|
|
}, {
|
|
key: "renderLabel",
|
|
value: function renderLabel() {
|
|
var _this6 = this;
|
|
|
|
var label = this.props.value ? this.getOptionLabel(this.props.value) : this.props.placeholder || 'p-emptylabel';
|
|
var labelClassName = classNames('p-cascadeselect-label ', {
|
|
'p-placeholder': label === this.props.placeholder,
|
|
'p-cascadeselect-label-empty': !this.props.value && label === 'p-emptylabel'
|
|
});
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
ref: function ref(el) {
|
|
return _this6.label = el;
|
|
},
|
|
className: labelClassName
|
|
}, label);
|
|
}
|
|
}, {
|
|
key: "renderDropdownIcon",
|
|
value: function renderDropdownIcon() {
|
|
var iconClassName = classNames('p-cascadeselect-trigger-icon', this.props.dropdownIcon);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-cascadeselect-trigger",
|
|
role: "button",
|
|
"aria-haspopup": "listbox",
|
|
"aria-expanded": this.state.overlayVisible
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
}));
|
|
}
|
|
}, {
|
|
key: "renderOverlay",
|
|
value: function renderOverlay() {
|
|
var overlay = /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.overlayRef,
|
|
classNames: "p-connected-overlay",
|
|
"in": this.state.overlayVisible,
|
|
timeout: {
|
|
enter: 120,
|
|
exit: 100
|
|
},
|
|
options: this.props.transitionOptions,
|
|
unmountOnExit: true,
|
|
onEnter: this.onOverlayEnter,
|
|
onEntered: this.onOverlayEntered,
|
|
onExit: this.onOverlayExit,
|
|
onExited: this.onOverlayExited
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.overlayRef,
|
|
className: "p-cascadeselect-panel p-component",
|
|
onClick: this.onPanelClick
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-cascadeselect-items-wrapper"
|
|
}, /*#__PURE__*/React.createElement(CascadeSelectSub, {
|
|
options: this.props.options,
|
|
selectionPath: this.selectionPath,
|
|
className: "p-cascadeselect-items",
|
|
optionLabel: this.props.optionLabel,
|
|
optionValue: this.props.optionValue,
|
|
level: 0,
|
|
optionGroupLabel: this.props.optionGroupLabel,
|
|
optionGroupChildren: this.props.optionGroupChildren,
|
|
onOptionSelect: this.onOptionSelect,
|
|
onOptionGroupSelect: this.onOptionGroupSelect,
|
|
root: true,
|
|
template: this.props.itemTemplate,
|
|
onPanelHide: this.hide
|
|
}))));
|
|
return /*#__PURE__*/React.createElement(Portal, {
|
|
element: overlay,
|
|
appendTo: this.props.appendTo
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
var _this7 = this;
|
|
|
|
var className = classNames('p-cascadeselect p-component p-inputwrapper', this.props.className, {
|
|
'p-disabled': this.props.disabled,
|
|
'p-focus': this.state.focused,
|
|
'p-inputwrapper-filled': this.props.value,
|
|
'p-inputwrapper-focus': this.state.focused || this.state.overlayVisible
|
|
});
|
|
var keyboardHelper = this.renderKeyboardHelper();
|
|
var labelElement = this.renderLabel();
|
|
var dropdownIcon = this.renderDropdownIcon();
|
|
var overlay = this.renderOverlay();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
ref: function ref(el) {
|
|
return _this7.container = el;
|
|
},
|
|
className: className,
|
|
style: this.props.style,
|
|
onClick: this.onClick
|
|
}, keyboardHelper, labelElement, dropdownIcon, overlay);
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var element = this.renderElement();
|
|
return element;
|
|
}
|
|
}]);
|
|
|
|
return CascadeSelect;
|
|
}(Component);
|
|
|
|
_defineProperty(CascadeSelect, "defaultProps", {
|
|
id: null,
|
|
inputRef: null,
|
|
style: null,
|
|
className: null,
|
|
value: null,
|
|
name: null,
|
|
options: null,
|
|
optionLabel: null,
|
|
optionValue: null,
|
|
optionGroupLabel: null,
|
|
optionGroupChildren: null,
|
|
placeholder: null,
|
|
itemTemplate: null,
|
|
disabled: false,
|
|
dataKey: null,
|
|
inputId: null,
|
|
tabIndex: null,
|
|
ariaLabelledBy: null,
|
|
appendTo: null,
|
|
transitionOptions: null,
|
|
dropdownIcon: 'pi pi-chevron-down',
|
|
onChange: null,
|
|
onGroupChange: null,
|
|
onBeforeShow: null,
|
|
onBeforeHide: null,
|
|
onShow: null,
|
|
onHide: null
|
|
});
|
|
|
|
function _createSuper$20(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$20(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$20() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Chart = /*#__PURE__*/function (_Component) {
|
|
_inherits(Chart, _Component);
|
|
|
|
var _super = _createSuper$20(Chart);
|
|
|
|
function Chart() {
|
|
_classCallCheck(this, Chart);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(Chart, [{
|
|
key: "initChart",
|
|
value: function initChart() {
|
|
var _this = this;
|
|
|
|
import('chart.js/auto').then(function (module) {
|
|
if (_this.chart) {
|
|
_this.chart.destroy();
|
|
|
|
_this.chart = null;
|
|
}
|
|
|
|
if (module && module["default"]) {
|
|
_this.chart = new module["default"](_this.canvas, {
|
|
type: _this.props.type,
|
|
data: _this.props.data,
|
|
options: _this.props.options,
|
|
plugins: _this.props.plugins
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "getCanvas",
|
|
value: function getCanvas() {
|
|
return this.canvas;
|
|
}
|
|
}, {
|
|
key: "getChart",
|
|
value: function getChart() {
|
|
return this.chart;
|
|
}
|
|
}, {
|
|
key: "getBase64Image",
|
|
value: function getBase64Image() {
|
|
return this.chart.toBase64Image();
|
|
}
|
|
}, {
|
|
key: "generateLegend",
|
|
value: function generateLegend() {
|
|
if (this.chart) {
|
|
this.chart.generateLegend();
|
|
}
|
|
}
|
|
}, {
|
|
key: "refresh",
|
|
value: function refresh() {
|
|
if (this.chart) {
|
|
this.chart.update();
|
|
}
|
|
}
|
|
}, {
|
|
key: "reinit",
|
|
value: function reinit() {
|
|
this.initChart();
|
|
}
|
|
}, {
|
|
key: "shouldComponentUpdate",
|
|
value: function shouldComponentUpdate(nextProps) {
|
|
if (nextProps.data === this.props.data && nextProps.options === this.props.options && nextProps.type === this.props.type) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.initChart();
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate() {
|
|
this.reinit();
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.chart) {
|
|
this.chart.destroy();
|
|
this.chart = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this2 = this;
|
|
|
|
var className = classNames('p-chart', this.props.className),
|
|
style = Object.assign({
|
|
width: this.props.width,
|
|
height: this.props.height
|
|
}, this.props.style);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
style: style,
|
|
className: className
|
|
}, /*#__PURE__*/React.createElement("canvas", {
|
|
ref: function ref(el) {
|
|
_this2.canvas = el;
|
|
},
|
|
width: this.props.width,
|
|
height: this.props.height
|
|
}));
|
|
}
|
|
}]);
|
|
|
|
return Chart;
|
|
}(Component);
|
|
|
|
_defineProperty(Chart, "defaultProps", {
|
|
id: null,
|
|
type: null,
|
|
data: null,
|
|
options: null,
|
|
plugins: null,
|
|
width: null,
|
|
height: null,
|
|
style: null,
|
|
className: null
|
|
});
|
|
|
|
function ownKeys$I(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$I(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$I(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$I(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$1$(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1$(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1$() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Checkbox = /*#__PURE__*/function (_Component) {
|
|
_inherits(Checkbox, _Component);
|
|
|
|
var _super = _createSuper$1$(Checkbox);
|
|
|
|
function Checkbox(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Checkbox);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
focused: false
|
|
};
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onFocus = _this.onFocus.bind(_assertThisInitialized(_this));
|
|
_this.onBlur = _this.onBlur.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.inputRef = /*#__PURE__*/createRef(_this.props.inputRef);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Checkbox, [{
|
|
key: "onClick",
|
|
value: function onClick(e) {
|
|
if (!this.props.disabled && !this.props.readOnly && this.props.onChange) {
|
|
var value = this.isChecked() ? this.props.falseValue : this.props.trueValue;
|
|
this.props.onChange({
|
|
originalEvent: e,
|
|
value: this.props.value,
|
|
checked: value,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
type: 'checkbox',
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: this.props.value,
|
|
checked: value
|
|
}
|
|
});
|
|
this.inputRef.current.checked = !this.isChecked();
|
|
this.inputRef.current.focus();
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateInputRef",
|
|
value: function updateInputRef() {
|
|
var ref = this.props.inputRef;
|
|
|
|
if (ref) {
|
|
if (typeof ref === 'function') {
|
|
ref(this.inputRef.current);
|
|
} else {
|
|
ref.current = this.inputRef.current;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.updateInputRef();
|
|
|
|
if (this.props.tooltip) {
|
|
this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
this.inputRef.current.checked = this.isChecked();
|
|
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$I({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onFocus",
|
|
value: function onFocus() {
|
|
this.setState({
|
|
focused: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "onBlur",
|
|
value: function onBlur() {
|
|
this.setState({
|
|
focused: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event) {
|
|
if (event.key === 'Enter') {
|
|
this.onClick(event);
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.element,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "isChecked",
|
|
value: function isChecked() {
|
|
return this.props.checked === this.props.trueValue;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this2 = this;
|
|
|
|
var checked = this.isChecked();
|
|
var containerClass = classNames('p-checkbox p-component', {
|
|
'p-checkbox-checked': checked,
|
|
'p-checkbox-disabled': this.props.disabled,
|
|
'p-checkbox-focused': this.state.focused
|
|
}, this.props.className);
|
|
var boxClass = classNames('p-checkbox-box', {
|
|
'p-highlight': checked,
|
|
'p-disabled': this.props.disabled,
|
|
'p-focus': this.state.focused
|
|
});
|
|
var icon = checked && this.props.icon;
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this2.element = el;
|
|
},
|
|
id: this.props.id,
|
|
className: containerClass,
|
|
style: this.props.style,
|
|
onClick: this.onClick,
|
|
onContextMenu: this.props.onContextMenu,
|
|
onMouseDown: this.props.onMouseDown
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-hidden-accessible"
|
|
}, /*#__PURE__*/React.createElement("input", {
|
|
ref: this.inputRef,
|
|
type: "checkbox",
|
|
"aria-labelledby": this.props.ariaLabelledBy,
|
|
id: this.props.inputId,
|
|
name: this.props.name,
|
|
tabIndex: this.props.tabIndex,
|
|
defaultChecked: checked,
|
|
onKeyDown: this.onKeyDown,
|
|
onFocus: this.onFocus,
|
|
onBlur: this.onBlur,
|
|
disabled: this.props.disabled,
|
|
readOnly: this.props.readOnly,
|
|
required: this.props.required
|
|
})), /*#__PURE__*/React.createElement("div", {
|
|
className: boxClass,
|
|
ref: function ref(el) {
|
|
return _this2.box = el;
|
|
},
|
|
role: "checkbox",
|
|
"aria-checked": checked
|
|
}, IconUtils.getJSXIcon(icon, {
|
|
className: 'p-checkbox-icon p-c'
|
|
}, {
|
|
props: this.props,
|
|
checked: checked
|
|
})));
|
|
}
|
|
}]);
|
|
|
|
return Checkbox;
|
|
}(Component);
|
|
|
|
_defineProperty(Checkbox, "defaultProps", {
|
|
id: null,
|
|
inputRef: null,
|
|
inputId: null,
|
|
value: null,
|
|
name: null,
|
|
checked: false,
|
|
trueValue: true,
|
|
falseValue: false,
|
|
style: null,
|
|
className: null,
|
|
disabled: false,
|
|
required: false,
|
|
readOnly: false,
|
|
tabIndex: null,
|
|
icon: 'pi pi-check',
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
ariaLabelledBy: null,
|
|
onChange: null,
|
|
onMouseDown: null,
|
|
onContextMenu: null
|
|
});
|
|
|
|
function _createSuper$1_(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1_(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1_() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Chip = /*#__PURE__*/function (_Component) {
|
|
_inherits(Chip, _Component);
|
|
|
|
var _super = _createSuper$1_(Chip);
|
|
|
|
function Chip(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Chip);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
visible: true
|
|
};
|
|
_this.close = _this.close.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Chip, [{
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event) {
|
|
if (event.keyCode === 13) {
|
|
// enter
|
|
this.close(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "close",
|
|
value: function close(event) {
|
|
var _this2 = this;
|
|
|
|
event.persist();
|
|
this.setState({
|
|
visible: false
|
|
}, function () {
|
|
if (_this2.props.onRemove) {
|
|
_this2.props.onRemove(event);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
var _this3 = this;
|
|
|
|
var content = [];
|
|
|
|
if (this.props.image) {
|
|
var onError = function onError(e) {
|
|
if (_this3.props.onImageError) {
|
|
_this3.props.onImageError(e);
|
|
}
|
|
};
|
|
|
|
content.push( /*#__PURE__*/React.createElement("img", {
|
|
key: "image",
|
|
src: this.props.image,
|
|
alt: this.props.imageAlt,
|
|
onError: onError
|
|
}));
|
|
} else if (this.props.icon) {
|
|
content.push(IconUtils.getJSXIcon(this.props.icon, {
|
|
key: 'icon',
|
|
className: 'p-chip-icon'
|
|
}, {
|
|
props: this.props
|
|
}));
|
|
}
|
|
|
|
if (this.props.label) {
|
|
content.push( /*#__PURE__*/React.createElement("span", {
|
|
key: "label",
|
|
className: "p-chip-text"
|
|
}, this.props.label));
|
|
}
|
|
|
|
if (this.props.removable) {
|
|
content.push(IconUtils.getJSXIcon(this.props.removeIcon, {
|
|
key: 'removeIcon',
|
|
tabIndex: 0,
|
|
className: 'p-chip-remove-icon',
|
|
onClick: this.close,
|
|
onKeyDown: this.onKeyDown
|
|
}, {
|
|
props: this.props
|
|
}));
|
|
}
|
|
|
|
return content;
|
|
}
|
|
}, {
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
var containerClassName = classNames('p-chip p-component', {
|
|
'p-chip-image': this.props.image != null
|
|
}, this.props.className);
|
|
var content = this.props.template ? ObjectUtils.getJSXElement(this.props.template, this.props) : this.renderContent();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: containerClassName,
|
|
style: this.props.style
|
|
}, content);
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
return this.state.visible && this.renderElement();
|
|
}
|
|
}]);
|
|
|
|
return Chip;
|
|
}(Component);
|
|
|
|
_defineProperty(Chip, "defaultProps", {
|
|
label: null,
|
|
icon: null,
|
|
image: null,
|
|
removable: false,
|
|
removeIcon: 'pi pi-times-circle',
|
|
className: null,
|
|
style: null,
|
|
template: null,
|
|
imageAlt: 'chip',
|
|
onImageError: null,
|
|
onRemove: null
|
|
});
|
|
|
|
function ownKeys$H(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$H(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$H(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$H(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$1Z(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1Z(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1Z() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Chips = /*#__PURE__*/function (_Component) {
|
|
_inherits(Chips, _Component);
|
|
|
|
var _super = _createSuper$1Z(Chips);
|
|
|
|
function Chips(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Chips);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
focused: false
|
|
};
|
|
_this.onWrapperClick = _this.onWrapperClick.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onPaste = _this.onPaste.bind(_assertThisInitialized(_this));
|
|
_this.onFocus = _this.onFocus.bind(_assertThisInitialized(_this));
|
|
_this.onBlur = _this.onBlur.bind(_assertThisInitialized(_this));
|
|
_this.inputRef = /*#__PURE__*/createRef(_this.props.inputRef);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Chips, [{
|
|
key: "removeItem",
|
|
value: function removeItem(event, index) {
|
|
if (this.props.disabled && this.props.readOnly) {
|
|
return;
|
|
}
|
|
|
|
var values = _toConsumableArray(this.props.value);
|
|
|
|
var removedItem = values.splice(index, 1);
|
|
|
|
if (!this.isRemovable(removedItem, index)) {
|
|
return;
|
|
}
|
|
|
|
if (this.props.onRemove) {
|
|
this.props.onRemove({
|
|
originalEvent: event,
|
|
value: removedItem
|
|
});
|
|
}
|
|
|
|
if (this.props.onChange) {
|
|
this.props.onChange({
|
|
originalEvent: event,
|
|
value: values,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: values
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "addItem",
|
|
value: function addItem(event, item, preventDefault) {
|
|
if (item && item.trim().length) {
|
|
var values = this.props.value ? _toConsumableArray(this.props.value) : [];
|
|
|
|
if (this.props.allowDuplicate || values.indexOf(item) === -1) {
|
|
values.push(item);
|
|
|
|
if (this.props.onAdd) {
|
|
this.props.onAdd({
|
|
originalEvent: event,
|
|
value: item
|
|
});
|
|
}
|
|
}
|
|
|
|
this.updateInput(event, values, preventDefault);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onWrapperClick",
|
|
value: function onWrapperClick() {
|
|
this.inputRef.current.focus();
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event) {
|
|
var inputValue = event.target.value;
|
|
var values = this.props.value || [];
|
|
|
|
switch (event.which) {
|
|
//backspace
|
|
case 8:
|
|
if (this.inputRef.current.value.length === 0 && values.length > 0) {
|
|
this.removeItem(event, values.length - 1);
|
|
}
|
|
|
|
break;
|
|
//enter
|
|
|
|
case 13:
|
|
if (inputValue && inputValue.trim().length && (!this.props.max || this.props.max > values.length)) {
|
|
this.addItem(event, inputValue, true);
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
if (this.isMaxedOut()) {
|
|
event.preventDefault();
|
|
} else if (this.props.separator) {
|
|
if (this.props.separator === ',' && event.which === 188) {
|
|
this.addItem(event, inputValue, true);
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateInput",
|
|
value: function updateInput(event, items, preventDefault) {
|
|
if (this.props.onChange) {
|
|
this.props.onChange({
|
|
originalEvent: event,
|
|
value: items,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: items
|
|
}
|
|
});
|
|
}
|
|
|
|
this.inputRef.current.value = '';
|
|
|
|
if (preventDefault) {
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onPaste",
|
|
value: function onPaste(event) {
|
|
var _this2 = this;
|
|
|
|
if (this.props.separator) {
|
|
var pastedData = (event.clipboardData || window['clipboardData']).getData('Text');
|
|
|
|
if (pastedData) {
|
|
var values = this.props.value || [];
|
|
var pastedValues = pastedData.split(this.props.separator);
|
|
pastedValues = pastedValues.filter(function (val) {
|
|
return (_this2.props.allowDuplicate || values.indexOf(val) === -1) && val.trim().length;
|
|
});
|
|
values = [].concat(_toConsumableArray(values), _toConsumableArray(pastedValues));
|
|
this.updateInput(event, values, true);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onFocus",
|
|
value: function onFocus(event) {
|
|
var _this3 = this;
|
|
|
|
event.persist();
|
|
this.setState({
|
|
focused: true
|
|
}, function () {
|
|
if (_this3.props.onFocus) {
|
|
_this3.props.onFocus(event);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onBlur",
|
|
value: function onBlur(event) {
|
|
var _this4 = this;
|
|
|
|
event.persist();
|
|
this.setState({
|
|
focused: false
|
|
}, function () {
|
|
if (_this4.props.onBlur) {
|
|
_this4.props.onBlur(event);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "isMaxedOut",
|
|
value: function isMaxedOut() {
|
|
return this.props.max && this.props.value && this.props.max === this.props.value.length;
|
|
}
|
|
}, {
|
|
key: "isFilled",
|
|
value: function isFilled() {
|
|
return this.props.value && this.props.value.length || this.inputRef && this.inputRef.current && this.inputRef.current.value && this.inputRef.current.value.length;
|
|
}
|
|
}, {
|
|
key: "isRemovable",
|
|
value: function isRemovable(value, index) {
|
|
return ObjectUtils.getPropValue(this.props.removable, {
|
|
value: value,
|
|
index: index,
|
|
props: this.props
|
|
});
|
|
}
|
|
}, {
|
|
key: "updateInputRef",
|
|
value: function updateInputRef() {
|
|
var ref = this.props.inputRef;
|
|
|
|
if (ref) {
|
|
if (typeof ref === 'function') {
|
|
ref(this.inputRef.current);
|
|
} else {
|
|
ref.current = this.inputRef.current;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.updateInputRef();
|
|
|
|
if (this.props.tooltip) {
|
|
this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
var isValueSame = this.props.value && prevProps.value && prevProps.value.length === this.props.value.length;
|
|
|
|
if (this.props.tooltip) {
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$H({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
} else if (!isValueSame && this.tooltip) {
|
|
this.tooltip.deactivate();
|
|
this.tooltip.activate();
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.inputRef.current,
|
|
targetContainer: this.listElement,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderRemoveIcon",
|
|
value: function renderRemoveIcon(value, index) {
|
|
var _this5 = this;
|
|
|
|
if (!this.props.disabled && !this.props.readOnly && this.isRemovable(value, index)) {
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: "p-chips-token-icon pi pi-times-circle",
|
|
onClick: function onClick(event) {
|
|
return _this5.removeItem(event, index);
|
|
}
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderItem",
|
|
value: function renderItem(value, index) {
|
|
var content = this.props.itemTemplate ? this.props.itemTemplate(value) : value;
|
|
var icon = this.renderRemoveIcon(value, index);
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: index,
|
|
className: "p-chips-token p-highlight"
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-chips-token-label"
|
|
}, content), icon);
|
|
}
|
|
}, {
|
|
key: "renderInputElement",
|
|
value: function renderInputElement() {
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
className: "p-chips-input-token"
|
|
}, /*#__PURE__*/React.createElement("input", {
|
|
ref: this.inputRef,
|
|
placeholder: this.props.placeholder,
|
|
type: "text",
|
|
name: this.props.name,
|
|
disabled: this.props.disabled || this.isMaxedOut(),
|
|
onKeyDown: this.onKeyDown,
|
|
onPaste: this.onPaste,
|
|
onFocus: this.onFocus,
|
|
onBlur: this.onBlur,
|
|
"aria-labelledby": this.props.ariaLabelledBy,
|
|
readOnly: this.props.readOnly
|
|
}));
|
|
}
|
|
}, {
|
|
key: "renderItems",
|
|
value: function renderItems() {
|
|
var _this6 = this;
|
|
|
|
if (this.props.value) {
|
|
return this.props.value.map(function (value, index) {
|
|
return _this6.renderItem(value, index);
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderList",
|
|
value: function renderList() {
|
|
var _this7 = this;
|
|
|
|
var className = classNames('p-inputtext p-chips-multiple-container', {
|
|
'p-disabled': this.props.disabled,
|
|
'p-focus': this.state.focused
|
|
});
|
|
var items = this.renderItems();
|
|
var inputElement = this.renderInputElement();
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
ref: function ref(el) {
|
|
return _this7.listElement = el;
|
|
},
|
|
className: className,
|
|
onClick: this.onWrapperClick
|
|
}, items, inputElement);
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this8 = this;
|
|
|
|
var className = classNames('p-chips p-component p-inputwrapper', this.props.className, {
|
|
'p-inputwrapper-filled': this.isFilled(),
|
|
'p-inputwrapper-focus': this.state.focused
|
|
});
|
|
var list = this.renderList();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this8.element = el;
|
|
},
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, list);
|
|
}
|
|
}]);
|
|
|
|
return Chips;
|
|
}(Component);
|
|
|
|
_defineProperty(Chips, "defaultProps", {
|
|
id: null,
|
|
inputRef: null,
|
|
name: null,
|
|
placeholder: null,
|
|
value: null,
|
|
max: null,
|
|
disabled: null,
|
|
readOnly: false,
|
|
removable: true,
|
|
style: null,
|
|
className: null,
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
ariaLabelledBy: null,
|
|
separator: null,
|
|
allowDuplicate: true,
|
|
itemTemplate: null,
|
|
onAdd: null,
|
|
onRemove: null,
|
|
onChange: null,
|
|
onFocus: null,
|
|
onBlur: null
|
|
});
|
|
|
|
function _createSuper$1Y(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1Y(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1Y() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
var ColorPickerPanelComponent = /*#__PURE__*/function (_Component) {
|
|
_inherits(ColorPickerPanelComponent, _Component);
|
|
|
|
var _super = _createSuper$1Y(ColorPickerPanelComponent);
|
|
|
|
function ColorPickerPanelComponent() {
|
|
_classCallCheck(this, ColorPickerPanelComponent);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(ColorPickerPanelComponent, [{
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
var className = classNames('p-colorpicker-panel', {
|
|
'p-colorpicker-overlay-panel': !this.props.inline,
|
|
'p-disabled': this.props.disabled
|
|
});
|
|
return /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.props.forwardRef,
|
|
classNames: "p-connected-overlay",
|
|
"in": this.props["in"],
|
|
timeout: {
|
|
enter: 120,
|
|
exit: 100
|
|
},
|
|
options: this.props.transitionOptions,
|
|
unmountOnExit: true,
|
|
onEnter: this.props.onEnter,
|
|
onEntered: this.props.onEntered,
|
|
onExit: this.props.onExit,
|
|
onExited: this.props.onExited
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.props.forwardRef,
|
|
className: className,
|
|
onClick: this.props.onClick
|
|
}, this.props.children));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var element = this.renderElement();
|
|
return this.props.inline ? element : /*#__PURE__*/React.createElement(Portal, {
|
|
element: element,
|
|
appendTo: this.props.appendTo
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return ColorPickerPanelComponent;
|
|
}(Component);
|
|
|
|
_defineProperty(ColorPickerPanelComponent, "defaultProps", {
|
|
appendTo: null,
|
|
inline: false,
|
|
disabled: false,
|
|
onClick: null
|
|
});
|
|
|
|
var ColorPickerPanel = /*#__PURE__*/React.forwardRef(function (props, ref) {
|
|
return /*#__PURE__*/React.createElement(ColorPickerPanelComponent, _extends({
|
|
forwardRef: ref
|
|
}, props));
|
|
});
|
|
|
|
function ownKeys$G(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$G(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$G(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$G(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$1X(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1X(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1X() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var ColorPicker = /*#__PURE__*/function (_Component) {
|
|
_inherits(ColorPicker, _Component);
|
|
|
|
var _super = _createSuper$1X(ColorPicker);
|
|
|
|
function ColorPicker(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, ColorPicker);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
overlayVisible: false
|
|
};
|
|
_this.onInputClick = _this.onInputClick.bind(_assertThisInitialized(_this));
|
|
_this.onInputKeydown = _this.onInputKeydown.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEnter = _this.onOverlayEnter.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEntered = _this.onOverlayEntered.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExit = _this.onOverlayExit.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExited = _this.onOverlayExited.bind(_assertThisInitialized(_this));
|
|
_this.onPanelClick = _this.onPanelClick.bind(_assertThisInitialized(_this));
|
|
_this.onColorMousedown = _this.onColorMousedown.bind(_assertThisInitialized(_this));
|
|
_this.onHueMousedown = _this.onHueMousedown.bind(_assertThisInitialized(_this));
|
|
_this.onColorDragStart = _this.onColorDragStart.bind(_assertThisInitialized(_this));
|
|
_this.onHueDragStart = _this.onHueDragStart.bind(_assertThisInitialized(_this));
|
|
_this.onDrag = _this.onDrag.bind(_assertThisInitialized(_this));
|
|
_this.onDragEnd = _this.onDragEnd.bind(_assertThisInitialized(_this));
|
|
_this.overlayRef = /*#__PURE__*/createRef();
|
|
_this.inputRef = /*#__PURE__*/createRef(_this.props.inputRef);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(ColorPicker, [{
|
|
key: "onPanelClick",
|
|
value: function onPanelClick(event) {
|
|
if (!this.props.inline) {
|
|
OverlayService.emit('overlay-click', {
|
|
originalEvent: event,
|
|
target: this.container
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onHueMousedown",
|
|
value: function onHueMousedown(event) {
|
|
if (this.props.disabled) {
|
|
return;
|
|
}
|
|
|
|
this.bindDragListeners();
|
|
this.onHueDragStart(event);
|
|
}
|
|
}, {
|
|
key: "onHueDragStart",
|
|
value: function onHueDragStart(event) {
|
|
if (this.props.disabled) {
|
|
return;
|
|
}
|
|
|
|
this.hueDragging = true;
|
|
this.pickHue(event);
|
|
DomHandler.addClass(this.container, 'p-colorpicker-dragging');
|
|
}
|
|
}, {
|
|
key: "pickHue",
|
|
value: function pickHue(event) {
|
|
var top = this.hueView.getBoundingClientRect().top + (window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0);
|
|
this.hsbValue = this.validateHSB({
|
|
h: Math.floor(360 * (150 - Math.max(0, Math.min(150, (event.pageY || event.changedTouches[0].pageY) - top))) / 150),
|
|
s: 100,
|
|
b: 100
|
|
});
|
|
this.updateColorSelector();
|
|
this.updateHue();
|
|
this.updateModel();
|
|
}
|
|
}, {
|
|
key: "onColorMousedown",
|
|
value: function onColorMousedown(event) {
|
|
if (this.props.disabled) {
|
|
return;
|
|
}
|
|
|
|
this.bindDragListeners();
|
|
this.onColorDragStart(event);
|
|
}
|
|
}, {
|
|
key: "onColorDragStart",
|
|
value: function onColorDragStart(event) {
|
|
if (this.props.disabled) {
|
|
return;
|
|
}
|
|
|
|
this.colorDragging = true;
|
|
this.pickColor(event);
|
|
DomHandler.addClass(this.container, 'p-colorpicker-dragging');
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onDrag",
|
|
value: function onDrag(event) {
|
|
if (this.colorDragging) {
|
|
this.pickColor(event);
|
|
event.preventDefault();
|
|
}
|
|
|
|
if (this.hueDragging) {
|
|
this.pickHue(event);
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDragEnd",
|
|
value: function onDragEnd() {
|
|
this.colorDragging = false;
|
|
this.hueDragging = false;
|
|
DomHandler.removeClass(this.container, 'p-colorpicker-dragging');
|
|
this.unbindDragListeners();
|
|
}
|
|
}, {
|
|
key: "bindDragListeners",
|
|
value: function bindDragListeners() {
|
|
this.bindDocumentMouseMoveListener();
|
|
this.bindDocumentMouseUpListener();
|
|
}
|
|
}, {
|
|
key: "unbindDragListeners",
|
|
value: function unbindDragListeners() {
|
|
this.unbindDocumentMouseMoveListener();
|
|
this.unbindDocumentMouseUpListener();
|
|
}
|
|
}, {
|
|
key: "pickColor",
|
|
value: function pickColor(event) {
|
|
var rect = this.colorSelector.getBoundingClientRect();
|
|
var top = rect.top + (window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0);
|
|
var left = rect.left + document.body.scrollLeft;
|
|
var saturation = Math.floor(100 * Math.max(0, Math.min(150, (event.pageX || event.changedTouches[0].pageX) - left)) / 150);
|
|
var brightness = Math.floor(100 * (150 - Math.max(0, Math.min(150, (event.pageY || event.changedTouches[0].pageY) - top))) / 150);
|
|
this.hsbValue = this.validateHSB({
|
|
h: this.hsbValue.h,
|
|
s: saturation,
|
|
b: brightness
|
|
});
|
|
this.updateColorHandle();
|
|
this.updateInput();
|
|
this.updateModel();
|
|
}
|
|
}, {
|
|
key: "updateModel",
|
|
value: function updateModel() {
|
|
switch (this.props.format) {
|
|
case 'hex':
|
|
this.onChange(this.HSBtoHEX(this.hsbValue));
|
|
break;
|
|
|
|
case 'rgb':
|
|
this.onChange(this.HSBtoRGB(this.hsbValue));
|
|
break;
|
|
|
|
case 'hsb':
|
|
this.onChange(this.hsbValue);
|
|
break;
|
|
}
|
|
}
|
|
}, {
|
|
key: "toHSB",
|
|
value: function toHSB(value) {
|
|
var hsb;
|
|
|
|
if (value) {
|
|
switch (this.props.format) {
|
|
case 'hex':
|
|
hsb = this.HEXtoHSB(value);
|
|
break;
|
|
|
|
case 'rgb':
|
|
hsb = this.RGBtoHSB(value);
|
|
break;
|
|
|
|
case 'hsb':
|
|
hsb = value;
|
|
break;
|
|
}
|
|
} else {
|
|
hsb = this.HEXtoHSB(this.props.defaultColor);
|
|
}
|
|
|
|
return hsb;
|
|
}
|
|
}, {
|
|
key: "updateHSBValue",
|
|
value: function updateHSBValue(value) {
|
|
this.hsbValue = this.toHSB(value);
|
|
}
|
|
}, {
|
|
key: "areHSBEqual",
|
|
value: function areHSBEqual(val1, val2) {
|
|
return val1.h === val2.h && val1.s === val2.s && val1.b === val2.b;
|
|
}
|
|
}, {
|
|
key: "onChange",
|
|
value: function onChange(value) {
|
|
if (this.props.onChange) {
|
|
this.props.onChange({
|
|
value: value,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: value
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateColorSelector",
|
|
value: function updateColorSelector() {
|
|
if (this.colorSelector) {
|
|
var hsbValue = this.validateHSB({
|
|
h: this.hsbValue.h,
|
|
s: 100,
|
|
b: 100
|
|
});
|
|
this.colorSelector.style.backgroundColor = '#' + this.HSBtoHEX(hsbValue);
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateColorHandle",
|
|
value: function updateColorHandle() {
|
|
if (this.colorHandle) {
|
|
this.colorHandle.style.left = Math.floor(150 * this.hsbValue.s / 100) + 'px';
|
|
this.colorHandle.style.top = Math.floor(150 * (100 - this.hsbValue.b) / 100) + 'px';
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateHue",
|
|
value: function updateHue() {
|
|
if (this.hueHandle) {
|
|
this.hueHandle.style.top = Math.floor(150 - 150 * this.hsbValue.h / 360) + 'px';
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateInput",
|
|
value: function updateInput() {
|
|
if (this.inputRef && this.inputRef.current) {
|
|
this.inputRef.current.style.backgroundColor = '#' + this.HSBtoHEX(this.hsbValue);
|
|
}
|
|
}
|
|
}, {
|
|
key: "show",
|
|
value: function show() {
|
|
this.setState({
|
|
overlayVisible: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "hide",
|
|
value: function hide() {
|
|
this.setState({
|
|
overlayVisible: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "onOverlayEnter",
|
|
value: function onOverlayEnter() {
|
|
ZIndexUtils.set('overlay', this.overlayRef.current, PrimeReact.autoZIndex, PrimeReact.zIndex['overlay']);
|
|
this.alignOverlay();
|
|
}
|
|
}, {
|
|
key: "onOverlayEntered",
|
|
value: function onOverlayEntered() {
|
|
this.bindDocumentClickListener();
|
|
this.bindScrollListener();
|
|
this.bindResizeListener();
|
|
this.props.onShow && this.props.onShow();
|
|
}
|
|
}, {
|
|
key: "onOverlayExit",
|
|
value: function onOverlayExit() {
|
|
this.unbindDocumentClickListener();
|
|
this.unbindScrollListener();
|
|
this.unbindResizeListener();
|
|
}
|
|
}, {
|
|
key: "onOverlayExited",
|
|
value: function onOverlayExited() {
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
this.props.onHide && this.props.onHide();
|
|
}
|
|
}, {
|
|
key: "onInputClick",
|
|
value: function onInputClick() {
|
|
this.togglePanel();
|
|
}
|
|
}, {
|
|
key: "togglePanel",
|
|
value: function togglePanel() {
|
|
if (this.state.overlayVisible) this.hide();else this.show();
|
|
}
|
|
}, {
|
|
key: "onInputKeydown",
|
|
value: function onInputKeydown(event) {
|
|
switch (event.which) {
|
|
//space
|
|
case 32:
|
|
this.togglePanel();
|
|
event.preventDefault();
|
|
break;
|
|
//escape and tab
|
|
|
|
case 27:
|
|
case 9:
|
|
this.hide();
|
|
break;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindDocumentClickListener",
|
|
value: function bindDocumentClickListener() {
|
|
var _this2 = this;
|
|
|
|
if (!this.documentClickListener) {
|
|
this.documentClickListener = function (event) {
|
|
if (_this2.state.overlayVisible && _this2.isOutsideClicked(event)) {
|
|
_this2.hide();
|
|
}
|
|
};
|
|
|
|
document.addEventListener('click', this.documentClickListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentClickListener",
|
|
value: function unbindDocumentClickListener() {
|
|
if (this.documentClickListener) {
|
|
document.removeEventListener('click', this.documentClickListener);
|
|
this.documentClickListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindScrollListener",
|
|
value: function bindScrollListener() {
|
|
var _this3 = this;
|
|
|
|
if (!this.scrollHandler) {
|
|
this.scrollHandler = new ConnectedOverlayScrollHandler(this.container, function () {
|
|
if (_this3.state.overlayVisible) {
|
|
_this3.hide();
|
|
}
|
|
});
|
|
}
|
|
|
|
this.scrollHandler.bindScrollListener();
|
|
}
|
|
}, {
|
|
key: "unbindScrollListener",
|
|
value: function unbindScrollListener() {
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.unbindScrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindResizeListener",
|
|
value: function bindResizeListener() {
|
|
var _this4 = this;
|
|
|
|
if (!this.resizeListener) {
|
|
this.resizeListener = function () {
|
|
if (_this4.state.overlayVisible && !DomHandler.isTouchDevice()) {
|
|
_this4.hide();
|
|
}
|
|
};
|
|
|
|
window.addEventListener('resize', this.resizeListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindResizeListener",
|
|
value: function unbindResizeListener() {
|
|
if (this.resizeListener) {
|
|
window.removeEventListener('resize', this.resizeListener);
|
|
this.resizeListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "isOutsideClicked",
|
|
value: function isOutsideClicked(event) {
|
|
return this.container && !(this.container.isSameNode(event.target) || this.container.contains(event.target) || this.overlayRef && this.overlayRef.current.contains(event.target));
|
|
}
|
|
}, {
|
|
key: "bindDocumentMouseMoveListener",
|
|
value: function bindDocumentMouseMoveListener() {
|
|
if (!this.documentMouseMoveListener) {
|
|
this.documentMouseMoveListener = this.onDocumentMouseMove.bind(this);
|
|
document.addEventListener('mousemove', this.documentMouseMoveListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDocumentMouseMove",
|
|
value: function onDocumentMouseMove(event) {
|
|
if (this.colorDragging) {
|
|
this.pickColor(event);
|
|
}
|
|
|
|
if (this.hueDragging) {
|
|
this.pickHue(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentMouseMoveListener",
|
|
value: function unbindDocumentMouseMoveListener() {
|
|
if (this.documentMouseMoveListener) {
|
|
document.removeEventListener('mousemove', this.documentMouseMoveListener);
|
|
this.documentMouseMoveListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindDocumentMouseUpListener",
|
|
value: function bindDocumentMouseUpListener() {
|
|
if (!this.documentMouseUpListener) {
|
|
this.documentMouseUpListener = this.onDocumentMouseUp.bind(this);
|
|
document.addEventListener('mouseup', this.documentMouseUpListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDocumentMouseUp",
|
|
value: function onDocumentMouseUp() {
|
|
this.colorDragging = false;
|
|
this.hueDragging = false;
|
|
DomHandler.removeClass(this.container, 'p-colorpicker-dragging');
|
|
this.unbindDocumentMouseMoveListener();
|
|
this.unbindDocumentMouseUpListener();
|
|
}
|
|
}, {
|
|
key: "unbindDocumentMouseUpListener",
|
|
value: function unbindDocumentMouseUpListener() {
|
|
if (this.documentMouseUpListener) {
|
|
document.removeEventListener('mouseup', this.documentMouseUpListener);
|
|
this.documentMouseUpListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "validateHSB",
|
|
value: function validateHSB(hsb) {
|
|
return {
|
|
h: Math.min(360, Math.max(0, hsb.h)),
|
|
s: Math.min(100, Math.max(0, hsb.s)),
|
|
b: Math.min(100, Math.max(0, hsb.b))
|
|
};
|
|
}
|
|
}, {
|
|
key: "validateRGB",
|
|
value: function validateRGB(rgb) {
|
|
return {
|
|
r: Math.min(255, Math.max(0, rgb.r)),
|
|
g: Math.min(255, Math.max(0, rgb.g)),
|
|
b: Math.min(255, Math.max(0, rgb.b))
|
|
};
|
|
}
|
|
}, {
|
|
key: "validateHEX",
|
|
value: function validateHEX(hex) {
|
|
var len = 6 - hex.length;
|
|
|
|
if (len > 0) {
|
|
var o = [];
|
|
|
|
for (var i = 0; i < len; i++) {
|
|
o.push('0');
|
|
}
|
|
|
|
o.push(hex);
|
|
hex = o.join('');
|
|
}
|
|
|
|
return hex;
|
|
}
|
|
}, {
|
|
key: "HEXtoRGB",
|
|
value: function HEXtoRGB(hex) {
|
|
var hexValue = parseInt(hex.indexOf('#') > -1 ? hex.substring(1) : hex, 16);
|
|
return {
|
|
r: hexValue >> 16,
|
|
g: (hexValue & 0x00FF00) >> 8,
|
|
b: hexValue & 0x0000FF
|
|
};
|
|
}
|
|
}, {
|
|
key: "HEXtoHSB",
|
|
value: function HEXtoHSB(hex) {
|
|
return this.RGBtoHSB(this.HEXtoRGB(hex));
|
|
}
|
|
}, {
|
|
key: "RGBtoHSB",
|
|
value: function RGBtoHSB(rgb) {
|
|
var hsb = {
|
|
h: 0,
|
|
s: 0,
|
|
b: 0
|
|
};
|
|
var min = Math.min(rgb.r, rgb.g, rgb.b);
|
|
var max = Math.max(rgb.r, rgb.g, rgb.b);
|
|
var delta = max - min;
|
|
hsb.b = max;
|
|
hsb.s = max !== 0 ? 255 * delta / max : 0;
|
|
|
|
if (hsb.s !== 0) {
|
|
if (rgb.r === max) {
|
|
hsb.h = (rgb.g - rgb.b) / delta;
|
|
} else if (rgb.g === max) {
|
|
hsb.h = 2 + (rgb.b - rgb.r) / delta;
|
|
} else {
|
|
hsb.h = 4 + (rgb.r - rgb.g) / delta;
|
|
}
|
|
} else {
|
|
hsb.h = -1;
|
|
}
|
|
|
|
hsb.h *= 60;
|
|
|
|
if (hsb.h < 0) {
|
|
hsb.h += 360;
|
|
}
|
|
|
|
hsb.s *= 100 / 255;
|
|
hsb.b *= 100 / 255;
|
|
return hsb;
|
|
}
|
|
}, {
|
|
key: "HSBtoRGB",
|
|
value: function HSBtoRGB(hsb) {
|
|
var rgb = {
|
|
r: null,
|
|
g: null,
|
|
b: null
|
|
};
|
|
var h = Math.round(hsb.h);
|
|
var s = Math.round(hsb.s * 255 / 100);
|
|
var v = Math.round(hsb.b * 255 / 100);
|
|
|
|
if (s === 0) {
|
|
rgb = {
|
|
r: v,
|
|
g: v,
|
|
b: v
|
|
};
|
|
} else {
|
|
var t1 = v;
|
|
var t2 = (255 - s) * v / 255;
|
|
var t3 = (t1 - t2) * (h % 60) / 60;
|
|
if (h === 360) h = 0;
|
|
|
|
if (h < 60) {
|
|
rgb.r = t1;
|
|
rgb.b = t2;
|
|
rgb.g = t2 + t3;
|
|
} else if (h < 120) {
|
|
rgb.g = t1;
|
|
rgb.b = t2;
|
|
rgb.r = t1 - t3;
|
|
} else if (h < 180) {
|
|
rgb.g = t1;
|
|
rgb.r = t2;
|
|
rgb.b = t2 + t3;
|
|
} else if (h < 240) {
|
|
rgb.b = t1;
|
|
rgb.r = t2;
|
|
rgb.g = t1 - t3;
|
|
} else if (h < 300) {
|
|
rgb.b = t1;
|
|
rgb.g = t2;
|
|
rgb.r = t2 + t3;
|
|
} else if (h < 360) {
|
|
rgb.r = t1;
|
|
rgb.g = t2;
|
|
rgb.b = t1 - t3;
|
|
} else {
|
|
rgb.r = 0;
|
|
rgb.g = 0;
|
|
rgb.b = 0;
|
|
}
|
|
}
|
|
|
|
return {
|
|
r: Math.round(rgb.r),
|
|
g: Math.round(rgb.g),
|
|
b: Math.round(rgb.b)
|
|
};
|
|
}
|
|
}, {
|
|
key: "RGBtoHEX",
|
|
value: function RGBtoHEX(rgb) {
|
|
var hex = [rgb.r.toString(16), rgb.g.toString(16), rgb.b.toString(16)];
|
|
|
|
for (var key in hex) {
|
|
if (hex[key].length === 1) {
|
|
hex[key] = '0' + hex[key];
|
|
}
|
|
}
|
|
|
|
return hex.join('');
|
|
}
|
|
}, {
|
|
key: "HSBtoHEX",
|
|
value: function HSBtoHEX(hsb) {
|
|
return this.RGBtoHEX(this.HSBtoRGB(hsb));
|
|
}
|
|
}, {
|
|
key: "updateInputRef",
|
|
value: function updateInputRef() {
|
|
var ref = this.props.inputRef;
|
|
|
|
if (ref) {
|
|
if (typeof ref === 'function') {
|
|
ref(this.inputRef.current);
|
|
} else {
|
|
ref.current = this.inputRef.current;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.updateInputRef();
|
|
this.updateHSBValue(this.props.value);
|
|
this.updateUI();
|
|
|
|
if (this.props.tooltip) {
|
|
this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (!this.colorDragging && !this.hueDragging && this.props.value !== prevProps.value) {
|
|
this.updateHSBValue(this.props.value);
|
|
}
|
|
|
|
this.updateUI();
|
|
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$G({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.unbindDocumentClickListener();
|
|
this.unbindDocumentMouseMoveListener();
|
|
this.unbindDocumentMouseUpListener();
|
|
this.unbindResizeListener();
|
|
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.destroy();
|
|
this.scrollHandler = null;
|
|
}
|
|
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
}
|
|
}, {
|
|
key: "updateUI",
|
|
value: function updateUI() {
|
|
this.updateHue();
|
|
this.updateColorHandle();
|
|
this.updateInput();
|
|
this.updateColorSelector();
|
|
}
|
|
}, {
|
|
key: "alignOverlay",
|
|
value: function alignOverlay() {
|
|
if (this.inputRef && this.inputRef.current) {
|
|
DomHandler.alignOverlay(this.overlayRef.current, this.inputRef.current.parentElement, this.props.appendTo || PrimeReact.appendTo);
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.container,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderColorSelector",
|
|
value: function renderColorSelector() {
|
|
var _this5 = this;
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this5.colorSelector = el;
|
|
},
|
|
className: "p-colorpicker-color-selector",
|
|
onMouseDown: this.onColorMousedown,
|
|
onTouchStart: this.onColorDragStart,
|
|
onTouchMove: this.onDrag,
|
|
onTouchEnd: this.onDragEnd
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-colorpicker-color"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this5.colorHandle = el;
|
|
},
|
|
className: "p-colorpicker-color-handle"
|
|
})));
|
|
}
|
|
}, {
|
|
key: "renderHue",
|
|
value: function renderHue() {
|
|
var _this6 = this;
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this6.hueView = el;
|
|
},
|
|
className: "p-colorpicker-hue",
|
|
onMouseDown: this.onHueMousedown,
|
|
onTouchStart: this.onHueDragStart,
|
|
onTouchMove: this.onDrag,
|
|
onTouchEnd: this.onDragEnd
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this6.hueHandle = el;
|
|
},
|
|
className: "p-colorpicker-hue-handle"
|
|
}));
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
var colorSelector = this.renderColorSelector();
|
|
var hue = this.renderHue();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-colorpicker-content"
|
|
}, colorSelector, hue);
|
|
}
|
|
}, {
|
|
key: "renderInput",
|
|
value: function renderInput() {
|
|
if (!this.props.inline) {
|
|
var inputClassName = classNames('p-colorpicker-preview p-inputtext', {
|
|
'p-disabled': this.props.disabled
|
|
});
|
|
var inputProps = ObjectUtils.findDiffKeys(this.props, ColorPicker.defaultProps);
|
|
return /*#__PURE__*/React.createElement("input", _extends({
|
|
ref: this.inputRef,
|
|
type: "text",
|
|
className: inputClassName,
|
|
readOnly: true,
|
|
id: this.props.inputId,
|
|
tabIndex: this.props.tabIndex,
|
|
disabled: this.props.disabled,
|
|
onClick: this.onInputClick,
|
|
onKeyDown: this.onInputKeydown
|
|
}, inputProps));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this7 = this;
|
|
|
|
var containerClassName = classNames('p-colorpicker p-component', {
|
|
'p-colorpicker-overlay': !this.props.inline
|
|
}, this.props.className);
|
|
var content = this.renderContent();
|
|
var input = this.renderInput();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this7.container = el;
|
|
},
|
|
id: this.props.id,
|
|
style: this.props.style,
|
|
className: containerClassName
|
|
}, input, /*#__PURE__*/React.createElement(ColorPickerPanel, {
|
|
ref: this.overlayRef,
|
|
appendTo: this.props.appendTo,
|
|
inline: this.props.inline,
|
|
disabled: this.props.disabled,
|
|
onClick: this.onPanelClick,
|
|
"in": this.props.inline || this.state.overlayVisible,
|
|
onEnter: this.onOverlayEnter,
|
|
onEntered: this.onOverlayEntered,
|
|
onExit: this.onOverlayExit,
|
|
onExited: this.onOverlayExited,
|
|
transitionOptions: this.props.transitionOptions
|
|
}, content));
|
|
}
|
|
}]);
|
|
|
|
return ColorPicker;
|
|
}(Component);
|
|
|
|
_defineProperty(ColorPicker, "defaultProps", {
|
|
id: null,
|
|
inputRef: null,
|
|
value: null,
|
|
style: null,
|
|
className: null,
|
|
defaultColor: 'ff0000',
|
|
inline: false,
|
|
format: 'hex',
|
|
appendTo: null,
|
|
disabled: false,
|
|
tabIndex: null,
|
|
inputId: null,
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
transitionOptions: null,
|
|
onChange: null,
|
|
onShow: null,
|
|
onHide: null
|
|
});
|
|
|
|
function _createSuper$1W(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1W(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1W() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Column = /*#__PURE__*/function (_Component) {
|
|
_inherits(Column, _Component);
|
|
|
|
var _super = _createSuper$1W(Column);
|
|
|
|
function Column() {
|
|
_classCallCheck(this, Column);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
return _createClass(Column);
|
|
}(Component);
|
|
|
|
_defineProperty(Column, "defaultProps", {
|
|
columnKey: null,
|
|
field: null,
|
|
sortField: null,
|
|
filterField: null,
|
|
exportField: null,
|
|
header: null,
|
|
body: null,
|
|
footer: null,
|
|
sortable: false,
|
|
sortableDisabled: false,
|
|
sortFunction: null,
|
|
dataType: 'text',
|
|
filter: false,
|
|
filterMatchMode: null,
|
|
filterPlaceholder: null,
|
|
filterType: 'text',
|
|
filterMaxLength: null,
|
|
filterElement: null,
|
|
filterFunction: null,
|
|
filterHeaderStyle: null,
|
|
filterHeaderClassName: null,
|
|
showFilterMenu: true,
|
|
showFilterOperator: true,
|
|
showClearButton: true,
|
|
showApplyButton: true,
|
|
showFilterMatchModes: true,
|
|
showFilterMenuOptions: true,
|
|
showAddButton: true,
|
|
filterMatchModeOptions: null,
|
|
maxConstraints: 2,
|
|
filterMenuClassName: null,
|
|
filterMenuStyle: null,
|
|
align: null,
|
|
alignHeader: null,
|
|
alignFrozen: 'left',
|
|
hidden: false,
|
|
onFilterClear: null,
|
|
onFilterApplyClick: null,
|
|
onFilterMatchModeChange: null,
|
|
onFilterOperatorChange: null,
|
|
onFilterConstraintAdd: null,
|
|
onFilterConstraintRemove: null,
|
|
filterClear: null,
|
|
filterApply: null,
|
|
filterHeader: null,
|
|
filterFooter: null,
|
|
style: null,
|
|
className: null,
|
|
headerStyle: null,
|
|
headerClassName: null,
|
|
bodyStyle: null,
|
|
bodyClassName: null,
|
|
footerStyle: null,
|
|
footerClassName: null,
|
|
expander: false,
|
|
frozen: false,
|
|
selectionMode: null,
|
|
colSpan: null,
|
|
rowSpan: null,
|
|
editor: null,
|
|
cellEditValidator: null,
|
|
cellEditValidatorEvent: 'click',
|
|
onBeforeCellEditHide: null,
|
|
onBeforeCellEditShow: null,
|
|
onCellEditInit: null,
|
|
onCellEditComplete: null,
|
|
onCellEditCancel: null,
|
|
excludeGlobalFilter: false,
|
|
rowReorder: false,
|
|
rowReorderIcon: 'pi pi-bars',
|
|
rowEditor: false,
|
|
exportable: true,
|
|
reorderable: true
|
|
});
|
|
|
|
function _createSuper$1V(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1V(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1V() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var ColumnGroup = /*#__PURE__*/function (_Component) {
|
|
_inherits(ColumnGroup, _Component);
|
|
|
|
var _super = _createSuper$1V(ColumnGroup);
|
|
|
|
function ColumnGroup() {
|
|
_classCallCheck(this, ColumnGroup);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
return _createClass(ColumnGroup);
|
|
}(Component);
|
|
|
|
function _createSuper$1U(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1U(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1U() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Dialog = /*#__PURE__*/function (_Component) {
|
|
_inherits(Dialog, _Component);
|
|
|
|
var _super = _createSuper$1U(Dialog);
|
|
|
|
function Dialog(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Dialog);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
id: props.id,
|
|
maskVisible: false,
|
|
visible: false
|
|
};
|
|
|
|
if (!_this.props.onMaximize) {
|
|
_this.state.maximized = props.maximized;
|
|
}
|
|
|
|
_this.onClose = _this.onClose.bind(_assertThisInitialized(_this));
|
|
_this.toggleMaximize = _this.toggleMaximize.bind(_assertThisInitialized(_this));
|
|
_this.onDragStart = _this.onDragStart.bind(_assertThisInitialized(_this));
|
|
_this.onResizeStart = _this.onResizeStart.bind(_assertThisInitialized(_this));
|
|
_this.onMaskClick = _this.onMaskClick.bind(_assertThisInitialized(_this));
|
|
_this.onEnter = _this.onEnter.bind(_assertThisInitialized(_this));
|
|
_this.onEntered = _this.onEntered.bind(_assertThisInitialized(_this));
|
|
_this.onExiting = _this.onExiting.bind(_assertThisInitialized(_this));
|
|
_this.onExited = _this.onExited.bind(_assertThisInitialized(_this));
|
|
_this.attributeSelector = UniqueComponentId();
|
|
_this.dialogRef = /*#__PURE__*/React.createRef();
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Dialog, [{
|
|
key: "onClose",
|
|
value: function onClose(event) {
|
|
this.props.onHide();
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "focus",
|
|
value: function focus() {
|
|
var activeElement = document.activeElement;
|
|
var isActiveElementInDialog = activeElement && this.dialogRef && this.dialogRef.current.contains(activeElement);
|
|
|
|
if (!isActiveElementInDialog && this.props.closable && this.props.showHeader) {
|
|
this.closeElement.focus();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onMaskClick",
|
|
value: function onMaskClick(event) {
|
|
if (this.props.dismissableMask && this.props.modal && this.mask === event.target) {
|
|
this.onClose(event);
|
|
}
|
|
|
|
this.props.onMaskClick && this.props.onMaskClick(event);
|
|
}
|
|
}, {
|
|
key: "toggleMaximize",
|
|
value: function toggleMaximize(event) {
|
|
var maximized = !this.maximized;
|
|
|
|
if (this.props.onMaximize) {
|
|
this.props.onMaximize({
|
|
originalEvent: event,
|
|
maximized: maximized
|
|
});
|
|
} else {
|
|
this.setState({
|
|
maximized: maximized
|
|
}, this.changeScrollOnMaximizable);
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onDragStart",
|
|
value: function onDragStart(event) {
|
|
if (DomHandler.hasClass(event.target, 'p-dialog-header-icon') || DomHandler.hasClass(event.target.parentElement, 'p-dialog-header-icon')) {
|
|
return;
|
|
}
|
|
|
|
if (this.props.draggable) {
|
|
this.dragging = true;
|
|
this.lastPageX = event.pageX;
|
|
this.lastPageY = event.pageY;
|
|
this.dialogEl.style.margin = '0';
|
|
DomHandler.addClass(document.body, 'p-unselectable-text');
|
|
|
|
if (this.props.onDragStart) {
|
|
this.props.onDragStart(event);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDrag",
|
|
value: function onDrag(event) {
|
|
if (this.dragging) {
|
|
var width = DomHandler.getOuterWidth(this.dialogEl);
|
|
var height = DomHandler.getOuterHeight(this.dialogEl);
|
|
var deltaX = event.pageX - this.lastPageX;
|
|
var deltaY = event.pageY - this.lastPageY;
|
|
var offset = this.dialogEl.getBoundingClientRect();
|
|
var leftPos = offset.left + deltaX;
|
|
var topPos = offset.top + deltaY;
|
|
var viewport = DomHandler.getViewport();
|
|
this.dialogEl.style.position = 'fixed';
|
|
|
|
if (this.props.keepInViewport) {
|
|
if (leftPos >= this.props.minX && leftPos + width < viewport.width) {
|
|
this.lastPageX = event.pageX;
|
|
this.dialogEl.style.left = leftPos + 'px';
|
|
}
|
|
|
|
if (topPos >= this.props.minY && topPos + height < viewport.height) {
|
|
this.lastPageY = event.pageY;
|
|
this.dialogEl.style.top = topPos + 'px';
|
|
}
|
|
} else {
|
|
this.lastPageX = event.pageX;
|
|
this.dialogEl.style.left = leftPos + 'px';
|
|
this.lastPageY = event.pageY;
|
|
this.dialogEl.style.top = topPos + 'px';
|
|
}
|
|
|
|
if (this.props.onDrag) {
|
|
this.props.onDrag(event);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDragEnd",
|
|
value: function onDragEnd(event) {
|
|
if (this.dragging) {
|
|
this.dragging = false;
|
|
DomHandler.removeClass(document.body, 'p-unselectable-text');
|
|
|
|
if (this.props.onDragEnd) {
|
|
this.props.onDragEnd(event);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onResizeStart",
|
|
value: function onResizeStart(event) {
|
|
if (this.props.resizable) {
|
|
this.resizing = true;
|
|
this.lastPageX = event.pageX;
|
|
this.lastPageY = event.pageY;
|
|
DomHandler.addClass(document.body, 'p-unselectable-text');
|
|
|
|
if (this.props.onResizeStart) {
|
|
this.props.onResizeStart(event);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "convertToPx",
|
|
value: function convertToPx(value, property, viewport) {
|
|
!viewport && (viewport = DomHandler.getViewport());
|
|
var val = parseInt(value);
|
|
|
|
if (/^(\d+|(\.\d+))(\.\d+)?%$/.test(value)) {
|
|
return val * (viewport[property] / 100);
|
|
}
|
|
|
|
return val;
|
|
}
|
|
}, {
|
|
key: "onResize",
|
|
value: function onResize(event) {
|
|
if (this.resizing) {
|
|
var deltaX = event.pageX - this.lastPageX;
|
|
var deltaY = event.pageY - this.lastPageY;
|
|
var width = DomHandler.getOuterWidth(this.dialogEl);
|
|
var height = DomHandler.getOuterHeight(this.dialogEl);
|
|
var offset = this.dialogEl.getBoundingClientRect();
|
|
var viewport = DomHandler.getViewport();
|
|
var newWidth = width + deltaX;
|
|
var newHeight = height + deltaY;
|
|
var minWidth = this.convertToPx(this.dialogEl.style.minWidth, 'width', viewport);
|
|
var minHeight = this.convertToPx(this.dialogEl.style.minHeight, 'height', viewport);
|
|
var hasBeenDragged = !parseInt(this.dialogEl.style.top) || !parseInt(this.dialogEl.style.left);
|
|
|
|
if (hasBeenDragged) {
|
|
newWidth += deltaX;
|
|
newHeight += deltaY;
|
|
}
|
|
|
|
if ((!minWidth || newWidth > minWidth) && offset.left + newWidth < viewport.width) {
|
|
this.dialogEl.style.width = newWidth + 'px';
|
|
}
|
|
|
|
if ((!minHeight || newHeight > minHeight) && offset.top + newHeight < viewport.height) {
|
|
this.dialogEl.style.height = newHeight + 'px';
|
|
}
|
|
|
|
this.lastPageX = event.pageX;
|
|
this.lastPageY = event.pageY;
|
|
|
|
if (this.props.onResize) {
|
|
this.props.onResize(event);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onResizeEnd",
|
|
value: function onResizeEnd(event) {
|
|
if (this.resizing) {
|
|
this.resizing = false;
|
|
DomHandler.removeClass(document.body, 'p-unselectable-text');
|
|
|
|
if (this.props.onResizeEnd) {
|
|
this.props.onResizeEnd(event);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "resetPosition",
|
|
value: function resetPosition() {
|
|
this.dialogEl.style.position = '';
|
|
this.dialogEl.style.left = '';
|
|
this.dialogEl.style.top = '';
|
|
this.dialogEl.style.margin = '';
|
|
}
|
|
}, {
|
|
key: "getPositionClass",
|
|
value: function getPositionClass() {
|
|
var _this2 = this;
|
|
|
|
var positions = ['center', 'left', 'right', 'top', 'top-left', 'top-right', 'bottom', 'bottom-left', 'bottom-right'];
|
|
var pos = positions.find(function (item) {
|
|
return item === _this2.props.position || item.replace('-', '') === _this2.props.position;
|
|
});
|
|
return pos ? "p-dialog-".concat(pos) : '';
|
|
}
|
|
}, {
|
|
key: "maximized",
|
|
get: function get() {
|
|
return this.props.onMaximize ? this.props.maximized : this.state.maximized;
|
|
}
|
|
}, {
|
|
key: "dialogEl",
|
|
get: function get() {
|
|
return this.dialogRef.current;
|
|
}
|
|
}, {
|
|
key: "onEnter",
|
|
value: function onEnter() {
|
|
this.dialogEl.setAttribute(this.attributeSelector, '');
|
|
}
|
|
}, {
|
|
key: "onEntered",
|
|
value: function onEntered() {
|
|
if (this.props.onShow) {
|
|
this.props.onShow();
|
|
}
|
|
|
|
if (this.props.focusOnShow) {
|
|
this.focus();
|
|
}
|
|
|
|
this.enableDocumentSettings();
|
|
}
|
|
}, {
|
|
key: "onExiting",
|
|
value: function onExiting() {
|
|
if (this.props.modal) {
|
|
DomHandler.addClass(this.mask, 'p-component-overlay-leave');
|
|
}
|
|
}
|
|
}, {
|
|
key: "onExited",
|
|
value: function onExited() {
|
|
this.dragging = false;
|
|
ZIndexUtils.clear(this.mask);
|
|
this.setState({
|
|
maskVisible: false
|
|
});
|
|
this.disableDocumentSettings();
|
|
}
|
|
}, {
|
|
key: "enableDocumentSettings",
|
|
value: function enableDocumentSettings() {
|
|
this.bindGlobalListeners();
|
|
|
|
if (this.props.blockScroll || this.props.maximizable && this.maximized) {
|
|
DomHandler.addClass(document.body, 'p-overflow-hidden');
|
|
}
|
|
}
|
|
}, {
|
|
key: "disableDocumentSettings",
|
|
value: function disableDocumentSettings() {
|
|
this.unbindGlobalListeners();
|
|
|
|
if (this.props.modal) {
|
|
var hasBlockScroll = document.primeDialogParams && document.primeDialogParams.some(function (param) {
|
|
return param.hasBlockScroll;
|
|
});
|
|
|
|
if (!hasBlockScroll) {
|
|
DomHandler.removeClass(document.body, 'p-overflow-hidden');
|
|
}
|
|
} else if (this.props.blockScroll || this.props.maximizable && this.maximized) {
|
|
DomHandler.removeClass(document.body, 'p-overflow-hidden');
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindGlobalListeners",
|
|
value: function bindGlobalListeners() {
|
|
if (this.props.draggable) {
|
|
this.bindDocumentDragListener();
|
|
}
|
|
|
|
if (this.props.resizable) {
|
|
this.bindDocumentResizeListeners();
|
|
}
|
|
|
|
if (this.props.closable) {
|
|
this.bindDocumentKeyDownListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindGlobalListeners",
|
|
value: function unbindGlobalListeners() {
|
|
this.unbindDocumentDragListener();
|
|
this.unbindDocumentResizeListeners();
|
|
this.unbindDocumentKeyDownListener();
|
|
}
|
|
}, {
|
|
key: "bindDocumentDragListener",
|
|
value: function bindDocumentDragListener() {
|
|
this.documentDragListener = this.onDrag.bind(this);
|
|
this.documentDragEndListener = this.onDragEnd.bind(this);
|
|
window.document.addEventListener('mousemove', this.documentDragListener);
|
|
window.document.addEventListener('mouseup', this.documentDragEndListener);
|
|
}
|
|
}, {
|
|
key: "unbindDocumentDragListener",
|
|
value: function unbindDocumentDragListener() {
|
|
if (this.documentDragListener && this.documentDragEndListener) {
|
|
window.document.removeEventListener('mousemove', this.documentDragListener);
|
|
window.document.removeEventListener('mouseup', this.documentDragEndListener);
|
|
this.documentDragListener = null;
|
|
this.documentDragEndListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindDocumentResizeListeners",
|
|
value: function bindDocumentResizeListeners() {
|
|
this.documentResizeListener = this.onResize.bind(this);
|
|
this.documentResizeEndListener = this.onResizeEnd.bind(this);
|
|
window.document.addEventListener('mousemove', this.documentResizeListener);
|
|
window.document.addEventListener('mouseup', this.documentResizeEndListener);
|
|
}
|
|
}, {
|
|
key: "unbindDocumentResizeListeners",
|
|
value: function unbindDocumentResizeListeners() {
|
|
if (this.documentResizeListener && this.documentResizeEndListener) {
|
|
window.document.removeEventListener('mousemove', this.documentResizeListener);
|
|
window.document.removeEventListener('mouseup', this.documentResizeEndListener);
|
|
this.documentResizeListener = null;
|
|
this.documentResizeEndListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindDocumentKeyDownListener",
|
|
value: function bindDocumentKeyDownListener() {
|
|
var _this3 = this;
|
|
|
|
this.documentKeyDownListener = function (event) {
|
|
var currentTarget = event.currentTarget;
|
|
|
|
if (currentTarget && currentTarget.primeDialogParams) {
|
|
var params = currentTarget.primeDialogParams;
|
|
var paramLength = params.length;
|
|
var dialogId = params[paramLength - 1] ? params[paramLength - 1].id : undefined;
|
|
|
|
if (dialogId === _this3.state.id && _this3.props.closeOnEscape) {
|
|
var dialog = document.getElementById(dialogId);
|
|
|
|
if (event.which === 27) {
|
|
_this3.onClose(event);
|
|
|
|
event.stopImmediatePropagation();
|
|
params.splice(paramLength - 1, 1);
|
|
} else if (event.which === 9) {
|
|
event.preventDefault();
|
|
var focusableElements = DomHandler.getFocusableElements(dialog);
|
|
|
|
if (focusableElements && focusableElements.length > 0) {
|
|
if (!document.activeElement) {
|
|
focusableElements[0].focus();
|
|
} else {
|
|
var focusedIndex = focusableElements.indexOf(document.activeElement);
|
|
|
|
if (event.shiftKey) {
|
|
if (focusedIndex === -1 || focusedIndex === 0) focusableElements[focusableElements.length - 1].focus();else focusableElements[focusedIndex - 1].focus();
|
|
} else {
|
|
if (focusedIndex === -1 || focusedIndex === focusableElements.length - 1) focusableElements[0].focus();else focusableElements[focusedIndex + 1].focus();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
var newParam = {
|
|
id: this.state.id,
|
|
hasBlockScroll: this.props.blockScroll
|
|
};
|
|
document.primeDialogParams = document.primeDialogParams ? [].concat(_toConsumableArray(document.primeDialogParams), [newParam]) : [newParam];
|
|
document.addEventListener('keydown', this.documentKeyDownListener);
|
|
}
|
|
}, {
|
|
key: "unbindDocumentKeyDownListener",
|
|
value: function unbindDocumentKeyDownListener() {
|
|
var _this4 = this;
|
|
|
|
if (this.documentKeyDownListener) {
|
|
document.removeEventListener('keydown', this.documentKeyDownListener);
|
|
document.primeDialogParams = document.primeDialogParams && document.primeDialogParams.filter(function (param) {
|
|
return param.id !== _this4.state.id;
|
|
});
|
|
this.documentKeyDownListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "createStyle",
|
|
value: function createStyle() {
|
|
if (!this.styleElement) {
|
|
this.styleElement = DomHandler.createInlineStyle(PrimeReact.nonce);
|
|
var innerHTML = '';
|
|
|
|
for (var breakpoint in this.props.breakpoints) {
|
|
innerHTML += "\n @media screen and (max-width: ".concat(breakpoint, ") {\n .p-dialog[").concat(this.attributeSelector, "] {\n width: ").concat(this.props.breakpoints[breakpoint], " !important;\n }\n }\n ");
|
|
}
|
|
|
|
this.styleElement.innerHTML = innerHTML;
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
var _this5 = this;
|
|
|
|
if (!this.state.id) {
|
|
this.setState({
|
|
id: UniqueComponentId()
|
|
});
|
|
}
|
|
|
|
if (this.props.visible) {
|
|
this.setState({
|
|
maskVisible: true
|
|
}, function () {
|
|
ZIndexUtils.set('modal', _this5.mask, PrimeReact.autoZIndex, _this5.props.baseZIndex || PrimeReact.zIndex['modal']);
|
|
|
|
_this5.setState({
|
|
visible: true
|
|
});
|
|
});
|
|
}
|
|
|
|
if (this.props.breakpoints) {
|
|
this.createStyle();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
var _this6 = this;
|
|
|
|
if (this.props.visible && !this.state.maskVisible) {
|
|
this.setState({
|
|
maskVisible: true
|
|
}, function () {
|
|
ZIndexUtils.set('modal', _this6.mask, PrimeReact.autoZIndex, _this6.props.baseZIndex || PrimeReact.zIndex['modal']);
|
|
});
|
|
}
|
|
|
|
if (this.props.visible !== this.state.visible && this.state.maskVisible) {
|
|
this.setState({
|
|
visible: this.props.visible
|
|
});
|
|
}
|
|
|
|
if (prevProps.maximized !== this.props.maximized && this.props.onMaximize) {
|
|
this.changeScrollOnMaximizable();
|
|
}
|
|
}
|
|
}, {
|
|
key: "changeScrollOnMaximizable",
|
|
value: function changeScrollOnMaximizable() {
|
|
if (!this.props.blockScroll) {
|
|
var funcName = this.maximized ? 'addClass' : 'removeClass';
|
|
DomHandler[funcName](document.body, 'p-overflow-hidden');
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.disableDocumentSettings();
|
|
this.styleElement = DomHandler.removeInlineStyle(this.styleElement);
|
|
ZIndexUtils.clear(this.mask);
|
|
}
|
|
}, {
|
|
key: "renderCloseIcon",
|
|
value: function renderCloseIcon() {
|
|
var _this7 = this;
|
|
|
|
if (this.props.closable) {
|
|
return /*#__PURE__*/React.createElement("button", {
|
|
ref: function ref(el) {
|
|
return _this7.closeElement = el;
|
|
},
|
|
type: "button",
|
|
className: "p-dialog-header-icon p-dialog-header-close p-link",
|
|
"aria-label": this.props.ariaCloseIconLabel,
|
|
onClick: this.onClose
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-dialog-header-close-icon pi pi-times"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderMaximizeIcon",
|
|
value: function renderMaximizeIcon() {
|
|
var iconClassName = classNames('p-dialog-header-maximize-icon pi', {
|
|
'pi-window-maximize': !this.maximized,
|
|
'pi-window-minimize': this.maximized
|
|
});
|
|
|
|
if (this.props.maximizable) {
|
|
return /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "p-dialog-header-icon p-dialog-header-maximize p-link",
|
|
onClick: this.toggleMaximize
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderHeader",
|
|
value: function renderHeader() {
|
|
var _this8 = this;
|
|
|
|
if (this.props.showHeader) {
|
|
var closeIcon = this.renderCloseIcon();
|
|
var maximizeIcon = this.renderMaximizeIcon();
|
|
var icons = ObjectUtils.getJSXElement(this.props.icons, this.props);
|
|
var header = ObjectUtils.getJSXElement(this.props.header, this.props);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this8.headerEl = el;
|
|
},
|
|
className: "p-dialog-header",
|
|
onMouseDown: this.onDragStart
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
id: this.state.id + '_header',
|
|
className: "p-dialog-title"
|
|
}, header), /*#__PURE__*/React.createElement("div", {
|
|
className: "p-dialog-header-icons"
|
|
}, icons, maximizeIcon, closeIcon));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
var _this9 = this;
|
|
|
|
var contentClassName = classNames('p-dialog-content', this.props.contentClassName);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.state.id + '_content',
|
|
ref: function ref(el) {
|
|
return _this9.contentEl = el;
|
|
},
|
|
className: contentClassName,
|
|
style: this.props.contentStyle
|
|
}, this.props.children);
|
|
}
|
|
}, {
|
|
key: "renderFooter",
|
|
value: function renderFooter() {
|
|
var _this10 = this;
|
|
|
|
var footer = ObjectUtils.getJSXElement(this.props.footer, this.props);
|
|
return footer && /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this10.footerElement = el;
|
|
},
|
|
className: "p-dialog-footer"
|
|
}, footer);
|
|
}
|
|
}, {
|
|
key: "renderResizer",
|
|
value: function renderResizer() {
|
|
if (this.props.resizable) {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-resizable-handle",
|
|
style: {
|
|
zIndex: 90
|
|
},
|
|
onMouseDown: this.onResizeStart
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
var _this11 = this;
|
|
|
|
var className = classNames('p-dialog p-component', this.props.className, {
|
|
'p-dialog-rtl': this.props.rtl,
|
|
'p-dialog-maximized': this.maximized
|
|
});
|
|
var maskClassName = classNames('p-dialog-mask', {
|
|
'p-component-overlay p-component-overlay-enter': this.props.modal,
|
|
'p-dialog-visible': this.state.maskVisible,
|
|
'p-dialog-draggable': this.props.draggable,
|
|
'p-dialog-resizable': this.props.resizable
|
|
}, this.props.maskClassName, this.getPositionClass());
|
|
var header = this.renderHeader();
|
|
var content = this.renderContent();
|
|
var footer = this.renderFooter();
|
|
var resizer = this.renderResizer();
|
|
var transitionTimeout = {
|
|
enter: this.props.position === 'center' ? 150 : 300,
|
|
exit: this.props.position === 'center' ? 150 : 300
|
|
};
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this11.mask = el;
|
|
},
|
|
style: this.props.maskStyle,
|
|
className: maskClassName,
|
|
onClick: this.onMaskClick
|
|
}, /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.dialogRef,
|
|
classNames: "p-dialog",
|
|
timeout: transitionTimeout,
|
|
"in": this.state.visible,
|
|
options: this.props.transitionOptions,
|
|
unmountOnExit: true,
|
|
onEnter: this.onEnter,
|
|
onEntered: this.onEntered,
|
|
onExiting: this.onExiting,
|
|
onExited: this.onExited
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.dialogRef,
|
|
id: this.state.id,
|
|
className: className,
|
|
style: this.props.style,
|
|
onClick: this.props.onClick,
|
|
role: "dialog",
|
|
"aria-labelledby": this.state.id + '_header',
|
|
"aria-describedby": this.state.id + '_content',
|
|
"aria-modal": this.props.modal
|
|
}, header, content, footer, resizer)));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
if (this.state.maskVisible) {
|
|
var element = this.renderElement();
|
|
return /*#__PURE__*/React.createElement(Portal, {
|
|
element: element,
|
|
appendTo: this.props.appendTo,
|
|
visible: true
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}]);
|
|
|
|
return Dialog;
|
|
}(Component);
|
|
|
|
_defineProperty(Dialog, "defaultProps", {
|
|
id: null,
|
|
header: null,
|
|
footer: null,
|
|
visible: false,
|
|
position: 'center',
|
|
draggable: true,
|
|
resizable: true,
|
|
modal: true,
|
|
onHide: null,
|
|
onShow: null,
|
|
contentStyle: null,
|
|
contentClassName: null,
|
|
closeOnEscape: true,
|
|
dismissableMask: false,
|
|
rtl: false,
|
|
closable: true,
|
|
style: null,
|
|
className: null,
|
|
maskStyle: null,
|
|
maskClassName: null,
|
|
showHeader: true,
|
|
appendTo: null,
|
|
baseZIndex: 0,
|
|
maximizable: false,
|
|
blockScroll: false,
|
|
icons: null,
|
|
ariaCloseIconLabel: 'Close',
|
|
focusOnShow: true,
|
|
minX: 0,
|
|
minY: 0,
|
|
keepInViewport: true,
|
|
maximized: false,
|
|
breakpoints: null,
|
|
transitionOptions: null,
|
|
onMaximize: null,
|
|
onDragStart: null,
|
|
onDrag: null,
|
|
onDragEnd: null,
|
|
onResizeStart: null,
|
|
onResize: null,
|
|
onResizeEnd: null,
|
|
onClick: null,
|
|
onMaskClick: null
|
|
});
|
|
|
|
function _createSuper$1T(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1T(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1T() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function ownKeys$F(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$F(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$F(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$F(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
function confirmDialog(props) {
|
|
var appendTo = props.appendTo || document.body;
|
|
var confirmDialogWrapper = document.createDocumentFragment();
|
|
DomHandler.appendChild(confirmDialogWrapper, appendTo);
|
|
props = _objectSpread$F(_objectSpread$F({}, props), {
|
|
visible: props.visible === undefined ? true : props.visible
|
|
});
|
|
var confirmDialogEl = /*#__PURE__*/React.createElement(ConfirmDialog, props);
|
|
ReactDOM.render(confirmDialogEl, confirmDialogWrapper);
|
|
|
|
var updateConfirmDialog = function updateConfirmDialog(newProps) {
|
|
props = _objectSpread$F(_objectSpread$F({}, props), newProps);
|
|
ReactDOM.render( /*#__PURE__*/React.cloneElement(confirmDialogEl, props), confirmDialogWrapper);
|
|
};
|
|
|
|
return {
|
|
_destroy: function _destroy() {
|
|
ReactDOM.unmountComponentAtNode(confirmDialogWrapper);
|
|
},
|
|
show: function show() {
|
|
updateConfirmDialog({
|
|
visible: true,
|
|
onHide: function onHide() {
|
|
updateConfirmDialog({
|
|
visible: false
|
|
}); // reset
|
|
}
|
|
});
|
|
},
|
|
hide: function hide() {
|
|
updateConfirmDialog({
|
|
visible: false
|
|
});
|
|
},
|
|
update: function update(newProps) {
|
|
updateConfirmDialog(newProps);
|
|
}
|
|
};
|
|
}
|
|
var ConfirmDialog = /*#__PURE__*/function (_Component) {
|
|
_inherits(ConfirmDialog, _Component);
|
|
|
|
var _super = _createSuper$1T(ConfirmDialog);
|
|
|
|
function ConfirmDialog(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, ConfirmDialog);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
visible: props.visible
|
|
};
|
|
_this.reject = _this.reject.bind(_assertThisInitialized(_this));
|
|
_this.accept = _this.accept.bind(_assertThisInitialized(_this));
|
|
_this.hide = _this.hide.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(ConfirmDialog, [{
|
|
key: "acceptLabel",
|
|
value: function acceptLabel() {
|
|
return this.props.acceptLabel || localeOption('accept');
|
|
}
|
|
}, {
|
|
key: "rejectLabel",
|
|
value: function rejectLabel() {
|
|
return this.props.rejectLabel || localeOption('reject');
|
|
}
|
|
}, {
|
|
key: "accept",
|
|
value: function accept() {
|
|
if (this.props.accept) {
|
|
this.props.accept();
|
|
}
|
|
|
|
this.hide('accept');
|
|
}
|
|
}, {
|
|
key: "reject",
|
|
value: function reject() {
|
|
if (this.props.reject) {
|
|
this.props.reject();
|
|
}
|
|
|
|
this.hide('reject');
|
|
}
|
|
}, {
|
|
key: "show",
|
|
value: function show() {
|
|
this.setState({
|
|
visible: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "hide",
|
|
value: function hide(result) {
|
|
var _this2 = this;
|
|
|
|
this.setState({
|
|
visible: false
|
|
}, function () {
|
|
if (_this2.props.onHide) {
|
|
_this2.props.onHide(result);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.visible !== this.props.visible) {
|
|
this.setState({
|
|
visible: this.props.visible
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderFooter",
|
|
value: function renderFooter() {
|
|
var acceptClassName = classNames('p-confirm-dialog-accept', this.props.acceptClassName);
|
|
var rejectClassName = classNames('p-confirm-dialog-reject', {
|
|
'p-button-text': !this.props.rejectClassName
|
|
}, this.props.rejectClassName);
|
|
var content = /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Button, {
|
|
label: this.rejectLabel(),
|
|
icon: this.props.rejectIcon,
|
|
className: rejectClassName,
|
|
onClick: this.reject
|
|
}), /*#__PURE__*/React.createElement(Button, {
|
|
label: this.acceptLabel(),
|
|
icon: this.props.acceptIcon,
|
|
className: acceptClassName,
|
|
onClick: this.accept,
|
|
autoFocus: true
|
|
}));
|
|
|
|
if (this.props.footer) {
|
|
var defaultContentOptions = {
|
|
accept: this.accept,
|
|
reject: this.reject,
|
|
acceptClassName: acceptClassName,
|
|
rejectClassName: rejectClassName,
|
|
acceptLabel: this.acceptLabel(),
|
|
rejectLabel: this.rejectLabel(),
|
|
element: content,
|
|
props: this.props
|
|
};
|
|
return ObjectUtils.getJSXElement(this.props.footer, defaultContentOptions);
|
|
}
|
|
|
|
return content;
|
|
}
|
|
}, {
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
var className = classNames('p-confirm-dialog', this.props.className);
|
|
var dialogProps = ObjectUtils.findDiffKeys(this.props, ConfirmDialog.defaultProps);
|
|
var message = ObjectUtils.getJSXElement(this.props.message, this.props);
|
|
var footer = this.renderFooter();
|
|
return /*#__PURE__*/React.createElement(Dialog, _extends({
|
|
visible: this.state.visible
|
|
}, dialogProps, {
|
|
className: className,
|
|
footer: footer,
|
|
onHide: this.hide,
|
|
breakpoints: this.props.breakpoints
|
|
}), IconUtils.getJSXIcon(this.props.icon, {
|
|
className: 'p-confirm-dialog-icon'
|
|
}, {
|
|
props: this.props
|
|
}), /*#__PURE__*/React.createElement("span", {
|
|
className: "p-confirm-dialog-message"
|
|
}, message));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var element = this.renderElement();
|
|
return /*#__PURE__*/React.createElement(Portal, {
|
|
element: element,
|
|
appendTo: this.props.appendTo
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return ConfirmDialog;
|
|
}(Component);
|
|
|
|
_defineProperty(ConfirmDialog, "defaultProps", {
|
|
visible: false,
|
|
message: null,
|
|
rejectLabel: null,
|
|
acceptLabel: null,
|
|
icon: null,
|
|
rejectIcon: null,
|
|
acceptIcon: null,
|
|
rejectClassName: null,
|
|
acceptClassName: null,
|
|
className: null,
|
|
appendTo: null,
|
|
footer: null,
|
|
breakpoints: null,
|
|
onHide: null,
|
|
accept: null,
|
|
reject: null
|
|
});
|
|
|
|
function _createSuper$1S(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1S(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1S() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function ownKeys$E(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$E(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$E(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$E(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
function confirmPopup(props) {
|
|
var appendTo = props.appendTo || document.body;
|
|
var confirmPopupWrapper = document.createDocumentFragment();
|
|
DomHandler.appendChild(confirmPopupWrapper, appendTo);
|
|
props = _objectSpread$E(_objectSpread$E({}, props), {
|
|
visible: props.visible === undefined ? true : props.visible
|
|
});
|
|
var confirmPopupEl = /*#__PURE__*/React.createElement(ConfirmPopup, props);
|
|
ReactDOM.render(confirmPopupEl, confirmPopupWrapper);
|
|
|
|
var updateConfirmPopup = function updateConfirmPopup(newProps) {
|
|
props = _objectSpread$E(_objectSpread$E({}, props), newProps);
|
|
ReactDOM.render( /*#__PURE__*/React.cloneElement(confirmPopupEl, props), confirmPopupWrapper);
|
|
};
|
|
|
|
return {
|
|
_destroy: function _destroy() {
|
|
ReactDOM.unmountComponentAtNode(confirmPopupWrapper);
|
|
},
|
|
show: function show() {
|
|
updateConfirmPopup({
|
|
visible: true,
|
|
onHide: function onHide() {
|
|
updateConfirmPopup({
|
|
visible: false
|
|
}); // reset
|
|
}
|
|
});
|
|
},
|
|
hide: function hide() {
|
|
updateConfirmPopup({
|
|
visible: false
|
|
});
|
|
},
|
|
update: function update(newProps) {
|
|
updateConfirmPopup(newProps);
|
|
}
|
|
};
|
|
}
|
|
var ConfirmPopup = /*#__PURE__*/function (_Component) {
|
|
_inherits(ConfirmPopup, _Component);
|
|
|
|
var _super = _createSuper$1S(ConfirmPopup);
|
|
|
|
function ConfirmPopup(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, ConfirmPopup);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
visible: false
|
|
};
|
|
_this.reject = _this.reject.bind(_assertThisInitialized(_this));
|
|
_this.accept = _this.accept.bind(_assertThisInitialized(_this));
|
|
_this.hide = _this.hide.bind(_assertThisInitialized(_this));
|
|
_this.onCloseClick = _this.onCloseClick.bind(_assertThisInitialized(_this));
|
|
_this.onPanelClick = _this.onPanelClick.bind(_assertThisInitialized(_this));
|
|
_this.onEnter = _this.onEnter.bind(_assertThisInitialized(_this));
|
|
_this.onEntered = _this.onEntered.bind(_assertThisInitialized(_this));
|
|
_this.onExit = _this.onExit.bind(_assertThisInitialized(_this));
|
|
_this.onExited = _this.onExited.bind(_assertThisInitialized(_this));
|
|
_this.overlayRef = /*#__PURE__*/React.createRef();
|
|
_this.acceptBtnRef = /*#__PURE__*/React.createRef();
|
|
return _this;
|
|
}
|
|
|
|
_createClass(ConfirmPopup, [{
|
|
key: "acceptLabel",
|
|
value: function acceptLabel() {
|
|
return this.props.acceptLabel || localeOption('accept');
|
|
}
|
|
}, {
|
|
key: "rejectLabel",
|
|
value: function rejectLabel() {
|
|
return this.props.rejectLabel || localeOption('reject');
|
|
}
|
|
}, {
|
|
key: "bindDocumentClickListener",
|
|
value: function bindDocumentClickListener() {
|
|
var _this2 = this;
|
|
|
|
if (!this.documentClickListener && this.props.dismissable) {
|
|
this.documentClickListener = function (event) {
|
|
if (!_this2.isPanelClicked && _this2.isOutsideClicked(event.target)) {
|
|
_this2.hide();
|
|
}
|
|
|
|
_this2.isPanelClicked = false;
|
|
};
|
|
|
|
document.addEventListener('click', this.documentClickListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentClickListener",
|
|
value: function unbindDocumentClickListener() {
|
|
if (this.documentClickListener) {
|
|
document.removeEventListener('click', this.documentClickListener);
|
|
this.documentClickListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindScrollListener",
|
|
value: function bindScrollListener() {
|
|
var _this3 = this;
|
|
|
|
if (!this.scrollHandler) {
|
|
this.scrollHandler = new ConnectedOverlayScrollHandler(this.props.target, function () {
|
|
if (_this3.state.visible) {
|
|
_this3.hide();
|
|
}
|
|
});
|
|
}
|
|
|
|
this.scrollHandler.bindScrollListener();
|
|
}
|
|
}, {
|
|
key: "unbindScrollListener",
|
|
value: function unbindScrollListener() {
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.unbindScrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindResizeListener",
|
|
value: function bindResizeListener() {
|
|
var _this4 = this;
|
|
|
|
if (!this.resizeListener) {
|
|
this.resizeListener = function () {
|
|
if (_this4.state.visible && !DomHandler.isTouchDevice()) {
|
|
_this4.hide();
|
|
}
|
|
};
|
|
|
|
window.addEventListener('resize', this.resizeListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindResizeListener",
|
|
value: function unbindResizeListener() {
|
|
if (this.resizeListener) {
|
|
window.removeEventListener('resize', this.resizeListener);
|
|
this.resizeListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "isOutsideClicked",
|
|
value: function isOutsideClicked(target) {
|
|
return this.overlayRef && this.overlayRef.current && !(this.overlayRef.current.isSameNode(target) || this.overlayRef.current.contains(target));
|
|
}
|
|
}, {
|
|
key: "onCloseClick",
|
|
value: function onCloseClick(event) {
|
|
this.hide();
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onPanelClick",
|
|
value: function onPanelClick(event) {
|
|
this.isPanelClicked = true;
|
|
OverlayService.emit('overlay-click', {
|
|
originalEvent: event,
|
|
target: this.props.target
|
|
});
|
|
}
|
|
}, {
|
|
key: "accept",
|
|
value: function accept() {
|
|
if (this.props.accept) {
|
|
this.props.accept();
|
|
}
|
|
|
|
this.hide('accept');
|
|
}
|
|
}, {
|
|
key: "reject",
|
|
value: function reject() {
|
|
if (this.props.reject) {
|
|
this.props.reject();
|
|
}
|
|
|
|
this.hide('reject');
|
|
}
|
|
}, {
|
|
key: "show",
|
|
value: function show() {
|
|
var _this5 = this;
|
|
|
|
this.setState({
|
|
visible: true
|
|
}, function () {
|
|
_this5.overlayEventListener = function (e) {
|
|
if (!_this5.isOutsideClicked(e.target)) {
|
|
_this5.isPanelClicked = true;
|
|
}
|
|
};
|
|
|
|
OverlayService.on('overlay-click', _this5.overlayEventListener);
|
|
});
|
|
}
|
|
}, {
|
|
key: "hide",
|
|
value: function hide(result) {
|
|
var _this6 = this;
|
|
|
|
this.setState({
|
|
visible: false
|
|
}, function () {
|
|
OverlayService.off('overlay-click', _this6.overlayEventListener);
|
|
_this6.overlayEventListener = null;
|
|
|
|
if (_this6.props.onHide) {
|
|
_this6.props.onHide(result);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onEnter",
|
|
value: function onEnter() {
|
|
ZIndexUtils.set('overlay', this.overlayRef.current, PrimeReact.autoZIndex, PrimeReact.zIndex['overlay']);
|
|
this.align();
|
|
}
|
|
}, {
|
|
key: "onEntered",
|
|
value: function onEntered() {
|
|
this.bindDocumentClickListener();
|
|
this.bindScrollListener();
|
|
this.bindResizeListener();
|
|
|
|
if (this.acceptBtnRef && this.acceptBtnRef.current) {
|
|
this.acceptBtnRef.current.focus();
|
|
}
|
|
|
|
this.props.onShow && this.props.onShow();
|
|
}
|
|
}, {
|
|
key: "onExit",
|
|
value: function onExit() {
|
|
this.unbindDocumentClickListener();
|
|
this.unbindScrollListener();
|
|
this.unbindResizeListener();
|
|
}
|
|
}, {
|
|
key: "onExited",
|
|
value: function onExited() {
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
}
|
|
}, {
|
|
key: "align",
|
|
value: function align() {
|
|
if (this.props.target) {
|
|
DomHandler.absolutePosition(this.overlayRef.current, this.props.target);
|
|
var containerOffset = DomHandler.getOffset(this.overlayRef.current);
|
|
var targetOffset = DomHandler.getOffset(this.props.target);
|
|
var arrowLeft = 0;
|
|
|
|
if (containerOffset.left < targetOffset.left) {
|
|
arrowLeft = targetOffset.left - containerOffset.left;
|
|
}
|
|
|
|
this.overlayRef.current.style.setProperty('--overlayArrowLeft', "".concat(arrowLeft, "px"));
|
|
|
|
if (containerOffset.top < targetOffset.top) {
|
|
DomHandler.addClass(this.overlayRef.current, 'p-confirm-popup-flipped');
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (this.props.visible) {
|
|
this.setState({
|
|
visible: true
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.visible !== this.props.visible) {
|
|
this.setState({
|
|
visible: this.props.visible
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.unbindDocumentClickListener();
|
|
this.unbindResizeListener();
|
|
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.destroy();
|
|
this.scrollHandler = null;
|
|
}
|
|
|
|
if (this.overlayEventListener) {
|
|
OverlayService.off('overlay-click', this.overlayEventListener);
|
|
this.overlayEventListener = null;
|
|
}
|
|
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
var message = ObjectUtils.getJSXElement(this.props.message, this.props);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-confirm-popup-content"
|
|
}, IconUtils.getJSXIcon(this.props.icon, {
|
|
className: 'p-confirm-popup-icon'
|
|
}, {
|
|
props: this.props
|
|
}), /*#__PURE__*/React.createElement("span", {
|
|
className: "p-confirm-popup-message"
|
|
}, message));
|
|
}
|
|
}, {
|
|
key: "renderFooter",
|
|
value: function renderFooter() {
|
|
var acceptClassName = classNames('p-confirm-popup-accept p-button-sm', this.props.acceptClassName);
|
|
var rejectClassName = classNames('p-confirm-popup-reject p-button-sm', {
|
|
'p-button-text': !this.props.rejectClassName
|
|
}, this.props.rejectClassName);
|
|
var content = /*#__PURE__*/React.createElement("div", {
|
|
className: "p-confirm-popup-footer"
|
|
}, /*#__PURE__*/React.createElement(Button, {
|
|
label: this.rejectLabel(),
|
|
icon: this.props.rejectIcon,
|
|
className: rejectClassName,
|
|
onClick: this.reject
|
|
}), /*#__PURE__*/React.createElement(Button, {
|
|
ref: this.acceptBtnRef,
|
|
label: this.acceptLabel(),
|
|
icon: this.props.acceptIcon,
|
|
className: acceptClassName,
|
|
onClick: this.accept
|
|
}));
|
|
|
|
if (this.props.footer) {
|
|
var defaultContentOptions = {
|
|
accept: this.accept,
|
|
reject: this.reject,
|
|
className: 'p-confirm-popup-footer',
|
|
acceptClassName: acceptClassName,
|
|
rejectClassName: rejectClassName,
|
|
acceptLabel: this.acceptLabel(),
|
|
rejectLabel: this.rejectLabel(),
|
|
element: content,
|
|
props: this.props
|
|
};
|
|
return ObjectUtils.getJSXElement(this.props.footer, defaultContentOptions);
|
|
}
|
|
|
|
return content;
|
|
}
|
|
}, {
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
var className = classNames('p-confirm-popup p-component', this.props.className);
|
|
var content = this.renderContent();
|
|
var footer = this.renderFooter();
|
|
return /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.overlayRef,
|
|
classNames: "p-connected-overlay",
|
|
"in": this.state.visible,
|
|
timeout: {
|
|
enter: 120,
|
|
exit: 100
|
|
},
|
|
options: this.props.transitionOptions,
|
|
unmountOnExit: true,
|
|
onEnter: this.onEnter,
|
|
onEntered: this.onEntered,
|
|
onExit: this.onExit,
|
|
onExited: this.onExited
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.overlayRef,
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style,
|
|
onClick: this.onPanelClick
|
|
}, content, footer));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var element = this.renderElement();
|
|
return /*#__PURE__*/React.createElement(Portal, {
|
|
element: element,
|
|
appendTo: this.props.appendTo,
|
|
visible: this.props.visible
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return ConfirmPopup;
|
|
}(Component);
|
|
|
|
_defineProperty(ConfirmPopup, "defaultProps", {
|
|
target: null,
|
|
visible: false,
|
|
message: null,
|
|
rejectLabel: null,
|
|
acceptLabel: null,
|
|
icon: null,
|
|
rejectIcon: null,
|
|
acceptIcon: null,
|
|
rejectClassName: null,
|
|
acceptClassName: null,
|
|
className: null,
|
|
style: null,
|
|
appendTo: null,
|
|
dismissable: true,
|
|
footer: null,
|
|
onShow: null,
|
|
onHide: null,
|
|
accept: null,
|
|
reject: null,
|
|
transitionOptions: null
|
|
});
|
|
|
|
function _createSuper$1R(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1R(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1R() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
var ContextMenuSub = /*#__PURE__*/function (_Component) {
|
|
_inherits(ContextMenuSub, _Component);
|
|
|
|
var _super = _createSuper$1R(ContextMenuSub);
|
|
|
|
function ContextMenuSub(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, ContextMenuSub);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
activeItem: null
|
|
};
|
|
_this.onEnter = _this.onEnter.bind(_assertThisInitialized(_this));
|
|
_this.submenuRef = /*#__PURE__*/React.createRef();
|
|
return _this;
|
|
}
|
|
|
|
_createClass(ContextMenuSub, [{
|
|
key: "onItemMouseEnter",
|
|
value: function onItemMouseEnter(event, item) {
|
|
if (item.disabled) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
this.setState({
|
|
activeItem: item
|
|
});
|
|
}
|
|
}, {
|
|
key: "onItemClick",
|
|
value: function onItemClick(event, item) {
|
|
if (item.disabled) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
if (!item.url) {
|
|
event.preventDefault();
|
|
}
|
|
|
|
if (item.command) {
|
|
item.command({
|
|
originalEvent: event,
|
|
item: item
|
|
});
|
|
}
|
|
|
|
if (!item.items) {
|
|
this.props.onLeafClick(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "position",
|
|
value: function position() {
|
|
var parentItem = this.submenuRef.current.parentElement;
|
|
var containerOffset = DomHandler.getOffset(this.submenuRef.current.parentElement);
|
|
var viewport = DomHandler.getViewport();
|
|
var sublistWidth = this.submenuRef.current.offsetParent ? this.submenuRef.current.offsetWidth : DomHandler.getHiddenElementOuterWidth(this.submenuRef.current);
|
|
var itemOuterWidth = DomHandler.getOuterWidth(parentItem.children[0]);
|
|
this.submenuRef.current.style.top = '0px';
|
|
|
|
if (parseInt(containerOffset.left, 10) + itemOuterWidth + sublistWidth > viewport.width - DomHandler.calculateScrollbarWidth()) {
|
|
this.submenuRef.current.style.left = -1 * sublistWidth + 'px';
|
|
} else {
|
|
this.submenuRef.current.style.left = itemOuterWidth + 'px';
|
|
}
|
|
}
|
|
}, {
|
|
key: "onEnter",
|
|
value: function onEnter() {
|
|
this.position();
|
|
}
|
|
}, {
|
|
key: "isActive",
|
|
value: function isActive() {
|
|
return this.props.root || !this.props.resetMenu;
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate() {
|
|
if (this.isActive()) {
|
|
this.position();
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderSeparator",
|
|
value: function renderSeparator(index) {
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: 'separator_' + index,
|
|
className: "p-menu-separator",
|
|
role: "separator"
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderSubmenu",
|
|
value: function renderSubmenu(item) {
|
|
if (item.items) {
|
|
return /*#__PURE__*/React.createElement(ContextMenuSub, {
|
|
model: item.items,
|
|
resetMenu: item !== this.state.activeItem,
|
|
onLeafClick: this.props.onLeafClick
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderMenuitem",
|
|
value: function renderMenuitem(item, index) {
|
|
var _this2 = this;
|
|
|
|
var active = this.state.activeItem === item;
|
|
var className = classNames('p-menuitem', {
|
|
'p-menuitem-active': active
|
|
}, item.className);
|
|
var linkClassName = classNames('p-menuitem-link', {
|
|
'p-disabled': item.disabled
|
|
});
|
|
var iconClassName = classNames('p-menuitem-icon', item.icon);
|
|
var submenuIconClassName = 'p-submenu-icon pi pi-angle-right';
|
|
var icon = item.icon && /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
});
|
|
var label = item.label && /*#__PURE__*/React.createElement("span", {
|
|
className: "p-menuitem-text"
|
|
}, item.label);
|
|
var submenuIcon = item.items && /*#__PURE__*/React.createElement("span", {
|
|
className: submenuIconClassName
|
|
});
|
|
var submenu = this.renderSubmenu(item);
|
|
var content = /*#__PURE__*/React.createElement("a", {
|
|
href: item.url || '#',
|
|
className: linkClassName,
|
|
target: item.target,
|
|
onClick: function onClick(event) {
|
|
return _this2.onItemClick(event, item, index);
|
|
},
|
|
role: "menuitem",
|
|
"aria-haspopup": item.items != null,
|
|
"aria-disabled": item.disabled
|
|
}, icon, label, submenuIcon, /*#__PURE__*/React.createElement(Ripple, null));
|
|
|
|
if (item.template) {
|
|
var defaultContentOptions = {
|
|
onClick: function onClick(event) {
|
|
return _this2.onItemClick(event, item, index);
|
|
},
|
|
className: linkClassName,
|
|
labelClassName: 'p-menuitem-text',
|
|
iconClassName: iconClassName,
|
|
submenuIconClassName: submenuIconClassName,
|
|
element: content,
|
|
props: this.props,
|
|
active: active
|
|
};
|
|
content = ObjectUtils.getJSXElement(item.template, item, defaultContentOptions);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: item.label + '_' + index,
|
|
role: "none",
|
|
className: className,
|
|
style: item.style,
|
|
onMouseEnter: function onMouseEnter(event) {
|
|
return _this2.onItemMouseEnter(event, item);
|
|
}
|
|
}, content, submenu);
|
|
}
|
|
}, {
|
|
key: "renderItem",
|
|
value: function renderItem(item, index) {
|
|
if (item.separator) return this.renderSeparator(index);else return this.renderMenuitem(item, index);
|
|
}
|
|
}, {
|
|
key: "renderMenu",
|
|
value: function renderMenu() {
|
|
var _this3 = this;
|
|
|
|
if (this.props.model) {
|
|
return this.props.model.map(function (item, index) {
|
|
return _this3.renderItem(item, index);
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames({
|
|
'p-submenu-list': !this.props.root
|
|
});
|
|
var submenu = this.renderMenu();
|
|
var isActive = this.isActive();
|
|
return /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.submenuRef,
|
|
classNames: "p-contextmenusub",
|
|
"in": isActive,
|
|
timeout: {
|
|
enter: 0,
|
|
exit: 0
|
|
},
|
|
unmountOnExit: true,
|
|
onEnter: this.onEnter
|
|
}, /*#__PURE__*/React.createElement("ul", {
|
|
ref: this.submenuRef,
|
|
className: className
|
|
}, submenu));
|
|
}
|
|
}], [{
|
|
key: "getDerivedStateFromProps",
|
|
value: function getDerivedStateFromProps(nextProps, prevState) {
|
|
if (nextProps.resetMenu === true) {
|
|
return {
|
|
activeItem: null
|
|
};
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}]);
|
|
|
|
return ContextMenuSub;
|
|
}(Component);
|
|
|
|
_defineProperty(ContextMenuSub, "defaultProps", {
|
|
model: null,
|
|
root: false,
|
|
className: null,
|
|
resetMenu: false,
|
|
onLeafClick: null
|
|
});
|
|
|
|
var ContextMenu = /*#__PURE__*/function (_Component2) {
|
|
_inherits(ContextMenu, _Component2);
|
|
|
|
var _super2 = _createSuper$1R(ContextMenu);
|
|
|
|
function ContextMenu(props) {
|
|
var _this4;
|
|
|
|
_classCallCheck(this, ContextMenu);
|
|
|
|
_this4 = _super2.call(this, props);
|
|
_this4.state = {
|
|
visible: false,
|
|
reshow: false,
|
|
resetMenu: false
|
|
};
|
|
_this4.onMenuClick = _this4.onMenuClick.bind(_assertThisInitialized(_this4));
|
|
_this4.onLeafClick = _this4.onLeafClick.bind(_assertThisInitialized(_this4));
|
|
_this4.onMenuMouseEnter = _this4.onMenuMouseEnter.bind(_assertThisInitialized(_this4));
|
|
_this4.onEnter = _this4.onEnter.bind(_assertThisInitialized(_this4));
|
|
_this4.onEntered = _this4.onEntered.bind(_assertThisInitialized(_this4));
|
|
_this4.onExit = _this4.onExit.bind(_assertThisInitialized(_this4));
|
|
_this4.onExited = _this4.onExited.bind(_assertThisInitialized(_this4));
|
|
_this4.menuRef = /*#__PURE__*/React.createRef();
|
|
return _this4;
|
|
}
|
|
|
|
_createClass(ContextMenu, [{
|
|
key: "onMenuClick",
|
|
value: function onMenuClick() {
|
|
this.setState({
|
|
resetMenu: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "onMenuMouseEnter",
|
|
value: function onMenuMouseEnter() {
|
|
this.setState({
|
|
resetMenu: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "show",
|
|
value: function show(event) {
|
|
var _this5 = this;
|
|
|
|
if (!(event instanceof Event)) {
|
|
event.persist();
|
|
}
|
|
|
|
event.stopPropagation();
|
|
event.preventDefault();
|
|
this.currentEvent = event;
|
|
|
|
if (this.state.visible) {
|
|
this.setState({
|
|
reshow: true
|
|
});
|
|
} else {
|
|
this.setState({
|
|
visible: true
|
|
}, function () {
|
|
if (_this5.props.onShow) {
|
|
_this5.props.onShow(_this5.currentEvent);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "hide",
|
|
value: function hide(event) {
|
|
var _this6 = this;
|
|
|
|
if (!(event instanceof Event)) {
|
|
event.persist();
|
|
}
|
|
|
|
this.currentEvent = event;
|
|
this.setState({
|
|
visible: false,
|
|
reshow: false
|
|
}, function () {
|
|
if (_this6.props.onHide) {
|
|
_this6.props.onHide(_this6.currentEvent);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onEnter",
|
|
value: function onEnter() {
|
|
if (this.props.autoZIndex) {
|
|
ZIndexUtils.set('menu', this.menuRef.current, PrimeReact.autoZIndex, this.props.baseZIndex || PrimeReact.zIndex['menu']);
|
|
}
|
|
|
|
this.position(this.currentEvent);
|
|
}
|
|
}, {
|
|
key: "onEntered",
|
|
value: function onEntered() {
|
|
this.bindDocumentListeners();
|
|
}
|
|
}, {
|
|
key: "onExit",
|
|
value: function onExit() {
|
|
this.currentEvent = null;
|
|
this.unbindDocumentListeners();
|
|
}
|
|
}, {
|
|
key: "onExited",
|
|
value: function onExited() {
|
|
ZIndexUtils.clear(this.menuRef.current);
|
|
}
|
|
}, {
|
|
key: "position",
|
|
value: function position(event) {
|
|
if (event) {
|
|
var left = event.pageX + 1;
|
|
var top = event.pageY + 1;
|
|
var width = this.menuRef.current.offsetParent ? this.menuRef.current.offsetWidth : DomHandler.getHiddenElementOuterWidth(this.menuRef.current);
|
|
var height = this.menuRef.current.offsetParent ? this.menuRef.current.offsetHeight : DomHandler.getHiddenElementOuterHeight(this.menuRef.current);
|
|
var viewport = DomHandler.getViewport(); //flip
|
|
|
|
if (left + width - document.body.scrollLeft > viewport.width) {
|
|
left -= width;
|
|
} //flip
|
|
|
|
|
|
if (top + height - document.body.scrollTop > viewport.height) {
|
|
top -= height;
|
|
} //fit
|
|
|
|
|
|
if (left < document.body.scrollLeft) {
|
|
left = document.body.scrollLeft;
|
|
} //fit
|
|
|
|
|
|
if (top < document.body.scrollTop) {
|
|
top = document.body.scrollTop;
|
|
}
|
|
|
|
this.menuRef.current.style.left = left + 'px';
|
|
this.menuRef.current.style.top = top + 'px';
|
|
}
|
|
}
|
|
}, {
|
|
key: "onLeafClick",
|
|
value: function onLeafClick(event) {
|
|
this.setState({
|
|
resetMenu: true
|
|
});
|
|
this.hide(event);
|
|
event.stopPropagation();
|
|
}
|
|
}, {
|
|
key: "isOutsideClicked",
|
|
value: function isOutsideClicked(event) {
|
|
return this.menuRef && this.menuRef.current && !(this.menuRef.current.isSameNode(event.target) || this.menuRef.current.contains(event.target));
|
|
}
|
|
}, {
|
|
key: "bindDocumentListeners",
|
|
value: function bindDocumentListeners() {
|
|
this.bindDocumentResizeListener();
|
|
this.bindDocumentClickListener();
|
|
}
|
|
}, {
|
|
key: "unbindDocumentListeners",
|
|
value: function unbindDocumentListeners() {
|
|
this.unbindDocumentResizeListener();
|
|
this.unbindDocumentClickListener();
|
|
}
|
|
}, {
|
|
key: "bindDocumentClickListener",
|
|
value: function bindDocumentClickListener() {
|
|
var _this7 = this;
|
|
|
|
if (!this.documentClickListener) {
|
|
this.documentClickListener = function (event) {
|
|
if (_this7.isOutsideClicked(event) && event.button !== 2) {
|
|
_this7.hide(event);
|
|
|
|
_this7.setState({
|
|
resetMenu: true
|
|
});
|
|
}
|
|
};
|
|
|
|
document.addEventListener('click', this.documentClickListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindDocumentContextMenuListener",
|
|
value: function bindDocumentContextMenuListener() {
|
|
var _this8 = this;
|
|
|
|
if (!this.documentContextMenuListener) {
|
|
this.documentContextMenuListener = function (event) {
|
|
_this8.show(event);
|
|
};
|
|
|
|
document.addEventListener('contextmenu', this.documentContextMenuListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindDocumentResizeListener",
|
|
value: function bindDocumentResizeListener() {
|
|
var _this9 = this;
|
|
|
|
if (!this.documentResizeListener) {
|
|
this.documentResizeListener = function (event) {
|
|
if (_this9.state.visible && !DomHandler.isTouchDevice()) {
|
|
_this9.hide(event);
|
|
}
|
|
};
|
|
|
|
window.addEventListener('resize', this.documentResizeListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentClickListener",
|
|
value: function unbindDocumentClickListener() {
|
|
if (this.documentClickListener) {
|
|
document.removeEventListener('click', this.documentClickListener);
|
|
this.documentClickListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentContextMenuListener",
|
|
value: function unbindDocumentContextMenuListener() {
|
|
if (this.documentContextMenuListener) {
|
|
document.removeEventListener('contextmenu', this.documentContextMenuListener);
|
|
this.documentContextMenuListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentResizeListener",
|
|
value: function unbindDocumentResizeListener() {
|
|
if (this.documentResizeListener) {
|
|
window.removeEventListener('resize', this.documentResizeListener);
|
|
this.documentResizeListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (this.props.global) {
|
|
this.bindDocumentContextMenuListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps, prevState) {
|
|
var _this10 = this;
|
|
|
|
if (this.state.visible && (prevState.reshow !== this.state.reshow || prevProps.model !== this.props.model)) {
|
|
var event = this.currentEvent;
|
|
this.setState({
|
|
visible: false,
|
|
reshow: false,
|
|
rePosition: false,
|
|
resetMenu: true
|
|
}, function () {
|
|
return _this10.show(event);
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.unbindDocumentListeners();
|
|
this.unbindDocumentContextMenuListener();
|
|
ZIndexUtils.clear(this.menuRef.current);
|
|
}
|
|
}, {
|
|
key: "renderContextMenu",
|
|
value: function renderContextMenu() {
|
|
var className = classNames('p-contextmenu p-component', this.props.className);
|
|
return /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.menuRef,
|
|
classNames: "p-contextmenu",
|
|
"in": this.state.visible,
|
|
timeout: {
|
|
enter: 250,
|
|
exit: 0
|
|
},
|
|
options: this.props.transitionOptions,
|
|
unmountOnExit: true,
|
|
onEnter: this.onEnter,
|
|
onEntered: this.onEntered,
|
|
onExit: this.onExit,
|
|
onExited: this.onExited
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.menuRef,
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style,
|
|
onClick: this.onMenuClick,
|
|
onMouseEnter: this.onMenuMouseEnter
|
|
}, /*#__PURE__*/React.createElement(ContextMenuSub, {
|
|
model: this.props.model,
|
|
root: true,
|
|
resetMenu: this.state.resetMenu,
|
|
onLeafClick: this.onLeafClick
|
|
})));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var element = this.renderContextMenu();
|
|
return /*#__PURE__*/React.createElement(Portal, {
|
|
element: element,
|
|
appendTo: this.props.appendTo
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return ContextMenu;
|
|
}(Component);
|
|
|
|
_defineProperty(ContextMenu, "defaultProps", {
|
|
id: null,
|
|
model: null,
|
|
style: null,
|
|
className: null,
|
|
global: false,
|
|
autoZIndex: true,
|
|
baseZIndex: 0,
|
|
appendTo: null,
|
|
transitionOptions: null,
|
|
onShow: null,
|
|
onHide: null
|
|
});
|
|
|
|
function _createSuper$1Q(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1Q(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1Q() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var DataScroller = /*#__PURE__*/function (_Component) {
|
|
_inherits(DataScroller, _Component);
|
|
|
|
var _super = _createSuper$1Q(DataScroller);
|
|
|
|
function DataScroller(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, DataScroller);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {};
|
|
_this.dataToRender = [];
|
|
_this.value = _this.props.value;
|
|
_this.first = 0;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(DataScroller, [{
|
|
key: "handleDataChange",
|
|
value: function handleDataChange() {
|
|
if (this.props.lazy) {
|
|
this.dataToRender = this.value;
|
|
this.setState({
|
|
dataToRender: this.dataToRender
|
|
});
|
|
} else {
|
|
this.load();
|
|
}
|
|
}
|
|
}, {
|
|
key: "load",
|
|
value: function load() {
|
|
if (this.props.lazy) {
|
|
if (this.props.onLazyLoad) {
|
|
this.props.onLazyLoad(this.createLazyLoadMetadata());
|
|
}
|
|
|
|
this.first = this.first + this.props.rows;
|
|
} else {
|
|
if (this.value) {
|
|
for (var i = this.first; i < this.first + this.props.rows; i++) {
|
|
if (i >= this.value.length) {
|
|
break;
|
|
}
|
|
|
|
this.dataToRender.push(this.value[i]);
|
|
}
|
|
|
|
if (this.value.length !== 0) {
|
|
this.first = this.first + this.props.rows;
|
|
}
|
|
|
|
this.setState({
|
|
dataToRender: this.dataToRender
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "reset",
|
|
value: function reset() {
|
|
this.first = 0;
|
|
this.dataToRender = [];
|
|
this.setState({
|
|
dataToRender: this.dataToRender
|
|
});
|
|
this.load();
|
|
}
|
|
}, {
|
|
key: "isEmpty",
|
|
value: function isEmpty() {
|
|
return !this.dataToRender || this.dataToRender.length === 0;
|
|
}
|
|
}, {
|
|
key: "createLazyLoadMetadata",
|
|
value: function createLazyLoadMetadata() {
|
|
return {
|
|
first: this.first,
|
|
rows: this.props.rows
|
|
};
|
|
}
|
|
}, {
|
|
key: "bindScrollListener",
|
|
value: function bindScrollListener() {
|
|
var _this2 = this;
|
|
|
|
if (this.props.inline) {
|
|
this.scrollFunction = function () {
|
|
var scrollTop = _this2.contentElement.scrollTop,
|
|
scrollHeight = _this2.contentElement.scrollHeight,
|
|
viewportHeight = _this2.contentElement.clientHeight;
|
|
|
|
if (scrollTop >= scrollHeight * _this2.props.buffer - viewportHeight) {
|
|
_this2.load();
|
|
}
|
|
};
|
|
|
|
this.contentElement.addEventListener('scroll', this.scrollFunction);
|
|
} else {
|
|
this.scrollFunction = function () {
|
|
var docBody = document.body,
|
|
docElement = document.documentElement,
|
|
scrollTop = window.pageYOffset || document.documentElement.scrollTop,
|
|
winHeight = docElement.clientHeight,
|
|
docHeight = Math.max(docBody.scrollHeight, docBody.offsetHeight, winHeight, docElement.scrollHeight, docElement.offsetHeight);
|
|
|
|
if (scrollTop >= docHeight * _this2.props.buffer - winHeight) {
|
|
_this2.load();
|
|
}
|
|
};
|
|
|
|
window.addEventListener('scroll', this.scrollFunction);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindScrollListener",
|
|
value: function unbindScrollListener() {
|
|
if (this.scrollFunction) {
|
|
if (this.props.inline) {
|
|
this.contentElement.removeEventListener('scroll', this.scrollFunction);
|
|
this.contentElement = null;
|
|
} else if (!this.props.loader) {
|
|
window.removeEventListener('scroll', this.scrollFunction);
|
|
}
|
|
}
|
|
|
|
this.scrollFunction = null;
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.load();
|
|
|
|
if (!this.props.loader) {
|
|
this.bindScrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps, prevState) {
|
|
var newValue = this.props.value;
|
|
|
|
if (newValue && this.value !== newValue) {
|
|
this.value = newValue;
|
|
this.first = 0;
|
|
this.dataToRender = [];
|
|
this.handleDataChange();
|
|
}
|
|
|
|
if (prevProps.loader !== this.props.loader && this.props.loader) {
|
|
this.unbindScrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.scrollFunction) {
|
|
this.unbindScrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderHeader",
|
|
value: function renderHeader() {
|
|
if (this.props.header) {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-datascroller-header"
|
|
}, this.props.header);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderFooter",
|
|
value: function renderFooter() {
|
|
if (this.props.footer) {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-datascroller-footer"
|
|
}, this.props.footer);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderItem",
|
|
value: function renderItem(value, index) {
|
|
var content = this.props.itemTemplate ? this.props.itemTemplate(value) : value;
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: index + '_datascrollitem'
|
|
}, content);
|
|
}
|
|
}, {
|
|
key: "renderEmptyMessage",
|
|
value: function renderEmptyMessage() {
|
|
var content = ObjectUtils.getJSXElement(this.props.emptyMessage, this.props) || localeOption('emptyMessage');
|
|
return /*#__PURE__*/React.createElement("li", null, content);
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
var _this3 = this;
|
|
|
|
var content = this.state.dataToRender && this.state.dataToRender.length ? this.state.dataToRender.map(function (val, i) {
|
|
return _this3.renderItem(val, i);
|
|
}) : this.renderEmptyMessage();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this3.contentElement = el;
|
|
},
|
|
className: "p-datascroller-content",
|
|
style: {
|
|
'maxHeight': this.props.scrollHeight
|
|
}
|
|
}, /*#__PURE__*/React.createElement("ul", {
|
|
className: "p-datascroller-list"
|
|
}, content));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-datascroller p-component', this.props.className, {
|
|
'p-datascroller-inline': this.props.inline
|
|
});
|
|
var header = this.renderHeader();
|
|
var footer = this.renderFooter();
|
|
var content = this.renderContent();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
className: className
|
|
}, header, content, footer);
|
|
}
|
|
}]);
|
|
|
|
return DataScroller;
|
|
}(Component);
|
|
|
|
_defineProperty(DataScroller, "defaultProps", {
|
|
id: null,
|
|
value: null,
|
|
rows: 0,
|
|
inline: false,
|
|
scrollHeight: null,
|
|
loader: false,
|
|
buffer: 0.9,
|
|
style: null,
|
|
className: null,
|
|
onLazyLoad: null,
|
|
emptyMessage: null,
|
|
itemTemplate: null,
|
|
header: null,
|
|
footer: null,
|
|
lazy: false
|
|
});
|
|
|
|
function _createSuper$1P(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1P(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1P() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var FirstPageLink = /*#__PURE__*/function (_Component) {
|
|
_inherits(FirstPageLink, _Component);
|
|
|
|
var _super = _createSuper$1P(FirstPageLink);
|
|
|
|
function FirstPageLink() {
|
|
_classCallCheck(this, FirstPageLink);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(FirstPageLink, [{
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-paginator-first p-paginator-element p-link', {
|
|
'p-disabled': this.props.disabled
|
|
});
|
|
var iconClassName = 'p-paginator-icon pi pi-angle-double-left';
|
|
var element = /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: className,
|
|
onClick: this.props.onClick,
|
|
disabled: this.props.disabled
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
|
|
if (this.props.template) {
|
|
var defaultOptions = {
|
|
onClick: this.props.onClick,
|
|
className: className,
|
|
iconClassName: iconClassName,
|
|
disabled: this.props.disabled,
|
|
element: element,
|
|
props: this.props
|
|
};
|
|
return ObjectUtils.getJSXElement(this.props.template, defaultOptions);
|
|
}
|
|
|
|
return element;
|
|
}
|
|
}]);
|
|
|
|
return FirstPageLink;
|
|
}(Component);
|
|
|
|
_defineProperty(FirstPageLink, "defaultProps", {
|
|
disabled: false,
|
|
onClick: null,
|
|
template: null
|
|
});
|
|
|
|
function _createSuper$1O(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1O(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1O() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var NextPageLink = /*#__PURE__*/function (_Component) {
|
|
_inherits(NextPageLink, _Component);
|
|
|
|
var _super = _createSuper$1O(NextPageLink);
|
|
|
|
function NextPageLink() {
|
|
_classCallCheck(this, NextPageLink);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(NextPageLink, [{
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-paginator-next p-paginator-element p-link', {
|
|
'p-disabled': this.props.disabled
|
|
});
|
|
var iconClassName = 'p-paginator-icon pi pi-angle-right';
|
|
var element = /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: className,
|
|
onClick: this.props.onClick,
|
|
disabled: this.props.disabled
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
|
|
if (this.props.template) {
|
|
var defaultOptions = {
|
|
onClick: this.props.onClick,
|
|
className: className,
|
|
iconClassName: iconClassName,
|
|
disabled: this.props.disabled,
|
|
element: element,
|
|
props: this.props
|
|
};
|
|
return ObjectUtils.getJSXElement(this.props.template, defaultOptions);
|
|
}
|
|
|
|
return element;
|
|
}
|
|
}]);
|
|
|
|
return NextPageLink;
|
|
}(Component);
|
|
|
|
_defineProperty(NextPageLink, "defaultProps", {
|
|
disabled: false,
|
|
onClick: null,
|
|
template: null
|
|
});
|
|
|
|
function _createSuper$1N(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1N(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1N() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var PrevPageLink = /*#__PURE__*/function (_Component) {
|
|
_inherits(PrevPageLink, _Component);
|
|
|
|
var _super = _createSuper$1N(PrevPageLink);
|
|
|
|
function PrevPageLink() {
|
|
_classCallCheck(this, PrevPageLink);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(PrevPageLink, [{
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-paginator-prev p-paginator-element p-link', {
|
|
'p-disabled': this.props.disabled
|
|
});
|
|
var iconClassName = 'p-paginator-icon pi pi-angle-left';
|
|
var element = /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: className,
|
|
onClick: this.props.onClick,
|
|
disabled: this.props.disabled
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
|
|
if (this.props.template) {
|
|
var defaultOptions = {
|
|
onClick: this.props.onClick,
|
|
className: className,
|
|
iconClassName: iconClassName,
|
|
disabled: this.props.disabled,
|
|
element: element,
|
|
props: this.props
|
|
};
|
|
return ObjectUtils.getJSXElement(this.props.template, defaultOptions);
|
|
}
|
|
|
|
return element;
|
|
}
|
|
}]);
|
|
|
|
return PrevPageLink;
|
|
}(Component);
|
|
|
|
_defineProperty(PrevPageLink, "defaultProps", {
|
|
disabled: false,
|
|
onClick: null,
|
|
template: null
|
|
});
|
|
|
|
function _createSuper$1M(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1M(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1M() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var LastPageLink = /*#__PURE__*/function (_Component) {
|
|
_inherits(LastPageLink, _Component);
|
|
|
|
var _super = _createSuper$1M(LastPageLink);
|
|
|
|
function LastPageLink() {
|
|
_classCallCheck(this, LastPageLink);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(LastPageLink, [{
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-paginator-last p-paginator-element p-link', {
|
|
'p-disabled': this.props.disabled
|
|
});
|
|
var iconClassName = 'p-paginator-icon pi pi-angle-double-right';
|
|
var element = /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: className,
|
|
onClick: this.props.onClick,
|
|
disabled: this.props.disabled
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
|
|
if (this.props.template) {
|
|
var defaultOptions = {
|
|
onClick: this.props.onClick,
|
|
className: className,
|
|
iconClassName: iconClassName,
|
|
disabled: this.props.disabled,
|
|
element: element,
|
|
props: this.props
|
|
};
|
|
return ObjectUtils.getJSXElement(this.props.template, defaultOptions);
|
|
}
|
|
|
|
return element;
|
|
}
|
|
}]);
|
|
|
|
return LastPageLink;
|
|
}(Component);
|
|
|
|
_defineProperty(LastPageLink, "defaultProps", {
|
|
disabled: false,
|
|
onClick: null,
|
|
template: null
|
|
});
|
|
|
|
function _createSuper$1L(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1L(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1L() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var PageLinks = /*#__PURE__*/function (_Component) {
|
|
_inherits(PageLinks, _Component);
|
|
|
|
var _super = _createSuper$1L(PageLinks);
|
|
|
|
function PageLinks() {
|
|
_classCallCheck(this, PageLinks);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(PageLinks, [{
|
|
key: "onPageLinkClick",
|
|
value: function onPageLinkClick(event, pageLink) {
|
|
if (this.props.onClick) {
|
|
this.props.onClick({
|
|
originalEvent: event,
|
|
value: pageLink
|
|
});
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this = this;
|
|
|
|
var elements;
|
|
|
|
if (this.props.value) {
|
|
var startPageInView = this.props.value[0];
|
|
var endPageInView = this.props.value[this.props.value.length - 1];
|
|
elements = this.props.value.map(function (pageLink, i) {
|
|
var className = classNames('p-paginator-page p-paginator-element p-link', {
|
|
'p-paginator-page-start': pageLink === startPageInView,
|
|
'p-paginator-page-end': pageLink === endPageInView,
|
|
'p-highlight': pageLink - 1 === _this.props.page
|
|
});
|
|
var element = /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: className,
|
|
onClick: function onClick(e) {
|
|
return _this.onPageLinkClick(e, pageLink);
|
|
}
|
|
}, pageLink, /*#__PURE__*/React.createElement(Ripple, null));
|
|
|
|
if (_this.props.template) {
|
|
var defaultOptions = {
|
|
onClick: function onClick(e) {
|
|
return _this.onPageLinkClick(e, pageLink);
|
|
},
|
|
className: className,
|
|
view: {
|
|
startPage: startPageInView - 1,
|
|
endPage: endPageInView - 1
|
|
},
|
|
page: pageLink - 1,
|
|
currentPage: _this.props.page,
|
|
totalPages: _this.props.pageCount,
|
|
element: element,
|
|
props: _this.props
|
|
};
|
|
element = ObjectUtils.getJSXElement(_this.props.template, defaultOptions);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement(React.Fragment, {
|
|
key: pageLink
|
|
}, element);
|
|
});
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: "p-paginator-pages"
|
|
}, elements);
|
|
}
|
|
}]);
|
|
|
|
return PageLinks;
|
|
}(Component);
|
|
|
|
_defineProperty(PageLinks, "defaultProps", {
|
|
value: null,
|
|
page: null,
|
|
rows: null,
|
|
pageCount: null,
|
|
links: null,
|
|
template: null
|
|
});
|
|
|
|
function _createSuper$1K(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1K(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1K() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var DropdownItem = /*#__PURE__*/function (_Component) {
|
|
_inherits(DropdownItem, _Component);
|
|
|
|
var _super = _createSuper$1K(DropdownItem);
|
|
|
|
function DropdownItem(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, DropdownItem);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(DropdownItem, [{
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
if (this.props.onClick) {
|
|
this.props.onClick({
|
|
originalEvent: event,
|
|
option: this.props.option
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-dropdown-item', {
|
|
'p-highlight': this.props.selected,
|
|
'p-disabled': this.props.disabled,
|
|
'p-dropdown-item-empty': !this.props.label || this.props.label.length === 0
|
|
}, this.props.option.className);
|
|
var content = this.props.template ? ObjectUtils.getJSXElement(this.props.template, this.props.option) : this.props.label;
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
className: className,
|
|
onClick: this.onClick,
|
|
"aria-label": this.props.label,
|
|
key: this.props.label,
|
|
role: "option",
|
|
"aria-selected": this.props.selected
|
|
}, content, /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
}]);
|
|
|
|
return DropdownItem;
|
|
}(Component);
|
|
|
|
_defineProperty(DropdownItem, "defaultProps", {
|
|
option: null,
|
|
label: null,
|
|
template: null,
|
|
selected: false,
|
|
disabled: false,
|
|
onClick: null
|
|
});
|
|
|
|
function ownKeys$D(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$D(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$D(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$D(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$1J(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1J(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1J() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
var DropdownPanelComponent = /*#__PURE__*/function (_Component) {
|
|
_inherits(DropdownPanelComponent, _Component);
|
|
|
|
var _super = _createSuper$1J(DropdownPanelComponent);
|
|
|
|
function DropdownPanelComponent(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, DropdownPanelComponent);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onEnter = _this.onEnter.bind(_assertThisInitialized(_this));
|
|
_this.onEntered = _this.onEntered.bind(_assertThisInitialized(_this));
|
|
_this.onFilterInputChange = _this.onFilterInputChange.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(DropdownPanelComponent, [{
|
|
key: "onEnter",
|
|
value: function onEnter() {
|
|
var _this2 = this;
|
|
|
|
this.props.onEnter(function () {
|
|
if (_this2.virtualScrollerRef) {
|
|
var selectedIndex = _this2.props.getSelectedOptionIndex();
|
|
|
|
if (selectedIndex !== -1) {
|
|
_this2.virtualScrollerRef.scrollToIndex(selectedIndex);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onEntered",
|
|
value: function onEntered() {
|
|
var _this3 = this;
|
|
|
|
this.props.onEntered(function () {
|
|
if (_this3.props.filter && _this3.props.filterInputAutoFocus) {
|
|
_this3.filterInput.focus();
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onFilterInputChange",
|
|
value: function onFilterInputChange(event) {
|
|
if (this.virtualScrollerRef) {
|
|
this.virtualScrollerRef.scrollToIndex(0);
|
|
}
|
|
|
|
this.props.onFilterInputChange && this.props.onFilterInputChange(event);
|
|
}
|
|
}, {
|
|
key: "isEmptyFilter",
|
|
value: function isEmptyFilter() {
|
|
return !(this.props.visibleOptions && this.props.visibleOptions.length) && this.props.hasFilter();
|
|
}
|
|
}, {
|
|
key: "renderGroupChildren",
|
|
value: function renderGroupChildren(optionGroup) {
|
|
var _this4 = this;
|
|
|
|
var groupChildren = this.props.getOptionGroupChildren(optionGroup);
|
|
return groupChildren.map(function (option, j) {
|
|
var optionLabel = _this4.props.getOptionLabel(option);
|
|
|
|
var optionKey = j + '_' + _this4.props.getOptionRenderKey(option);
|
|
|
|
var disabled = _this4.props.isOptionDisabled(option);
|
|
|
|
return /*#__PURE__*/React.createElement(DropdownItem, {
|
|
key: optionKey,
|
|
label: optionLabel,
|
|
option: option,
|
|
template: _this4.props.itemTemplate,
|
|
selected: _this4.props.isSelected(option),
|
|
disabled: disabled,
|
|
onClick: _this4.props.onOptionClick
|
|
});
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderEmptyMessage",
|
|
value: function renderEmptyMessage(emptyMessage, isFilter) {
|
|
var message = ObjectUtils.getJSXElement(emptyMessage, this.props) || localeOption(isFilter ? 'emptyFilterMessage' : 'emptyMessage');
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
className: "p-dropdown-empty-message"
|
|
}, message);
|
|
}
|
|
}, {
|
|
key: "renderItem",
|
|
value: function renderItem(option, index) {
|
|
if (this.props.optionGroupLabel) {
|
|
var groupContent = this.props.optionGroupTemplate ? ObjectUtils.getJSXElement(this.props.optionGroupTemplate, option, index) : this.props.getOptionGroupLabel(option);
|
|
var groupChildrenContent = this.renderGroupChildren(option);
|
|
var key = index + '_' + this.props.getOptionGroupRenderKey(option);
|
|
return /*#__PURE__*/React.createElement(React.Fragment, {
|
|
key: key
|
|
}, /*#__PURE__*/React.createElement("li", {
|
|
className: "p-dropdown-item-group"
|
|
}, groupContent), groupChildrenContent);
|
|
} else {
|
|
var optionLabel = this.props.getOptionLabel(option);
|
|
var optionKey = index + '_' + this.props.getOptionRenderKey(option);
|
|
var disabled = this.props.isOptionDisabled(option);
|
|
return /*#__PURE__*/React.createElement(DropdownItem, {
|
|
key: optionKey,
|
|
label: optionLabel,
|
|
option: option,
|
|
template: this.props.itemTemplate,
|
|
selected: this.props.isSelected(option),
|
|
disabled: disabled,
|
|
onClick: this.props.onOptionClick
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderItems",
|
|
value: function renderItems() {
|
|
var _this5 = this;
|
|
|
|
if (this.props.visibleOptions && this.props.visibleOptions.length) {
|
|
return this.props.visibleOptions.map(function (option, index) {
|
|
return _this5.renderItem(option, index);
|
|
});
|
|
} else if (this.props.hasFilter()) {
|
|
return this.renderEmptyMessage(this.props.emptyFilterMessage, true);
|
|
}
|
|
|
|
return this.renderEmptyMessage(this.props.emptyMessage);
|
|
}
|
|
}, {
|
|
key: "renderFilterClearIcon",
|
|
value: function renderFilterClearIcon() {
|
|
var _this6 = this;
|
|
|
|
if (this.props.showFilterClear && this.props.filterValue) {
|
|
return /*#__PURE__*/React.createElement("i", {
|
|
className: "p-dropdown-filter-clear-icon pi pi-times",
|
|
onClick: function onClick() {
|
|
return _this6.props.onFilterClearIconClick(function () {
|
|
return _this6.filterInput.focus();
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderFilter",
|
|
value: function renderFilter() {
|
|
var _this7 = this;
|
|
|
|
if (this.props.filter) {
|
|
var clearIcon = this.renderFilterClearIcon();
|
|
var containerClassName = classNames('p-dropdown-filter-container', {
|
|
'p-dropdown-clearable-filter': !!clearIcon
|
|
});
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-dropdown-header"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: containerClassName
|
|
}, /*#__PURE__*/React.createElement("input", {
|
|
ref: function ref(el) {
|
|
return _this7.filterInput = el;
|
|
},
|
|
type: "text",
|
|
autoComplete: "off",
|
|
className: "p-dropdown-filter p-inputtext p-component",
|
|
placeholder: this.props.filterPlaceholder,
|
|
onKeyDown: this.props.onFilterInputKeyDown,
|
|
onChange: this.onFilterInputChange,
|
|
value: this.props.filterValue
|
|
}), clearIcon, /*#__PURE__*/React.createElement("i", {
|
|
className: "p-dropdown-filter-icon pi pi-search"
|
|
})));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
var _this8 = this;
|
|
|
|
if (this.props.virtualScrollerOptions) {
|
|
var virtualScrollerProps = _objectSpread$D(_objectSpread$D({}, this.props.virtualScrollerOptions), {
|
|
style: _objectSpread$D(_objectSpread$D({}, this.props.virtualScrollerOptions.style), {
|
|
height: this.props.scrollHeight
|
|
}),
|
|
className: classNames('p-dropdown-items-wrapper', this.props.virtualScrollerOptions.className),
|
|
items: this.props.visibleOptions,
|
|
onLazyLoad: function onLazyLoad(event) {
|
|
return _this8.props.virtualScrollerOptions.onLazyLoad(_objectSpread$D(_objectSpread$D({}, event), {
|
|
filter: _this8.props.filterValue
|
|
}));
|
|
},
|
|
itemTemplate: function itemTemplate(item, options) {
|
|
return item && _this8.renderItem(item, options.index);
|
|
},
|
|
contentTemplate: function contentTemplate(options) {
|
|
var className = classNames('p-dropdown-items', options.className);
|
|
var content = _this8.isEmptyFilter() ? _this8.renderEmptyMessage() : options.children;
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
ref: options.contentRef,
|
|
className: className,
|
|
role: "listbox"
|
|
}, content);
|
|
}
|
|
});
|
|
|
|
return /*#__PURE__*/React.createElement(VirtualScroller, _extends({
|
|
ref: function ref(el) {
|
|
return _this8.virtualScrollerRef = el;
|
|
}
|
|
}, virtualScrollerProps));
|
|
} else {
|
|
var items = this.renderItems();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-dropdown-items-wrapper",
|
|
style: {
|
|
maxHeight: this.props.scrollHeight || 'auto'
|
|
}
|
|
}, /*#__PURE__*/React.createElement("ul", {
|
|
className: "p-dropdown-items",
|
|
role: "listbox"
|
|
}, items));
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
var className = classNames('p-dropdown-panel p-component', this.props.panelClassName);
|
|
var filter = this.renderFilter();
|
|
var content = this.renderContent();
|
|
return /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.props.forwardRef,
|
|
classNames: "p-connected-overlay",
|
|
"in": this.props["in"],
|
|
timeout: {
|
|
enter: 120,
|
|
exit: 100
|
|
},
|
|
options: this.props.transitionOptions,
|
|
unmountOnExit: true,
|
|
onEnter: this.onEnter,
|
|
onEntering: this.props.onEntering,
|
|
onEntered: this.onEntered,
|
|
onExit: this.props.onExit,
|
|
onExited: this.props.onExited
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.props.forwardRef,
|
|
className: className,
|
|
style: this.props.panelStyle,
|
|
onClick: this.props.onClick
|
|
}, filter, content));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var element = this.renderElement();
|
|
return /*#__PURE__*/React.createElement(Portal, {
|
|
element: element,
|
|
appendTo: this.props.appendTo
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return DropdownPanelComponent;
|
|
}(Component);
|
|
|
|
var DropdownPanel = /*#__PURE__*/React.forwardRef(function (props, ref) {
|
|
return /*#__PURE__*/React.createElement(DropdownPanelComponent, _extends({
|
|
forwardRef: ref
|
|
}, props));
|
|
});
|
|
|
|
function ownKeys$C(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$C(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$C(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$C(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createForOfIteratorHelper$c(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$c(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$c(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$c(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$c(o, minLen); }
|
|
|
|
function _arrayLikeToArray$c(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 _createSuper$1I(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1I(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1I() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Dropdown = /*#__PURE__*/function (_Component) {
|
|
_inherits(Dropdown, _Component);
|
|
|
|
var _super = _createSuper$1I(Dropdown);
|
|
|
|
function Dropdown(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Dropdown);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
filter: '',
|
|
focused: false,
|
|
overlayVisible: false
|
|
};
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onInputFocus = _this.onInputFocus.bind(_assertThisInitialized(_this));
|
|
_this.onInputBlur = _this.onInputBlur.bind(_assertThisInitialized(_this));
|
|
_this.onInputKeyDown = _this.onInputKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onEditableInputChange = _this.onEditableInputChange.bind(_assertThisInitialized(_this));
|
|
_this.onEditableInputFocus = _this.onEditableInputFocus.bind(_assertThisInitialized(_this));
|
|
_this.onOptionClick = _this.onOptionClick.bind(_assertThisInitialized(_this));
|
|
_this.onFilterInputChange = _this.onFilterInputChange.bind(_assertThisInitialized(_this));
|
|
_this.onFilterInputKeyDown = _this.onFilterInputKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onFilterClearIconClick = _this.onFilterClearIconClick.bind(_assertThisInitialized(_this));
|
|
_this.onPanelClick = _this.onPanelClick.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEnter = _this.onOverlayEnter.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEntered = _this.onOverlayEntered.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExit = _this.onOverlayExit.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExited = _this.onOverlayExited.bind(_assertThisInitialized(_this));
|
|
_this.resetFilter = _this.resetFilter.bind(_assertThisInitialized(_this));
|
|
_this.clear = _this.clear.bind(_assertThisInitialized(_this));
|
|
_this.hasFilter = _this.hasFilter.bind(_assertThisInitialized(_this));
|
|
_this.getOptionLabel = _this.getOptionLabel.bind(_assertThisInitialized(_this));
|
|
_this.getOptionRenderKey = _this.getOptionRenderKey.bind(_assertThisInitialized(_this));
|
|
_this.isOptionDisabled = _this.isOptionDisabled.bind(_assertThisInitialized(_this));
|
|
_this.getOptionGroupChildren = _this.getOptionGroupChildren.bind(_assertThisInitialized(_this));
|
|
_this.getOptionGroupLabel = _this.getOptionGroupLabel.bind(_assertThisInitialized(_this));
|
|
_this.getOptionGroupRenderKey = _this.getOptionGroupRenderKey.bind(_assertThisInitialized(_this));
|
|
_this.getSelectedOptionIndex = _this.getSelectedOptionIndex.bind(_assertThisInitialized(_this));
|
|
_this.isSelected = _this.isSelected.bind(_assertThisInitialized(_this));
|
|
_this.overlayRef = /*#__PURE__*/createRef();
|
|
_this.inputRef = /*#__PURE__*/createRef(_this.props.inputRef);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Dropdown, [{
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
if (this.props.disabled) {
|
|
return;
|
|
}
|
|
|
|
if (DomHandler.hasClass(event.target, 'p-dropdown-clear-icon') || event.target.tagName === 'INPUT') {
|
|
return;
|
|
} else if (!this.overlayRef.current || !(this.overlayRef.current && this.overlayRef.current.contains(event.target))) {
|
|
this.focusInput.focus();
|
|
|
|
if (this.state.overlayVisible) {
|
|
this.hideOverlay();
|
|
} else {
|
|
this.showOverlay();
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onInputFocus",
|
|
value: function onInputFocus(event) {
|
|
var _this2 = this;
|
|
|
|
event.persist();
|
|
|
|
if (this.props.showOnFocus && !this.state.overlayVisible) {
|
|
this.showOverlay();
|
|
}
|
|
|
|
this.setState({
|
|
focused: true
|
|
}, function () {
|
|
if (_this2.props.onFocus) {
|
|
_this2.props.onFocus(event);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onInputBlur",
|
|
value: function onInputBlur(event) {
|
|
var _this3 = this;
|
|
|
|
event.persist();
|
|
this.setState({
|
|
focused: false
|
|
}, function () {
|
|
if (_this3.props.onBlur) {
|
|
_this3.props.onBlur(event);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onPanelClick",
|
|
value: function onPanelClick(event) {
|
|
OverlayService.emit('overlay-click', {
|
|
originalEvent: event,
|
|
target: this.container
|
|
});
|
|
}
|
|
}, {
|
|
key: "onInputKeyDown",
|
|
value: function onInputKeyDown(event) {
|
|
switch (event.which) {
|
|
//down
|
|
case 40:
|
|
this.onDownKey(event);
|
|
break;
|
|
//up
|
|
|
|
case 38:
|
|
this.onUpKey(event);
|
|
break;
|
|
//space
|
|
|
|
case 32:
|
|
if (this.state.overlayVisible) this.hideOverlay();else this.showOverlay();
|
|
event.preventDefault();
|
|
break;
|
|
//enter
|
|
|
|
case 13:
|
|
this.hideOverlay();
|
|
event.preventDefault();
|
|
break;
|
|
//escape and tab
|
|
|
|
case 27:
|
|
case 9:
|
|
this.hideOverlay();
|
|
break;
|
|
|
|
default:
|
|
this.search(event);
|
|
break;
|
|
}
|
|
}
|
|
}, {
|
|
key: "onFilterInputKeyDown",
|
|
value: function onFilterInputKeyDown(event) {
|
|
switch (event.which) {
|
|
//down
|
|
case 40:
|
|
this.onDownKey(event);
|
|
break;
|
|
//up
|
|
|
|
case 38:
|
|
this.onUpKey(event);
|
|
break;
|
|
//enter and escape
|
|
|
|
case 13:
|
|
case 27:
|
|
this.hideOverlay();
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
}
|
|
}, {
|
|
key: "onUpKey",
|
|
value: function onUpKey(event) {
|
|
var visibleOptions = this.getVisibleOptions();
|
|
|
|
if (visibleOptions) {
|
|
var prevOption = this.findPrevOption(this.getSelectedOptionIndex());
|
|
|
|
if (prevOption) {
|
|
this.selectItem({
|
|
originalEvent: event,
|
|
option: prevOption
|
|
});
|
|
}
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onDownKey",
|
|
value: function onDownKey(event) {
|
|
var visibleOptions = this.getVisibleOptions();
|
|
|
|
if (visibleOptions) {
|
|
if (!this.state.overlayVisible && event.altKey) {
|
|
this.showOverlay();
|
|
} else {
|
|
var nextOption = this.findNextOption(this.getSelectedOptionIndex());
|
|
|
|
if (nextOption) {
|
|
this.selectItem({
|
|
originalEvent: event,
|
|
option: nextOption
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "findNextOption",
|
|
value: function findNextOption(index) {
|
|
var visibleOptions = this.getVisibleOptions();
|
|
|
|
if (this.props.optionGroupLabel) {
|
|
var groupIndex = index === -1 ? 0 : index.group;
|
|
var optionIndex = index === -1 ? -1 : index.option;
|
|
var option = this.findNextOptionInList(this.getOptionGroupChildren(visibleOptions[groupIndex]), optionIndex);
|
|
if (option) return option;else if (groupIndex + 1 !== visibleOptions.length) return this.findNextOption({
|
|
group: groupIndex + 1,
|
|
option: -1
|
|
});else return null;
|
|
} else {
|
|
return this.findNextOptionInList(visibleOptions, index);
|
|
}
|
|
}
|
|
}, {
|
|
key: "findNextOptionInList",
|
|
value: function findNextOptionInList(list, index) {
|
|
var i = index + 1;
|
|
|
|
if (i === list.length) {
|
|
return null;
|
|
}
|
|
|
|
var option = list[i];
|
|
if (this.isOptionDisabled(option)) return this.findNextOptionInList(i);else return option;
|
|
}
|
|
}, {
|
|
key: "findPrevOption",
|
|
value: function findPrevOption(index) {
|
|
if (index === -1) {
|
|
return null;
|
|
}
|
|
|
|
var visibleOptions = this.getVisibleOptions();
|
|
|
|
if (this.props.optionGroupLabel) {
|
|
var groupIndex = index.group;
|
|
var optionIndex = index.option;
|
|
var option = this.findPrevOptionInList(this.getOptionGroupChildren(visibleOptions[groupIndex]), optionIndex);
|
|
if (option) return option;else if (groupIndex > 0) return this.findPrevOption({
|
|
group: groupIndex - 1,
|
|
option: this.getOptionGroupChildren(visibleOptions[groupIndex - 1]).length
|
|
});else return null;
|
|
} else {
|
|
return this.findPrevOptionInList(visibleOptions, index);
|
|
}
|
|
}
|
|
}, {
|
|
key: "findPrevOptionInList",
|
|
value: function findPrevOptionInList(list, index) {
|
|
var i = index - 1;
|
|
|
|
if (i < 0) {
|
|
return null;
|
|
}
|
|
|
|
var option = list[i];
|
|
if (this.isOptionDisabled(option)) return this.findPrevOption(i);else return option;
|
|
}
|
|
}, {
|
|
key: "search",
|
|
value: function search(event) {
|
|
var _this4 = this;
|
|
|
|
if (this.searchTimeout) {
|
|
clearTimeout(this.searchTimeout);
|
|
}
|
|
|
|
var _char = event.key;
|
|
this.previousSearchChar = this.currentSearchChar;
|
|
this.currentSearchChar = _char;
|
|
if (this.previousSearchChar === this.currentSearchChar) this.searchValue = this.currentSearchChar;else this.searchValue = this.searchValue ? this.searchValue + _char : _char;
|
|
|
|
if (this.searchValue) {
|
|
var searchIndex = this.getSelectedOptionIndex();
|
|
var newOption = this.props.optionGroupLabel ? this.searchOptionInGroup(searchIndex) : this.searchOption(++searchIndex);
|
|
|
|
if (newOption) {
|
|
this.selectItem({
|
|
originalEvent: event,
|
|
option: newOption
|
|
});
|
|
this.selectedOptionUpdated = true;
|
|
}
|
|
}
|
|
|
|
this.searchTimeout = setTimeout(function () {
|
|
_this4.searchValue = null;
|
|
}, 250);
|
|
}
|
|
}, {
|
|
key: "searchOption",
|
|
value: function searchOption(index) {
|
|
var option;
|
|
|
|
if (this.searchValue) {
|
|
var visibleOptions = this.getVisibleOptions();
|
|
option = this.searchOptionInRange(index, visibleOptions.length);
|
|
|
|
if (!option) {
|
|
option = this.searchOptionInRange(0, index);
|
|
}
|
|
}
|
|
|
|
return option;
|
|
}
|
|
}, {
|
|
key: "searchOptionInRange",
|
|
value: function searchOptionInRange(start, end) {
|
|
var visibleOptions = this.getVisibleOptions();
|
|
|
|
for (var i = start; i < end; i++) {
|
|
var opt = visibleOptions[i];
|
|
|
|
if (this.matchesSearchValue(opt)) {
|
|
return opt;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "searchOptionInGroup",
|
|
value: function searchOptionInGroup(index) {
|
|
var searchIndex = index === -1 ? {
|
|
group: 0,
|
|
option: -1
|
|
} : index;
|
|
var visibleOptions = this.getVisibleOptions();
|
|
|
|
for (var i = searchIndex.group; i < visibleOptions.length; i++) {
|
|
var groupOptions = this.getOptionGroupChildren(visibleOptions[i]);
|
|
|
|
for (var j = searchIndex.group === i ? searchIndex.option + 1 : 0; j < groupOptions.length; j++) {
|
|
if (this.matchesSearchValue(groupOptions[j])) {
|
|
return groupOptions[j];
|
|
}
|
|
}
|
|
}
|
|
|
|
for (var _i = 0; _i <= searchIndex.group; _i++) {
|
|
var _groupOptions = this.getOptionGroupChildren(visibleOptions[_i]);
|
|
|
|
for (var _j = 0; _j < (searchIndex.group === _i ? searchIndex.option : _groupOptions.length); _j++) {
|
|
if (this.matchesSearchValue(_groupOptions[_j])) {
|
|
return _groupOptions[_j];
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "matchesSearchValue",
|
|
value: function matchesSearchValue(option) {
|
|
var label = this.getOptionLabel(option).toLocaleLowerCase(this.props.filterLocale);
|
|
return label.startsWith(this.searchValue.toLocaleLowerCase(this.props.filterLocale));
|
|
}
|
|
}, {
|
|
key: "onEditableInputChange",
|
|
value: function onEditableInputChange(event) {
|
|
if (this.props.onChange) {
|
|
this.props.onChange({
|
|
originalEvent: event.originalEvent,
|
|
value: event.target.value,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: event.target.value
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onEditableInputFocus",
|
|
value: function onEditableInputFocus(event) {
|
|
var _this5 = this;
|
|
|
|
event.persist();
|
|
this.setState({
|
|
focused: true
|
|
}, function () {
|
|
_this5.hideOverlay();
|
|
|
|
if (_this5.props.onFocus) {
|
|
_this5.props.onFocus(event);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onOptionClick",
|
|
value: function onOptionClick(event) {
|
|
var option = event.option;
|
|
|
|
if (!option.disabled) {
|
|
this.selectItem(event);
|
|
this.focusInput.focus();
|
|
}
|
|
|
|
this.hideOverlay();
|
|
}
|
|
}, {
|
|
key: "onFilterInputChange",
|
|
value: function onFilterInputChange(event) {
|
|
var _this6 = this;
|
|
|
|
var filter = event.target.value;
|
|
this.setState({
|
|
filter: filter
|
|
}, function () {
|
|
if (_this6.props.onFilter) {
|
|
_this6.props.onFilter({
|
|
originalEvent: event,
|
|
filter: filter
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onFilterClearIconClick",
|
|
value: function onFilterClearIconClick(callback) {
|
|
this.resetFilter(callback);
|
|
}
|
|
}, {
|
|
key: "resetFilter",
|
|
value: function resetFilter(callback) {
|
|
var _this7 = this;
|
|
|
|
var filter = '';
|
|
this.setState({
|
|
filter: filter
|
|
}, function () {
|
|
_this7.props.onFilter && _this7.props.onFilter({
|
|
filter: filter
|
|
});
|
|
callback && callback();
|
|
});
|
|
}
|
|
}, {
|
|
key: "clear",
|
|
value: function clear(event) {
|
|
if (this.props.onChange) {
|
|
this.props.onChange({
|
|
originalEvent: event,
|
|
value: undefined,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: undefined
|
|
}
|
|
});
|
|
}
|
|
|
|
this.updateEditableLabel();
|
|
}
|
|
}, {
|
|
key: "selectItem",
|
|
value: function selectItem(event) {
|
|
var currentSelectedOption = this.getSelectedOption();
|
|
|
|
if (currentSelectedOption !== event.option) {
|
|
this.updateEditableLabel(event.option);
|
|
var optionValue = this.getOptionValue(event.option);
|
|
|
|
if (this.props.onChange) {
|
|
this.props.onChange({
|
|
originalEvent: event.originalEvent,
|
|
value: optionValue,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: optionValue
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "getSelectedOption",
|
|
value: function getSelectedOption() {
|
|
var index = this.getSelectedOptionIndex();
|
|
var visibleOptions = this.getVisibleOptions();
|
|
return index !== -1 ? this.props.optionGroupLabel ? this.getOptionGroupChildren(visibleOptions[index.group])[index.option] : visibleOptions[index] : null;
|
|
}
|
|
}, {
|
|
key: "getSelectedOptionIndex",
|
|
value: function getSelectedOptionIndex() {
|
|
var visibleOptions = this.getVisibleOptions();
|
|
|
|
if (this.props.value != null && visibleOptions) {
|
|
if (this.props.optionGroupLabel) {
|
|
for (var i = 0; i < visibleOptions.length; i++) {
|
|
var selectedOptionIndex = this.findOptionIndexInList(this.props.value, this.getOptionGroupChildren(visibleOptions[i]));
|
|
|
|
if (selectedOptionIndex !== -1) {
|
|
return {
|
|
group: i,
|
|
option: selectedOptionIndex
|
|
};
|
|
}
|
|
}
|
|
} else {
|
|
return this.findOptionIndexInList(this.props.value, visibleOptions);
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
}, {
|
|
key: "findOptionIndexInList",
|
|
value: function findOptionIndexInList(value, list) {
|
|
var key = this.equalityKey();
|
|
|
|
for (var i = 0; i < list.length; i++) {
|
|
if (ObjectUtils.equals(value, this.getOptionValue(list[i]), key)) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
}, {
|
|
key: "isSelected",
|
|
value: function isSelected(option) {
|
|
return ObjectUtils.equals(this.props.value, this.getOptionValue(option), this.equalityKey());
|
|
}
|
|
}, {
|
|
key: "equalityKey",
|
|
value: function equalityKey() {
|
|
return this.props.optionValue ? null : this.props.dataKey;
|
|
}
|
|
}, {
|
|
key: "showOverlay",
|
|
value: function showOverlay() {
|
|
this.setState({
|
|
overlayVisible: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "hideOverlay",
|
|
value: function hideOverlay() {
|
|
this.setState({
|
|
overlayVisible: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "onOverlayEnter",
|
|
value: function onOverlayEnter(callback) {
|
|
ZIndexUtils.set('overlay', this.overlayRef.current, PrimeReact.autoZIndex, PrimeReact.zIndex['overlay']);
|
|
this.alignOverlay();
|
|
callback && callback();
|
|
}
|
|
}, {
|
|
key: "onOverlayEntered",
|
|
value: function onOverlayEntered(callback) {
|
|
callback && callback();
|
|
this.bindDocumentClickListener();
|
|
this.bindScrollListener();
|
|
this.bindResizeListener();
|
|
this.props.onShow && this.props.onShow();
|
|
}
|
|
}, {
|
|
key: "onOverlayExit",
|
|
value: function onOverlayExit() {
|
|
this.unbindDocumentClickListener();
|
|
this.unbindScrollListener();
|
|
this.unbindResizeListener();
|
|
}
|
|
}, {
|
|
key: "onOverlayExited",
|
|
value: function onOverlayExited() {
|
|
if (this.props.filter && this.props.resetFilterOnHide) {
|
|
this.resetFilter();
|
|
}
|
|
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
this.props.onHide && this.props.onHide();
|
|
}
|
|
}, {
|
|
key: "alignOverlay",
|
|
value: function alignOverlay() {
|
|
DomHandler.alignOverlay(this.overlayRef.current, this.input.parentElement, this.props.appendTo || PrimeReact.appendTo);
|
|
}
|
|
}, {
|
|
key: "scrollInView",
|
|
value: function scrollInView() {
|
|
var highlightItem = DomHandler.findSingle(this.overlayRef.current, 'li.p-highlight');
|
|
|
|
if (highlightItem) {
|
|
highlightItem.scrollIntoView({
|
|
block: 'nearest',
|
|
inline: 'start'
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindDocumentClickListener",
|
|
value: function bindDocumentClickListener() {
|
|
var _this8 = this;
|
|
|
|
if (!this.documentClickListener) {
|
|
this.documentClickListener = function (event) {
|
|
if (_this8.state.overlayVisible && _this8.isOutsideClicked(event)) {
|
|
_this8.hideOverlay();
|
|
}
|
|
};
|
|
|
|
document.addEventListener('click', this.documentClickListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentClickListener",
|
|
value: function unbindDocumentClickListener() {
|
|
if (this.documentClickListener) {
|
|
document.removeEventListener('click', this.documentClickListener);
|
|
this.documentClickListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindScrollListener",
|
|
value: function bindScrollListener() {
|
|
var _this9 = this;
|
|
|
|
if (!this.scrollHandler) {
|
|
this.scrollHandler = new ConnectedOverlayScrollHandler(this.container, function () {
|
|
if (_this9.state.overlayVisible) {
|
|
_this9.hideOverlay();
|
|
}
|
|
});
|
|
}
|
|
|
|
this.scrollHandler.bindScrollListener();
|
|
}
|
|
}, {
|
|
key: "unbindScrollListener",
|
|
value: function unbindScrollListener() {
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.unbindScrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindResizeListener",
|
|
value: function bindResizeListener() {
|
|
var _this10 = this;
|
|
|
|
if (!this.resizeListener) {
|
|
this.resizeListener = function () {
|
|
if (_this10.state.overlayVisible && !DomHandler.isTouchDevice()) {
|
|
_this10.hideOverlay();
|
|
}
|
|
};
|
|
|
|
window.addEventListener('resize', this.resizeListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindResizeListener",
|
|
value: function unbindResizeListener() {
|
|
if (this.resizeListener) {
|
|
window.removeEventListener('resize', this.resizeListener);
|
|
this.resizeListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "isOutsideClicked",
|
|
value: function isOutsideClicked(event) {
|
|
return this.container && !(this.container.isSameNode(event.target) || this.isClearClicked(event) || this.container.contains(event.target) || this.overlayRef && this.overlayRef.current.contains(event.target));
|
|
}
|
|
}, {
|
|
key: "isClearClicked",
|
|
value: function isClearClicked(event) {
|
|
return DomHandler.hasClass(event.target, 'p-dropdown-clear-icon') || DomHandler.hasClass(event.target, 'p-dropdown-filter-clear-icon');
|
|
}
|
|
}, {
|
|
key: "updateEditableLabel",
|
|
value: function updateEditableLabel(option) {
|
|
if (this.input) {
|
|
this.input.value = option ? this.getOptionLabel(option) : this.props.value || '';
|
|
}
|
|
}
|
|
}, {
|
|
key: "hasFilter",
|
|
value: function hasFilter() {
|
|
return this.state.filter && this.state.filter.trim().length > 0;
|
|
}
|
|
}, {
|
|
key: "getOptionLabel",
|
|
value: function getOptionLabel(option) {
|
|
return this.props.optionLabel ? ObjectUtils.resolveFieldData(option, this.props.optionLabel) : option && option['label'] !== undefined ? option['label'] : option;
|
|
}
|
|
}, {
|
|
key: "getOptionValue",
|
|
value: function getOptionValue(option) {
|
|
return this.props.optionValue ? ObjectUtils.resolveFieldData(option, this.props.optionValue) : option && option['value'] !== undefined ? option['value'] : option;
|
|
}
|
|
}, {
|
|
key: "getOptionRenderKey",
|
|
value: function getOptionRenderKey(option) {
|
|
return this.props.dataKey ? ObjectUtils.resolveFieldData(option, this.props.dataKey) : this.getOptionLabel(option);
|
|
}
|
|
}, {
|
|
key: "isOptionDisabled",
|
|
value: function isOptionDisabled(option) {
|
|
if (this.props.optionDisabled) {
|
|
return ObjectUtils.isFunction(this.props.optionDisabled) ? this.props.optionDisabled(option) : ObjectUtils.resolveFieldData(option, this.props.optionDisabled);
|
|
}
|
|
|
|
return option && option['disabled'] !== undefined ? option['disabled'] : false;
|
|
}
|
|
}, {
|
|
key: "getOptionGroupRenderKey",
|
|
value: function getOptionGroupRenderKey(optionGroup) {
|
|
return ObjectUtils.resolveFieldData(optionGroup, this.props.optionGroupLabel);
|
|
}
|
|
}, {
|
|
key: "getOptionGroupLabel",
|
|
value: function getOptionGroupLabel(optionGroup) {
|
|
return ObjectUtils.resolveFieldData(optionGroup, this.props.optionGroupLabel);
|
|
}
|
|
}, {
|
|
key: "getOptionGroupChildren",
|
|
value: function getOptionGroupChildren(optionGroup) {
|
|
return ObjectUtils.resolveFieldData(optionGroup, this.props.optionGroupChildren);
|
|
}
|
|
}, {
|
|
key: "checkValidity",
|
|
value: function checkValidity() {
|
|
if (this.inputRef.current) {
|
|
return this.inputRef.current.checkValidity();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "isLazy",
|
|
value: function isLazy() {
|
|
return this.props.virtualScrollerOptions && this.props.virtualScrollerOptions.lazy;
|
|
}
|
|
}, {
|
|
key: "getVisibleOptions",
|
|
value: function getVisibleOptions() {
|
|
if (this.hasFilter() && !this.isLazy()) {
|
|
var filterValue = this.state.filter.trim().toLocaleLowerCase(this.props.filterLocale);
|
|
var searchFields = this.props.filterBy ? this.props.filterBy.split(',') : [this.props.optionLabel || 'label'];
|
|
|
|
if (this.props.optionGroupLabel) {
|
|
var filteredGroups = [];
|
|
|
|
var _iterator = _createForOfIteratorHelper$c(this.props.options),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var optgroup = _step.value;
|
|
var filteredSubOptions = FilterService.filter(this.getOptionGroupChildren(optgroup), searchFields, filterValue, this.props.filterMatchMode, this.props.filterLocale);
|
|
|
|
if (filteredSubOptions && filteredSubOptions.length) {
|
|
filteredGroups.push(_objectSpread$C(_objectSpread$C({}, optgroup), {
|
|
items: filteredSubOptions
|
|
}));
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
|
|
return filteredGroups;
|
|
} else {
|
|
return FilterService.filter(this.props.options, searchFields, filterValue, this.props.filterMatchMode, this.props.filterLocale);
|
|
}
|
|
} else {
|
|
return this.props.options;
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateInputField",
|
|
value: function updateInputField() {
|
|
if (this.props.editable && this.input) {
|
|
var selectedOption = this.getSelectedOption();
|
|
var label = selectedOption ? this.getOptionLabel(selectedOption) : null;
|
|
var value = label || this.props.value || '';
|
|
this.input.value = value;
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateInputRef",
|
|
value: function updateInputRef() {
|
|
var ref = this.props.inputRef;
|
|
|
|
if (ref) {
|
|
if (typeof ref === 'function') {
|
|
ref(this.inputRef.current);
|
|
} else {
|
|
ref.current = this.inputRef.current;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.updateInputRef();
|
|
|
|
if (this.props.autoFocus && this.focusInput) {
|
|
this.focusInput.focus();
|
|
}
|
|
|
|
if (this.props.tooltip) {
|
|
this.renderTooltip();
|
|
}
|
|
|
|
this.updateInputField();
|
|
|
|
if (this.inputRef.current) {
|
|
this.inputRef.current.selectedIndex = 1;
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.unbindDocumentClickListener();
|
|
this.unbindResizeListener();
|
|
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.destroy();
|
|
this.scrollHandler = null;
|
|
}
|
|
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
|
|
if (this.hideTimeout) {
|
|
clearTimeout(this.hideTimeout);
|
|
this.hideTimeout = null;
|
|
}
|
|
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (this.state.overlayVisible) {
|
|
if (this.props.filter) {
|
|
this.alignOverlay();
|
|
}
|
|
|
|
if (prevProps.value !== this.props.value) {
|
|
this.scrollInView();
|
|
}
|
|
}
|
|
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$C({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
}
|
|
|
|
if (this.state.filter && (!this.props.options || this.props.options.length === 0)) {
|
|
this.setState({
|
|
filter: ''
|
|
});
|
|
}
|
|
|
|
this.updateInputField();
|
|
|
|
if (this.inputRef.current) {
|
|
this.inputRef.current.selectedIndex = 1;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderHiddenSelect",
|
|
value: function renderHiddenSelect(selectedOption) {
|
|
var placeHolderOption = /*#__PURE__*/React.createElement("option", {
|
|
value: ""
|
|
}, this.props.placeholder);
|
|
var option = selectedOption ? /*#__PURE__*/React.createElement("option", {
|
|
value: selectedOption.value
|
|
}, this.getOptionLabel(selectedOption)) : null;
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-hidden-accessible p-dropdown-hidden-select"
|
|
}, /*#__PURE__*/React.createElement("select", {
|
|
ref: this.inputRef,
|
|
required: this.props.required,
|
|
name: this.props.name,
|
|
tabIndex: -1,
|
|
"aria-hidden": "true"
|
|
}, placeHolderOption, option));
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.container,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderKeyboardHelper",
|
|
value: function renderKeyboardHelper() {
|
|
var _this11 = this;
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-hidden-accessible"
|
|
}, /*#__PURE__*/React.createElement("input", {
|
|
ref: function ref(el) {
|
|
return _this11.focusInput = el;
|
|
},
|
|
id: this.props.inputId,
|
|
type: "text",
|
|
readOnly: true,
|
|
"aria-haspopup": "listbox",
|
|
onFocus: this.onInputFocus,
|
|
onBlur: this.onInputBlur,
|
|
onKeyDown: this.onInputKeyDown,
|
|
disabled: this.props.disabled,
|
|
tabIndex: this.props.tabIndex,
|
|
"aria-label": this.props.ariaLabel,
|
|
"aria-labelledby": this.props.ariaLabelledBy
|
|
}));
|
|
}
|
|
}, {
|
|
key: "renderLabel",
|
|
value: function renderLabel(selectedOption) {
|
|
var _this12 = this;
|
|
|
|
var label = ObjectUtils.isNotEmpty(selectedOption) ? this.getOptionLabel(selectedOption) : null;
|
|
|
|
if (this.props.editable) {
|
|
var value = label || this.props.value || '';
|
|
return /*#__PURE__*/React.createElement("input", {
|
|
ref: function ref(el) {
|
|
return _this12.input = el;
|
|
},
|
|
type: "text",
|
|
defaultValue: value,
|
|
className: "p-dropdown-label p-inputtext",
|
|
disabled: this.props.disabled,
|
|
placeholder: this.props.placeholder,
|
|
maxLength: this.props.maxLength,
|
|
onInput: this.onEditableInputChange,
|
|
onFocus: this.onEditableInputFocus,
|
|
onBlur: this.onInputBlur,
|
|
"aria-label": this.props.ariaLabel,
|
|
"aria-labelledby": this.props.ariaLabelledBy,
|
|
"aria-haspopup": "listbox"
|
|
});
|
|
} else {
|
|
var className = classNames('p-dropdown-label p-inputtext', {
|
|
'p-placeholder': label === null && this.props.placeholder,
|
|
'p-dropdown-label-empty': label === null && !this.props.placeholder
|
|
});
|
|
var content = this.props.valueTemplate ? ObjectUtils.getJSXElement(this.props.valueTemplate, selectedOption, this.props) : label || this.props.placeholder || 'empty';
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
ref: function ref(el) {
|
|
return _this12.input = el;
|
|
},
|
|
className: className
|
|
}, content);
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderClearIcon",
|
|
value: function renderClearIcon() {
|
|
if (this.props.value != null && this.props.showClear && !this.props.disabled) {
|
|
return /*#__PURE__*/React.createElement("i", {
|
|
className: "p-dropdown-clear-icon pi pi-times",
|
|
onClick: this.clear
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderDropdownIcon",
|
|
value: function renderDropdownIcon() {
|
|
var _this13 = this;
|
|
|
|
var iconClassName = classNames('p-dropdown-trigger-icon p-clickable', this.props.dropdownIcon);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this13.trigger = el;
|
|
},
|
|
className: "p-dropdown-trigger",
|
|
role: "button",
|
|
"aria-haspopup": "listbox",
|
|
"aria-expanded": this.state.overlayVisible
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
}));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this14 = this;
|
|
|
|
var className = classNames('p-dropdown p-component p-inputwrapper', this.props.className, {
|
|
'p-disabled': this.props.disabled,
|
|
'p-focus': this.state.focused,
|
|
'p-dropdown-clearable': this.props.showClear && !this.props.disabled,
|
|
'p-inputwrapper-filled': this.props.value,
|
|
'p-inputwrapper-focus': this.state.focused || this.state.overlayVisible
|
|
});
|
|
var visibleOptions = this.getVisibleOptions();
|
|
var selectedOption = this.getSelectedOption();
|
|
var appendTo = this.props.appendTo || PrimeReact.appendTo;
|
|
var hiddenSelect = this.renderHiddenSelect(selectedOption);
|
|
var keyboardHelper = this.renderKeyboardHelper();
|
|
var labelElement = this.renderLabel(selectedOption);
|
|
var dropdownIcon = this.renderDropdownIcon();
|
|
var clearIcon = this.renderClearIcon();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
ref: function ref(el) {
|
|
return _this14.container = el;
|
|
},
|
|
className: className,
|
|
style: this.props.style,
|
|
onClick: this.onClick,
|
|
onMouseDown: this.props.onMouseDown,
|
|
onContextMenu: this.props.onContextMenu
|
|
}, keyboardHelper, hiddenSelect, labelElement, clearIcon, dropdownIcon, /*#__PURE__*/React.createElement(DropdownPanel, _extends({
|
|
ref: this.overlayRef,
|
|
visibleOptions: visibleOptions
|
|
}, this.props, {
|
|
appendTo: appendTo,
|
|
onClick: this.onPanelClick,
|
|
onOptionClick: this.onOptionClick,
|
|
filterValue: this.state.filter,
|
|
hasFilter: this.hasFilter,
|
|
onFilterClearIconClick: this.onFilterClearIconClick,
|
|
onFilterInputKeyDown: this.onFilterInputKeyDown,
|
|
onFilterInputChange: this.onFilterInputChange,
|
|
getOptionLabel: this.getOptionLabel,
|
|
getOptionRenderKey: this.getOptionRenderKey,
|
|
isOptionDisabled: this.isOptionDisabled,
|
|
getOptionGroupChildren: this.getOptionGroupChildren,
|
|
getOptionGroupLabel: this.getOptionGroupLabel,
|
|
getOptionGroupRenderKey: this.getOptionGroupRenderKey,
|
|
isSelected: this.isSelected,
|
|
getSelectedOptionIndex: this.getSelectedOptionIndex,
|
|
"in": this.state.overlayVisible,
|
|
onEnter: this.onOverlayEnter,
|
|
onEntered: this.onOverlayEntered,
|
|
onExit: this.onOverlayExit,
|
|
onExited: this.onOverlayExited
|
|
})));
|
|
}
|
|
}]);
|
|
|
|
return Dropdown;
|
|
}(Component);
|
|
|
|
_defineProperty(Dropdown, "defaultProps", {
|
|
id: null,
|
|
inputRef: null,
|
|
name: null,
|
|
value: null,
|
|
options: null,
|
|
optionLabel: null,
|
|
optionValue: null,
|
|
optionDisabled: null,
|
|
optionGroupLabel: null,
|
|
optionGroupChildren: null,
|
|
optionGroupTemplate: null,
|
|
valueTemplate: null,
|
|
itemTemplate: null,
|
|
style: null,
|
|
className: null,
|
|
virtualScrollerOptions: null,
|
|
scrollHeight: '200px',
|
|
filter: false,
|
|
filterBy: null,
|
|
filterMatchMode: 'contains',
|
|
filterPlaceholder: null,
|
|
filterLocale: undefined,
|
|
emptyMessage: null,
|
|
emptyFilterMessage: null,
|
|
editable: false,
|
|
placeholder: null,
|
|
required: false,
|
|
disabled: false,
|
|
appendTo: null,
|
|
tabIndex: null,
|
|
autoFocus: false,
|
|
filterInputAutoFocus: true,
|
|
resetFilterOnHide: false,
|
|
showFilterClear: false,
|
|
panelClassName: null,
|
|
panelStyle: null,
|
|
dataKey: null,
|
|
inputId: null,
|
|
showClear: false,
|
|
maxLength: null,
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
ariaLabel: null,
|
|
ariaLabelledBy: null,
|
|
transitionOptions: null,
|
|
dropdownIcon: 'pi pi-chevron-down',
|
|
showOnFocus: false,
|
|
onChange: null,
|
|
onFocus: null,
|
|
onBlur: null,
|
|
onMouseDown: null,
|
|
onContextMenu: null,
|
|
onShow: null,
|
|
onHide: null,
|
|
onFilter: null
|
|
});
|
|
|
|
function _createSuper$1H(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1H(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1H() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var RowsPerPageDropdown = /*#__PURE__*/function (_Component) {
|
|
_inherits(RowsPerPageDropdown, _Component);
|
|
|
|
var _super = _createSuper$1H(RowsPerPageDropdown);
|
|
|
|
function RowsPerPageDropdown() {
|
|
_classCallCheck(this, RowsPerPageDropdown);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(RowsPerPageDropdown, [{
|
|
key: "hasOptions",
|
|
value: function hasOptions() {
|
|
return this.props.options && this.props.options.length > 0;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var hasOptions = this.hasOptions();
|
|
var options = hasOptions ? this.props.options.map(function (opt) {
|
|
return {
|
|
label: String(opt),
|
|
value: opt
|
|
};
|
|
}) : [];
|
|
var element = hasOptions ? /*#__PURE__*/React.createElement(Dropdown, {
|
|
value: this.props.value,
|
|
options: options,
|
|
onChange: this.props.onChange,
|
|
appendTo: this.props.appendTo,
|
|
disabled: this.props.disabled
|
|
}) : null;
|
|
|
|
if (this.props.template) {
|
|
var defaultOptions = {
|
|
value: this.props.value,
|
|
options: options,
|
|
onChange: this.props.onChange,
|
|
appendTo: this.props.appendTo,
|
|
currentPage: this.props.page,
|
|
totalPages: this.props.pageCount,
|
|
totalRecords: this.props.totalRecords,
|
|
disabled: this.props.disabled,
|
|
element: element,
|
|
props: this.props
|
|
};
|
|
return ObjectUtils.getJSXElement(this.props.template, defaultOptions);
|
|
}
|
|
|
|
return element;
|
|
}
|
|
}]);
|
|
|
|
return RowsPerPageDropdown;
|
|
}(Component);
|
|
|
|
_defineProperty(RowsPerPageDropdown, "defaultProps", {
|
|
options: null,
|
|
value: null,
|
|
page: null,
|
|
pageCount: null,
|
|
totalRecords: 0,
|
|
appendTo: null,
|
|
onChange: null,
|
|
template: null,
|
|
disabled: false
|
|
});
|
|
|
|
function ownKeys$B(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$B(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$B(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$B(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$1G(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1G(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1G() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var CurrentPageReport = /*#__PURE__*/function (_Component) {
|
|
_inherits(CurrentPageReport, _Component);
|
|
|
|
var _super = _createSuper$1G(CurrentPageReport);
|
|
|
|
function CurrentPageReport() {
|
|
_classCallCheck(this, CurrentPageReport);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(CurrentPageReport, [{
|
|
key: "render",
|
|
value: function render() {
|
|
var report = {
|
|
currentPage: this.props.page + 1,
|
|
totalPages: this.props.pageCount,
|
|
first: Math.min(this.props.first + 1, this.props.totalRecords),
|
|
last: Math.min(this.props.first + this.props.rows, this.props.totalRecords),
|
|
rows: this.props.rows,
|
|
totalRecords: this.props.totalRecords
|
|
};
|
|
var text = this.props.reportTemplate.replace("{currentPage}", report.currentPage).replace("{totalPages}", report.totalPages).replace("{first}", report.first).replace("{last}", report.last).replace("{rows}", report.rows).replace("{totalRecords}", report.totalRecords);
|
|
var element = /*#__PURE__*/React.createElement("span", {
|
|
className: "p-paginator-current"
|
|
}, text);
|
|
|
|
if (this.props.template) {
|
|
var defaultOptions = _objectSpread$B(_objectSpread$B({}, report), {
|
|
className: 'p-paginator-current',
|
|
element: element,
|
|
props: this.props
|
|
});
|
|
|
|
return ObjectUtils.getJSXElement(this.props.template, defaultOptions);
|
|
}
|
|
|
|
return element;
|
|
}
|
|
}]);
|
|
|
|
return CurrentPageReport;
|
|
}(Component);
|
|
|
|
_defineProperty(CurrentPageReport, "defaultProps", {
|
|
pageCount: null,
|
|
page: null,
|
|
first: null,
|
|
rows: null,
|
|
totalRecords: null,
|
|
reportTemplate: '({currentPage} of {totalPages})',
|
|
template: null
|
|
});
|
|
|
|
function ownKeys$A(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$A(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$A(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$A(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$1F(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1F(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1F() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var InputNumber = /*#__PURE__*/function (_Component) {
|
|
_inherits(InputNumber, _Component);
|
|
|
|
var _super = _createSuper$1F(InputNumber);
|
|
|
|
function InputNumber(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, InputNumber);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
focused: false
|
|
};
|
|
|
|
_this.constructParser();
|
|
|
|
_this.onInput = _this.onInput.bind(_assertThisInitialized(_this));
|
|
_this.onInputKeyDown = _this.onInputKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onInputKeyPress = _this.onInputKeyPress.bind(_assertThisInitialized(_this));
|
|
_this.onInputClick = _this.onInputClick.bind(_assertThisInitialized(_this));
|
|
_this.onInputBlur = _this.onInputBlur.bind(_assertThisInitialized(_this));
|
|
_this.onInputFocus = _this.onInputFocus.bind(_assertThisInitialized(_this));
|
|
_this.onPaste = _this.onPaste.bind(_assertThisInitialized(_this));
|
|
_this.onUpButtonMouseLeave = _this.onUpButtonMouseLeave.bind(_assertThisInitialized(_this));
|
|
_this.onUpButtonMouseDown = _this.onUpButtonMouseDown.bind(_assertThisInitialized(_this));
|
|
_this.onUpButtonMouseUp = _this.onUpButtonMouseUp.bind(_assertThisInitialized(_this));
|
|
_this.onUpButtonKeyDown = _this.onUpButtonKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onUpButtonKeyUp = _this.onUpButtonKeyUp.bind(_assertThisInitialized(_this));
|
|
_this.onDownButtonMouseLeave = _this.onDownButtonMouseLeave.bind(_assertThisInitialized(_this));
|
|
_this.onDownButtonMouseDown = _this.onDownButtonMouseDown.bind(_assertThisInitialized(_this));
|
|
_this.onDownButtonMouseUp = _this.onDownButtonMouseUp.bind(_assertThisInitialized(_this));
|
|
_this.onDownButtonKeyDown = _this.onDownButtonKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onDownButtonKeyUp = _this.onDownButtonKeyUp.bind(_assertThisInitialized(_this));
|
|
_this.inputRef = /*#__PURE__*/createRef(_this.props.inputRef);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(InputNumber, [{
|
|
key: "getOptions",
|
|
value: function getOptions() {
|
|
return {
|
|
localeMatcher: this.props.localeMatcher,
|
|
style: this.props.mode,
|
|
currency: this.props.currency,
|
|
currencyDisplay: this.props.currencyDisplay,
|
|
useGrouping: this.props.useGrouping,
|
|
minimumFractionDigits: this.props.minFractionDigits,
|
|
maximumFractionDigits: this.props.maxFractionDigits
|
|
};
|
|
}
|
|
}, {
|
|
key: "constructParser",
|
|
value: function constructParser() {
|
|
this.numberFormat = new Intl.NumberFormat(this.props.locale, this.getOptions());
|
|
|
|
var numerals = _toConsumableArray(new Intl.NumberFormat(this.props.locale, {
|
|
useGrouping: false
|
|
}).format(9876543210)).reverse();
|
|
|
|
var index = new Map(numerals.map(function (d, i) {
|
|
return [d, i];
|
|
}));
|
|
this._numeral = new RegExp("[".concat(numerals.join(''), "]"), 'g');
|
|
this._group = this.getGroupingExpression();
|
|
this._minusSign = this.getMinusSignExpression();
|
|
this._currency = this.getCurrencyExpression();
|
|
this._decimal = this.getDecimalExpression();
|
|
this._suffix = this.getSuffixExpression();
|
|
this._prefix = this.getPrefixExpression();
|
|
|
|
this._index = function (d) {
|
|
return index.get(d);
|
|
};
|
|
}
|
|
}, {
|
|
key: "escapeRegExp",
|
|
value: function escapeRegExp(text) {
|
|
return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
|
|
}
|
|
}, {
|
|
key: "getDecimalExpression",
|
|
value: function getDecimalExpression() {
|
|
var formatter = new Intl.NumberFormat(this.props.locale, _objectSpread$A(_objectSpread$A({}, this.getOptions()), {}, {
|
|
useGrouping: false
|
|
}));
|
|
return new RegExp("[".concat(formatter.format(1.1).replace(this._currency, '').trim().replace(this._numeral, ''), "]"), 'g');
|
|
}
|
|
}, {
|
|
key: "getGroupingExpression",
|
|
value: function getGroupingExpression() {
|
|
var formatter = new Intl.NumberFormat(this.props.locale, {
|
|
useGrouping: true
|
|
});
|
|
this.groupChar = formatter.format(1000000).trim().replace(this._numeral, '').charAt(0);
|
|
return new RegExp("[".concat(this.groupChar, "]"), 'g');
|
|
}
|
|
}, {
|
|
key: "getMinusSignExpression",
|
|
value: function getMinusSignExpression() {
|
|
var formatter = new Intl.NumberFormat(this.props.locale, {
|
|
useGrouping: false
|
|
});
|
|
return new RegExp("[".concat(formatter.format(-1).trim().replace(this._numeral, ''), "]"), 'g');
|
|
}
|
|
}, {
|
|
key: "getCurrencyExpression",
|
|
value: function getCurrencyExpression() {
|
|
if (this.props.currency) {
|
|
var formatter = new Intl.NumberFormat(this.props.locale, {
|
|
style: 'currency',
|
|
currency: this.props.currency,
|
|
currencyDisplay: this.props.currencyDisplay,
|
|
minimumFractionDigits: 0,
|
|
maximumFractionDigits: 0
|
|
});
|
|
return new RegExp("[".concat(formatter.format(1).replace(/\s/g, '').replace(this._numeral, '').replace(this._group, ''), "]"), 'g');
|
|
}
|
|
|
|
return new RegExp("[]", 'g');
|
|
}
|
|
}, {
|
|
key: "getPrefixExpression",
|
|
value: function getPrefixExpression() {
|
|
if (this.props.prefix) {
|
|
this.prefixChar = this.props.prefix;
|
|
} else {
|
|
var formatter = new Intl.NumberFormat(this.props.locale, {
|
|
style: this.props.mode,
|
|
currency: this.props.currency,
|
|
currencyDisplay: this.props.currencyDisplay
|
|
});
|
|
this.prefixChar = formatter.format(1).split('1')[0];
|
|
}
|
|
|
|
return new RegExp("".concat(this.escapeRegExp(this.prefixChar || '')), 'g');
|
|
}
|
|
}, {
|
|
key: "getSuffixExpression",
|
|
value: function getSuffixExpression() {
|
|
if (this.props.suffix) {
|
|
this.suffixChar = this.props.suffix;
|
|
} else {
|
|
var formatter = new Intl.NumberFormat(this.props.locale, {
|
|
style: this.props.mode,
|
|
currency: this.props.currency,
|
|
currencyDisplay: this.props.currencyDisplay,
|
|
minimumFractionDigits: 0,
|
|
maximumFractionDigits: 0
|
|
});
|
|
this.suffixChar = formatter.format(1).split('1')[1];
|
|
}
|
|
|
|
return new RegExp("".concat(this.escapeRegExp(this.suffixChar || '')), 'g');
|
|
}
|
|
}, {
|
|
key: "formatValue",
|
|
value: function formatValue(value) {
|
|
if (value != null) {
|
|
if (value === '-') {
|
|
// Minus sign
|
|
return value;
|
|
}
|
|
|
|
if (this.props.format) {
|
|
var formatter = new Intl.NumberFormat(this.props.locale, this.getOptions());
|
|
var formattedValue = formatter.format(value);
|
|
|
|
if (this.props.prefix) {
|
|
formattedValue = this.props.prefix + formattedValue;
|
|
}
|
|
|
|
if (this.props.suffix) {
|
|
formattedValue = formattedValue + this.props.suffix;
|
|
}
|
|
|
|
return formattedValue;
|
|
}
|
|
|
|
return value.toString();
|
|
}
|
|
|
|
return '';
|
|
}
|
|
}, {
|
|
key: "parseValue",
|
|
value: function parseValue(text) {
|
|
var filteredText = text.replace(this._suffix, '').replace(this._prefix, '').trim().replace(/\s/g, '').replace(this._currency, '').replace(this._group, '').replace(this._minusSign, '-').replace(this._decimal, '.').replace(this._numeral, this._index);
|
|
|
|
if (filteredText) {
|
|
if (filteredText === '-') // Minus sign
|
|
return filteredText;
|
|
var parsedValue = +filteredText;
|
|
return isNaN(parsedValue) ? null : parsedValue;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "repeat",
|
|
value: function repeat(event, interval, dir) {
|
|
var _this2 = this;
|
|
|
|
var i = interval || 500;
|
|
this.clearTimer();
|
|
this.timer = setTimeout(function () {
|
|
_this2.repeat(event, 40, dir);
|
|
}, i);
|
|
this.spin(event, dir);
|
|
}
|
|
}, {
|
|
key: "spin",
|
|
value: function spin(event, dir) {
|
|
if (this.inputRef && this.inputRef.current) {
|
|
var step = this.props.step * dir;
|
|
var currentValue = this.parseValue(this.inputRef.current.value) || 0;
|
|
var newValue = this.validateValue(currentValue + step);
|
|
this.updateInput(newValue, null, 'spin');
|
|
this.updateModel(event, newValue);
|
|
this.handleOnChange(event, currentValue, newValue);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onUpButtonMouseDown",
|
|
value: function onUpButtonMouseDown(event) {
|
|
if (!this.props.disabled && !this.props.readOnly) {
|
|
this.inputRef.current.focus();
|
|
this.repeat(event, null, 1);
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onUpButtonMouseUp",
|
|
value: function onUpButtonMouseUp() {
|
|
if (!this.props.disabled && !this.props.readOnly) {
|
|
this.clearTimer();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onUpButtonMouseLeave",
|
|
value: function onUpButtonMouseLeave() {
|
|
if (!this.props.disabled && !this.props.readOnly) {
|
|
this.clearTimer();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onUpButtonKeyUp",
|
|
value: function onUpButtonKeyUp() {
|
|
if (!this.props.disabled && !this.props.readOnly) {
|
|
this.clearTimer();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onUpButtonKeyDown",
|
|
value: function onUpButtonKeyDown(event) {
|
|
if (!this.props.disabled && !this.props.readOnly && (event.keyCode === 32 || event.keyCode === 13)) {
|
|
this.repeat(event, null, 1);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDownButtonMouseDown",
|
|
value: function onDownButtonMouseDown(event) {
|
|
if (!this.props.disabled && !this.props.readOnly) {
|
|
this.inputRef.current.focus();
|
|
this.repeat(event, null, -1);
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDownButtonMouseUp",
|
|
value: function onDownButtonMouseUp() {
|
|
if (!this.props.disabled && !this.props.readOnly) {
|
|
this.clearTimer();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDownButtonMouseLeave",
|
|
value: function onDownButtonMouseLeave() {
|
|
if (!this.props.disabled && !this.props.readOnly) {
|
|
this.clearTimer();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDownButtonKeyUp",
|
|
value: function onDownButtonKeyUp() {
|
|
if (!this.props.disabled && !this.props.readOnly) {
|
|
this.clearTimer();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDownButtonKeyDown",
|
|
value: function onDownButtonKeyDown(event) {
|
|
if (!this.props.disabled && !this.props.readOnly && (event.keyCode === 32 || event.keyCode === 13)) {
|
|
this.repeat(event, null, -1);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onInput",
|
|
value: function onInput(event) {
|
|
if (this.props.disabled || this.props.readOnly) {
|
|
return;
|
|
}
|
|
|
|
if (this.isSpecialChar) {
|
|
event.target.value = this.lastValue;
|
|
}
|
|
|
|
this.isSpecialChar = false;
|
|
}
|
|
}, {
|
|
key: "onInputKeyDown",
|
|
value: function onInputKeyDown(event) {
|
|
if (this.props.disabled || this.props.readOnly) {
|
|
return;
|
|
}
|
|
|
|
this.lastValue = event.target.value;
|
|
|
|
if (event.shiftKey || event.altKey) {
|
|
this.isSpecialChar = true;
|
|
return;
|
|
}
|
|
|
|
var selectionStart = event.target.selectionStart;
|
|
var selectionEnd = event.target.selectionEnd;
|
|
var inputValue = event.target.value;
|
|
var newValueStr = null;
|
|
|
|
if (event.altKey) {
|
|
event.preventDefault();
|
|
}
|
|
|
|
switch (event.which) {
|
|
//up
|
|
case 38:
|
|
this.spin(event, 1);
|
|
event.preventDefault();
|
|
break;
|
|
//down
|
|
|
|
case 40:
|
|
this.spin(event, -1);
|
|
event.preventDefault();
|
|
break;
|
|
//left
|
|
|
|
case 37:
|
|
if (!this.isNumeralChar(inputValue.charAt(selectionStart - 1))) {
|
|
event.preventDefault();
|
|
}
|
|
|
|
break;
|
|
//right
|
|
|
|
case 39:
|
|
if (!this.isNumeralChar(inputValue.charAt(selectionStart))) {
|
|
event.preventDefault();
|
|
}
|
|
|
|
break;
|
|
//enter
|
|
|
|
case 13:
|
|
newValueStr = this.validateValue(this.parseValue(inputValue));
|
|
this.inputRef.current.value = this.formatValue(newValueStr);
|
|
this.inputRef.current.setAttribute('aria-valuenow', newValueStr);
|
|
this.updateModel(event, newValueStr);
|
|
break;
|
|
//backspace
|
|
|
|
case 8:
|
|
event.preventDefault();
|
|
|
|
if (selectionStart === selectionEnd) {
|
|
var deleteChar = inputValue.charAt(selectionStart - 1);
|
|
|
|
var _this$getDecimalCharI = this.getDecimalCharIndexes(inputValue),
|
|
decimalCharIndex = _this$getDecimalCharI.decimalCharIndex,
|
|
decimalCharIndexWithoutPrefix = _this$getDecimalCharI.decimalCharIndexWithoutPrefix;
|
|
|
|
if (this.isNumeralChar(deleteChar)) {
|
|
var decimalLength = this.getDecimalLength(inputValue);
|
|
|
|
if (this._group.test(deleteChar)) {
|
|
this._group.lastIndex = 0;
|
|
newValueStr = inputValue.slice(0, selectionStart - 2) + inputValue.slice(selectionStart - 1);
|
|
} else if (this._decimal.test(deleteChar)) {
|
|
this._decimal.lastIndex = 0;
|
|
|
|
if (decimalLength) {
|
|
this.inputRef.current.setSelectionRange(selectionStart - 1, selectionStart - 1);
|
|
} else {
|
|
newValueStr = inputValue.slice(0, selectionStart - 1) + inputValue.slice(selectionStart);
|
|
}
|
|
} else if (decimalCharIndex > 0 && selectionStart > decimalCharIndex) {
|
|
var insertedText = this.isDecimalMode() && (this.props.minFractionDigits || 0) < decimalLength ? '' : '0';
|
|
newValueStr = inputValue.slice(0, selectionStart - 1) + insertedText + inputValue.slice(selectionStart);
|
|
} else if (decimalCharIndexWithoutPrefix === 1) {
|
|
newValueStr = inputValue.slice(0, selectionStart - 1) + '0' + inputValue.slice(selectionStart);
|
|
newValueStr = this.parseValue(newValueStr) > 0 ? newValueStr : '';
|
|
} else {
|
|
newValueStr = inputValue.slice(0, selectionStart - 1) + inputValue.slice(selectionStart);
|
|
}
|
|
}
|
|
|
|
this.updateValue(event, newValueStr, null, 'delete-single');
|
|
} else {
|
|
newValueStr = this.deleteRange(inputValue, selectionStart, selectionEnd);
|
|
this.updateValue(event, newValueStr, null, 'delete-range');
|
|
}
|
|
|
|
break;
|
|
// del
|
|
|
|
case 46:
|
|
event.preventDefault();
|
|
|
|
if (selectionStart === selectionEnd) {
|
|
var _deleteChar = inputValue.charAt(selectionStart);
|
|
|
|
var _this$getDecimalCharI2 = this.getDecimalCharIndexes(inputValue),
|
|
_decimalCharIndex = _this$getDecimalCharI2.decimalCharIndex,
|
|
_decimalCharIndexWithoutPrefix = _this$getDecimalCharI2.decimalCharIndexWithoutPrefix;
|
|
|
|
if (this.isNumeralChar(_deleteChar)) {
|
|
var _decimalLength = this.getDecimalLength(inputValue);
|
|
|
|
if (this._group.test(_deleteChar)) {
|
|
this._group.lastIndex = 0;
|
|
newValueStr = inputValue.slice(0, selectionStart) + inputValue.slice(selectionStart + 2);
|
|
} else if (this._decimal.test(_deleteChar)) {
|
|
this._decimal.lastIndex = 0;
|
|
|
|
if (_decimalLength) {
|
|
this.$refs.input.$el.setSelectionRange(selectionStart + 1, selectionStart + 1);
|
|
} else {
|
|
newValueStr = inputValue.slice(0, selectionStart) + inputValue.slice(selectionStart + 1);
|
|
}
|
|
} else if (_decimalCharIndex > 0 && selectionStart > _decimalCharIndex) {
|
|
var _insertedText = this.isDecimalMode() && (this.props.minFractionDigits || 0) < _decimalLength ? '' : '0';
|
|
|
|
newValueStr = inputValue.slice(0, selectionStart) + _insertedText + inputValue.slice(selectionStart + 1);
|
|
} else if (_decimalCharIndexWithoutPrefix === 1) {
|
|
newValueStr = inputValue.slice(0, selectionStart) + '0' + inputValue.slice(selectionStart + 1);
|
|
newValueStr = this.parseValue(newValueStr) > 0 ? newValueStr : '';
|
|
} else {
|
|
newValueStr = inputValue.slice(0, selectionStart) + inputValue.slice(selectionStart + 1);
|
|
}
|
|
}
|
|
|
|
this.updateValue(event, newValueStr, null, 'delete-back-single');
|
|
} else {
|
|
newValueStr = this.deleteRange(inputValue, selectionStart, selectionEnd);
|
|
this.updateValue(event, newValueStr, null, 'delete-range');
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
if (this.props.onKeyDown) {
|
|
this.props.onKeyDown(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onInputKeyPress",
|
|
value: function onInputKeyPress(event) {
|
|
if (this.props.disabled || this.props.readOnly) {
|
|
return;
|
|
}
|
|
|
|
var code = event.which || event.keyCode;
|
|
|
|
var _char = String.fromCharCode(code);
|
|
|
|
var isDecimalSign = this.isDecimalSign(_char);
|
|
var isMinusSign = this.isMinusSign(_char);
|
|
|
|
if (48 <= code && code <= 57 || isMinusSign || isDecimalSign) {
|
|
this.insert(event, _char, {
|
|
isDecimalSign: isDecimalSign,
|
|
isMinusSign: isMinusSign
|
|
});
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onPaste",
|
|
value: function onPaste(event) {
|
|
event.preventDefault();
|
|
|
|
if (this.props.disabled || this.props.readOnly) {
|
|
return;
|
|
}
|
|
|
|
var data = (event.clipboardData || window['clipboardData']).getData('Text');
|
|
|
|
if (data) {
|
|
var filteredData = this.parseValue(data);
|
|
|
|
if (filteredData != null) {
|
|
this.insert(event, filteredData.toString());
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "allowMinusSign",
|
|
value: function allowMinusSign() {
|
|
return this.props.min === null || this.props.min < 0;
|
|
}
|
|
}, {
|
|
key: "isMinusSign",
|
|
value: function isMinusSign(_char2) {
|
|
if (this._minusSign.test(_char2) || _char2 === '-') {
|
|
this._minusSign.lastIndex = 0;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "isDecimalSign",
|
|
value: function isDecimalSign(_char3) {
|
|
if (this._decimal.test(_char3)) {
|
|
this._decimal.lastIndex = 0;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "isDecimalMode",
|
|
value: function isDecimalMode() {
|
|
return this.props.mode === 'decimal';
|
|
}
|
|
}, {
|
|
key: "getDecimalCharIndexes",
|
|
value: function getDecimalCharIndexes(val) {
|
|
var decimalCharIndex = val.search(this._decimal);
|
|
this._decimal.lastIndex = 0;
|
|
var filteredVal = val.replace(this._prefix, '').trim().replace(/\s/g, '').replace(this._currency, '');
|
|
var decimalCharIndexWithoutPrefix = filteredVal.search(this._decimal);
|
|
this._decimal.lastIndex = 0;
|
|
return {
|
|
decimalCharIndex: decimalCharIndex,
|
|
decimalCharIndexWithoutPrefix: decimalCharIndexWithoutPrefix
|
|
};
|
|
}
|
|
}, {
|
|
key: "getCharIndexes",
|
|
value: function getCharIndexes(val) {
|
|
var decimalCharIndex = val.search(this._decimal);
|
|
this._decimal.lastIndex = 0;
|
|
var minusCharIndex = val.search(this._minusSign);
|
|
this._minusSign.lastIndex = 0;
|
|
var suffixCharIndex = val.search(this._suffix);
|
|
this._suffix.lastIndex = 0;
|
|
var currencyCharIndex = val.search(this._currency);
|
|
this._currency.lastIndex = 0;
|
|
return {
|
|
decimalCharIndex: decimalCharIndex,
|
|
minusCharIndex: minusCharIndex,
|
|
suffixCharIndex: suffixCharIndex,
|
|
currencyCharIndex: currencyCharIndex
|
|
};
|
|
}
|
|
}, {
|
|
key: "insert",
|
|
value: function insert(event, text) {
|
|
var sign = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
|
|
isDecimalSign: false,
|
|
isMinusSign: false
|
|
};
|
|
var minusCharIndexOnText = text.search(this._minusSign);
|
|
this._minusSign.lastIndex = 0;
|
|
|
|
if (!this.allowMinusSign() && minusCharIndexOnText !== -1) {
|
|
return;
|
|
}
|
|
|
|
var selectionStart = this.inputRef.current.selectionStart;
|
|
var selectionEnd = this.inputRef.current.selectionEnd;
|
|
var inputValue = this.inputRef.current.value.trim();
|
|
|
|
var _this$getCharIndexes = this.getCharIndexes(inputValue),
|
|
decimalCharIndex = _this$getCharIndexes.decimalCharIndex,
|
|
minusCharIndex = _this$getCharIndexes.minusCharIndex,
|
|
suffixCharIndex = _this$getCharIndexes.suffixCharIndex,
|
|
currencyCharIndex = _this$getCharIndexes.currencyCharIndex;
|
|
|
|
var newValueStr;
|
|
|
|
if (sign.isMinusSign) {
|
|
if (selectionStart === 0) {
|
|
newValueStr = inputValue;
|
|
|
|
if (minusCharIndex === -1 || selectionEnd !== 0) {
|
|
newValueStr = this.insertText(inputValue, text, 0, selectionEnd);
|
|
}
|
|
|
|
this.updateValue(event, newValueStr, text, 'insert');
|
|
}
|
|
} else if (sign.isDecimalSign) {
|
|
if (decimalCharIndex > 0 && selectionStart === decimalCharIndex) {
|
|
this.updateValue(event, inputValue, text, 'insert');
|
|
} else if (decimalCharIndex > selectionStart && decimalCharIndex < selectionEnd) {
|
|
newValueStr = this.insertText(inputValue, text, selectionStart, selectionEnd);
|
|
this.updateValue(event, newValueStr, text, 'insert');
|
|
} else if (decimalCharIndex === -1 && this.props.maxFractionDigits) {
|
|
newValueStr = this.insertText(inputValue, text, selectionStart, selectionEnd);
|
|
this.updateValue(event, newValueStr, text, 'insert');
|
|
}
|
|
} else {
|
|
var maxFractionDigits = this.numberFormat.resolvedOptions().maximumFractionDigits;
|
|
var operation = selectionStart !== selectionEnd ? 'range-insert' : 'insert';
|
|
|
|
if (decimalCharIndex > 0 && selectionStart > decimalCharIndex) {
|
|
if (selectionStart + text.length - (decimalCharIndex + 1) <= maxFractionDigits) {
|
|
var charIndex = currencyCharIndex >= selectionStart ? currencyCharIndex - 1 : suffixCharIndex >= selectionStart ? suffixCharIndex : inputValue.length;
|
|
newValueStr = inputValue.slice(0, selectionStart) + text + inputValue.slice(selectionStart + text.length, charIndex) + inputValue.slice(charIndex);
|
|
this.updateValue(event, newValueStr, text, operation);
|
|
}
|
|
} else {
|
|
newValueStr = this.insertText(inputValue, text, selectionStart, selectionEnd);
|
|
this.updateValue(event, newValueStr, text, operation);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "insertText",
|
|
value: function insertText(value, text, start, end) {
|
|
var textSplit = text === '.' ? text : text.split('.');
|
|
|
|
if (textSplit.length === 2) {
|
|
var decimalCharIndex = value.slice(start, end).search(this._decimal);
|
|
this._decimal.lastIndex = 0;
|
|
return decimalCharIndex > 0 ? value.slice(0, start) + this.formatValue(text) + value.slice(end) : value || this.formatValue(text);
|
|
} else if (end - start === value.length) {
|
|
return this.formatValue(text);
|
|
} else if (start === 0) {
|
|
return text + value.slice(end);
|
|
} else if (end === value.length) {
|
|
return value.slice(0, start) + text;
|
|
} else {
|
|
return value.slice(0, start) + text + value.slice(end);
|
|
}
|
|
}
|
|
}, {
|
|
key: "deleteRange",
|
|
value: function deleteRange(value, start, end) {
|
|
var newValueStr;
|
|
if (end - start === value.length) newValueStr = '';else if (start === 0) newValueStr = value.slice(end);else if (end === value.length) newValueStr = value.slice(0, start);else newValueStr = value.slice(0, start) + value.slice(end);
|
|
return newValueStr;
|
|
}
|
|
}, {
|
|
key: "initCursor",
|
|
value: function initCursor() {
|
|
var selectionStart = this.inputRef.current.selectionStart;
|
|
var inputValue = this.inputRef.current.value;
|
|
var valueLength = inputValue.length;
|
|
var index = null; // remove prefix
|
|
|
|
var prefixLength = (this.prefixChar || '').length;
|
|
inputValue = inputValue.replace(this._prefix, '');
|
|
selectionStart = selectionStart - prefixLength;
|
|
|
|
var _char4 = inputValue.charAt(selectionStart);
|
|
|
|
if (this.isNumeralChar(_char4)) {
|
|
return selectionStart + prefixLength;
|
|
} //left
|
|
|
|
|
|
var i = selectionStart - 1;
|
|
|
|
while (i >= 0) {
|
|
_char4 = inputValue.charAt(i);
|
|
|
|
if (this.isNumeralChar(_char4)) {
|
|
index = i + prefixLength;
|
|
break;
|
|
} else {
|
|
i--;
|
|
}
|
|
}
|
|
|
|
if (index !== null) {
|
|
this.inputRef.current.setSelectionRange(index + 1, index + 1);
|
|
} else {
|
|
i = selectionStart;
|
|
|
|
while (i < valueLength) {
|
|
_char4 = inputValue.charAt(i);
|
|
|
|
if (this.isNumeralChar(_char4)) {
|
|
index = i + prefixLength;
|
|
break;
|
|
} else {
|
|
i++;
|
|
}
|
|
}
|
|
|
|
if (index !== null) {
|
|
this.inputRef.current.setSelectionRange(index, index);
|
|
}
|
|
}
|
|
|
|
return index || 0;
|
|
}
|
|
}, {
|
|
key: "onInputClick",
|
|
value: function onInputClick() {
|
|
this.initCursor();
|
|
}
|
|
}, {
|
|
key: "isNumeralChar",
|
|
value: function isNumeralChar(_char5) {
|
|
if (_char5.length === 1 && (this._numeral.test(_char5) || this._decimal.test(_char5) || this._group.test(_char5) || this._minusSign.test(_char5))) {
|
|
this.resetRegex();
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}, {
|
|
key: "resetRegex",
|
|
value: function resetRegex() {
|
|
this._numeral.lastIndex = 0;
|
|
this._decimal.lastIndex = 0;
|
|
this._group.lastIndex = 0;
|
|
this._minusSign.lastIndex = 0;
|
|
}
|
|
}, {
|
|
key: "updateValue",
|
|
value: function updateValue(event, valueStr, insertedValueStr, operation) {
|
|
var currentValue = this.inputRef.current.value;
|
|
var newValue = null;
|
|
|
|
if (valueStr != null) {
|
|
newValue = this.parseValue(valueStr);
|
|
newValue = this.evaluateEmpty(newValue);
|
|
this.updateInput(newValue, insertedValueStr, operation, valueStr);
|
|
this.handleOnChange(event, currentValue, newValue);
|
|
}
|
|
}
|
|
}, {
|
|
key: "evaluateEmpty",
|
|
value: function evaluateEmpty(newValue) {
|
|
return !newValue && !this.props.allowEmpty ? this.props.min || 0 : newValue;
|
|
}
|
|
}, {
|
|
key: "handleOnChange",
|
|
value: function handleOnChange(event, currentValue, newValue) {
|
|
if (this.props.onChange && this.isValueChanged(currentValue, newValue)) {
|
|
this.props.onChange({
|
|
originalEvent: event,
|
|
value: newValue
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "isValueChanged",
|
|
value: function isValueChanged(currentValue, newValue) {
|
|
if (newValue === null && currentValue !== null) {
|
|
return true;
|
|
}
|
|
|
|
if (newValue != null) {
|
|
var parsedCurrentValue = typeof currentValue === 'string' ? this.parseValue(currentValue) : currentValue;
|
|
return newValue !== parsedCurrentValue;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "validateValue",
|
|
value: function validateValue(value) {
|
|
if (value === '-' || value == null) {
|
|
return null;
|
|
}
|
|
|
|
if (this.props.min !== null && value < this.props.min) {
|
|
return this.props.min;
|
|
}
|
|
|
|
if (this.props.max !== null && value > this.props.max) {
|
|
return this.props.max;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
}, {
|
|
key: "updateInput",
|
|
value: function updateInput(value, insertedValueStr, operation, valueStr) {
|
|
insertedValueStr = insertedValueStr || '';
|
|
var inputEl = this.inputRef.current;
|
|
var inputValue = inputEl.value;
|
|
var newValue = this.formatValue(value);
|
|
var currentLength = inputValue.length;
|
|
|
|
if (newValue !== valueStr) {
|
|
newValue = this.concatValues(newValue, valueStr);
|
|
}
|
|
|
|
if (currentLength === 0) {
|
|
inputEl.value = newValue;
|
|
inputEl.setSelectionRange(0, 0);
|
|
var index = this.initCursor();
|
|
var selectionEnd = index + insertedValueStr.length;
|
|
inputEl.setSelectionRange(selectionEnd, selectionEnd);
|
|
} else {
|
|
var selectionStart = inputEl.selectionStart;
|
|
var _selectionEnd = inputEl.selectionEnd;
|
|
inputEl.value = newValue;
|
|
var newLength = newValue.length;
|
|
|
|
if (operation === 'range-insert') {
|
|
var startValue = this.parseValue((inputValue || '').slice(0, selectionStart));
|
|
var startValueStr = startValue !== null ? startValue.toString() : '';
|
|
var startExpr = startValueStr.split('').join("(".concat(this.groupChar, ")?"));
|
|
var sRegex = new RegExp(startExpr, 'g');
|
|
sRegex.test(newValue);
|
|
var tExpr = insertedValueStr.split('').join("(".concat(this.groupChar, ")?"));
|
|
var tRegex = new RegExp(tExpr, 'g');
|
|
tRegex.test(newValue.slice(sRegex.lastIndex));
|
|
_selectionEnd = sRegex.lastIndex + tRegex.lastIndex;
|
|
inputEl.setSelectionRange(_selectionEnd, _selectionEnd);
|
|
} else if (newLength === currentLength) {
|
|
if (operation === 'insert' || operation === 'delete-back-single') inputEl.setSelectionRange(_selectionEnd + 1, _selectionEnd + 1);else if (operation === 'delete-single') inputEl.setSelectionRange(_selectionEnd - 1, _selectionEnd - 1);else if (operation === 'delete-range' || operation === 'spin') inputEl.setSelectionRange(_selectionEnd, _selectionEnd);
|
|
} else if (operation === 'delete-back-single') {
|
|
var prevChar = inputValue.charAt(_selectionEnd - 1);
|
|
var nextChar = inputValue.charAt(_selectionEnd);
|
|
var diff = currentLength - newLength;
|
|
|
|
var isGroupChar = this._group.test(nextChar);
|
|
|
|
if (isGroupChar && diff === 1) {
|
|
_selectionEnd += 1;
|
|
} else if (!isGroupChar && this.isNumeralChar(prevChar)) {
|
|
_selectionEnd += -1 * diff + 1;
|
|
}
|
|
|
|
this._group.lastIndex = 0;
|
|
inputEl.setSelectionRange(_selectionEnd, _selectionEnd);
|
|
} else if (inputValue === '-' && operation === 'insert') {
|
|
inputEl.setSelectionRange(0, 0);
|
|
|
|
var _index = this.initCursor();
|
|
|
|
var _selectionEnd2 = _index + insertedValueStr.length + 1;
|
|
|
|
inputEl.setSelectionRange(_selectionEnd2, _selectionEnd2);
|
|
} else {
|
|
_selectionEnd = _selectionEnd + (newLength - currentLength);
|
|
inputEl.setSelectionRange(_selectionEnd, _selectionEnd);
|
|
}
|
|
}
|
|
|
|
inputEl.setAttribute('aria-valuenow', value);
|
|
}
|
|
}, {
|
|
key: "updateInputValue",
|
|
value: function updateInputValue(newValue) {
|
|
newValue = this.evaluateEmpty(newValue);
|
|
var inputEl = this.inputRef.current;
|
|
var value = inputEl.value;
|
|
var formattedValue = this.formattedValue(newValue);
|
|
|
|
if (value !== formattedValue) {
|
|
inputEl.value = formattedValue;
|
|
inputEl.setAttribute('aria-valuenow', newValue);
|
|
}
|
|
}
|
|
}, {
|
|
key: "formattedValue",
|
|
value: function formattedValue(val) {
|
|
var newValue = this.evaluateEmpty(val);
|
|
return this.formatValue(newValue);
|
|
}
|
|
}, {
|
|
key: "concatValues",
|
|
value: function concatValues(val1, val2) {
|
|
if (val1 && val2) {
|
|
var decimalCharIndex = val2.search(this._decimal);
|
|
this._decimal.lastIndex = 0;
|
|
return decimalCharIndex !== -1 ? val1.split(this._decimal)[0] + val2.slice(decimalCharIndex) : val1;
|
|
}
|
|
|
|
return val1;
|
|
}
|
|
}, {
|
|
key: "getDecimalLength",
|
|
value: function getDecimalLength(value) {
|
|
if (value) {
|
|
var valueSplit = value.split(this._decimal);
|
|
|
|
if (valueSplit.length === 2) {
|
|
return valueSplit[1].replace(this._suffix, '').trim().replace(/\s/g, '').replace(this._currency, '').length;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
}, {
|
|
key: "updateModel",
|
|
value: function updateModel(event, value) {
|
|
if (this.props.onValueChange) {
|
|
this.props.onValueChange({
|
|
originalEvent: event,
|
|
value: value,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: value
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onInputFocus",
|
|
value: function onInputFocus(event) {
|
|
var _this3 = this;
|
|
|
|
event.persist();
|
|
this.setState({
|
|
focused: true
|
|
}, function () {
|
|
if (_this3.props.onFocus) {
|
|
_this3.props.onFocus(event);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onInputBlur",
|
|
value: function onInputBlur(event) {
|
|
var _this4 = this;
|
|
|
|
event.persist();
|
|
this.setState({
|
|
focused: false
|
|
}, function () {
|
|
var currentValue = _this4.inputRef.current.value;
|
|
|
|
if (_this4.isValueChanged(currentValue, _this4.props.value)) {
|
|
var newValue = _this4.validateValue(_this4.parseValue(currentValue));
|
|
|
|
_this4.updateInputValue(newValue);
|
|
|
|
_this4.updateModel(event, newValue);
|
|
}
|
|
|
|
if (_this4.props.onBlur) {
|
|
_this4.props.onBlur(event);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "clearTimer",
|
|
value: function clearTimer() {
|
|
if (this.timer) {
|
|
clearInterval(this.timer);
|
|
}
|
|
}
|
|
}, {
|
|
key: "isStacked",
|
|
value: function isStacked() {
|
|
return this.props.showButtons && this.props.buttonLayout === 'stacked';
|
|
}
|
|
}, {
|
|
key: "isHorizontal",
|
|
value: function isHorizontal() {
|
|
return this.props.showButtons && this.props.buttonLayout === 'horizontal';
|
|
}
|
|
}, {
|
|
key: "isVertical",
|
|
value: function isVertical() {
|
|
return this.props.showButtons && this.props.buttonLayout === 'vertical';
|
|
}
|
|
}, {
|
|
key: "getInputMode",
|
|
value: function getInputMode() {
|
|
return this.props.inputMode || (this.props.mode === 'decimal' && !this.props.minFractionDigits ? 'numeric' : 'decimal');
|
|
}
|
|
}, {
|
|
key: "getFormatter",
|
|
value: function getFormatter() {
|
|
return this.numberFormat;
|
|
}
|
|
}, {
|
|
key: "updateInputRef",
|
|
value: function updateInputRef() {
|
|
var ref = this.props.inputRef;
|
|
|
|
if (ref) {
|
|
if (typeof ref === 'function') {
|
|
ref(this.inputRef.current);
|
|
} else {
|
|
ref.current = this.inputRef.current;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.updateInputRef();
|
|
|
|
if (this.props.tooltip) {
|
|
this.renderTooltip();
|
|
}
|
|
|
|
var newValue = this.validateValue(this.props.value);
|
|
|
|
if (this.props.value !== null && this.props.value !== newValue) {
|
|
this.updateModel(null, newValue);
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$A({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
}
|
|
|
|
var isOptionChanged = this.isOptionChanged(prevProps);
|
|
|
|
if (isOptionChanged) {
|
|
this.constructParser();
|
|
}
|
|
|
|
if (prevProps.value !== this.props.value || isOptionChanged) {
|
|
var newValue = this.validateValue(this.props.value);
|
|
this.updateInputValue(newValue);
|
|
|
|
if (this.props.value !== null && this.props.value !== newValue) {
|
|
this.updateModel(null, newValue);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "isOptionChanged",
|
|
value: function isOptionChanged(prevProps) {
|
|
var _this5 = this;
|
|
|
|
var optionProps = ['locale', 'localeMatcher', 'mode', 'currency', 'currencyDisplay', 'useGrouping', 'minFractionDigits', 'maxFractionDigits', 'suffix', 'prefix'];
|
|
return optionProps.some(function (option) {
|
|
return prevProps[option] !== _this5.props[option];
|
|
});
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.element,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderInputElement",
|
|
value: function renderInputElement() {
|
|
var className = classNames('p-inputnumber-input', this.props.inputClassName);
|
|
var valueToRender = this.formattedValue(this.props.value);
|
|
return /*#__PURE__*/React.createElement(InputText, {
|
|
ref: this.inputRef,
|
|
id: this.props.inputId,
|
|
style: this.props.inputStyle,
|
|
role: "spinbutton",
|
|
className: className,
|
|
defaultValue: valueToRender,
|
|
type: this.props.type,
|
|
size: this.props.size,
|
|
tabIndex: this.props.tabIndex,
|
|
inputMode: this.getInputMode(),
|
|
maxLength: this.props.maxLength,
|
|
disabled: this.props.disabled,
|
|
required: this.props.required,
|
|
pattern: this.props.pattern,
|
|
placeholder: this.props.placeholder,
|
|
readOnly: this.props.readOnly,
|
|
name: this.props.name,
|
|
autoFocus: this.props.autoFocus,
|
|
onKeyDown: this.onInputKeyDown,
|
|
onKeyPress: this.onInputKeyPress,
|
|
onInput: this.onInput,
|
|
onClick: this.onInputClick,
|
|
onBlur: this.onInputBlur,
|
|
onFocus: this.onInputFocus,
|
|
onPaste: this.onPaste,
|
|
min: this.props.min,
|
|
max: this.props.max,
|
|
"aria-valuemin": this.props.min,
|
|
"aria-valuemax": this.props.max,
|
|
"aria-valuenow": this.props.value,
|
|
"aria-labelledby": this.props.ariaLabelledBy
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderUpButton",
|
|
value: function renderUpButton() {
|
|
var className = classNames('p-inputnumber-button p-inputnumber-button-up p-button p-button-icon-only p-component', {
|
|
'p-disabled': this.props.disabled
|
|
}, this.props.incrementButtonClassName);
|
|
var icon = classNames('p-button-icon', this.props.incrementButtonIcon);
|
|
return /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: className,
|
|
onMouseLeave: this.onUpButtonMouseLeave,
|
|
onMouseDown: this.onUpButtonMouseDown,
|
|
onMouseUp: this.onUpButtonMouseUp,
|
|
onKeyDown: this.onUpButtonKeyDown,
|
|
onKeyUp: this.onUpButtonKeyUp,
|
|
disabled: this.props.disabled,
|
|
tabIndex: -1
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: icon
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
}, {
|
|
key: "renderDownButton",
|
|
value: function renderDownButton() {
|
|
var className = classNames('p-inputnumber-button p-inputnumber-button-down p-button p-button-icon-only p-component', {
|
|
'p-disabled': this.props.disabled
|
|
}, this.props.decrementButtonClassName);
|
|
var icon = classNames('p-button-icon', this.props.decrementButtonIcon);
|
|
return /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: className,
|
|
onMouseLeave: this.onDownButtonMouseLeave,
|
|
onMouseDown: this.onDownButtonMouseDown,
|
|
onMouseUp: this.onDownButtonMouseUp,
|
|
onKeyDown: this.onDownButtonKeyDown,
|
|
onKeyUp: this.onDownButtonKeyUp,
|
|
disabled: this.props.disabled,
|
|
tabIndex: -1
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: icon
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
}, {
|
|
key: "renderButtonGroup",
|
|
value: function renderButtonGroup() {
|
|
var upButton = this.props.showButtons && this.renderUpButton();
|
|
var downButton = this.props.showButtons && this.renderDownButton();
|
|
|
|
if (this.isStacked()) {
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: "p-inputnumber-button-group"
|
|
}, upButton, downButton);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, upButton, downButton);
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this6 = this;
|
|
|
|
var className = classNames('p-inputnumber p-component p-inputwrapper', this.props.className, {
|
|
'p-inputwrapper-filled': this.props.value != null && this.props.value.toString().length > 0,
|
|
'p-inputwrapper-focus': this.state.focused,
|
|
'p-inputnumber-buttons-stacked': this.isStacked(),
|
|
'p-inputnumber-buttons-horizontal': this.isHorizontal(),
|
|
'p-inputnumber-buttons-vertical': this.isVertical()
|
|
});
|
|
var inputElement = this.renderInputElement();
|
|
var buttonGroup = this.renderButtonGroup();
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
ref: function ref(el) {
|
|
return _this6.element = el;
|
|
},
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, inputElement, buttonGroup);
|
|
}
|
|
}]);
|
|
|
|
return InputNumber;
|
|
}(Component);
|
|
|
|
_defineProperty(InputNumber, "defaultProps", {
|
|
value: null,
|
|
inputRef: null,
|
|
format: true,
|
|
showButtons: false,
|
|
buttonLayout: 'stacked',
|
|
incrementButtonClassName: null,
|
|
decrementButtonClassName: null,
|
|
incrementButtonIcon: 'pi pi-angle-up',
|
|
decrementButtonIcon: 'pi pi-angle-down',
|
|
locale: undefined,
|
|
localeMatcher: undefined,
|
|
mode: 'decimal',
|
|
suffix: null,
|
|
prefix: null,
|
|
currency: undefined,
|
|
currencyDisplay: undefined,
|
|
useGrouping: true,
|
|
minFractionDigits: undefined,
|
|
maxFractionDigits: undefined,
|
|
id: null,
|
|
name: null,
|
|
type: 'text',
|
|
allowEmpty: true,
|
|
step: 1,
|
|
min: null,
|
|
max: null,
|
|
disabled: false,
|
|
required: false,
|
|
tabIndex: null,
|
|
pattern: null,
|
|
inputMode: null,
|
|
placeholder: null,
|
|
readOnly: false,
|
|
size: null,
|
|
style: null,
|
|
className: null,
|
|
inputId: null,
|
|
autoFocus: false,
|
|
inputStyle: null,
|
|
inputClassName: null,
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
ariaLabelledBy: null,
|
|
onValueChange: null,
|
|
onChange: null,
|
|
onBlur: null,
|
|
onFocus: null,
|
|
onKeyDown: null
|
|
});
|
|
|
|
function _createSuper$1E(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1E(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1E() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var JumpToPageInput = /*#__PURE__*/function (_Component) {
|
|
_inherits(JumpToPageInput, _Component);
|
|
|
|
var _super = _createSuper$1E(JumpToPageInput);
|
|
|
|
function JumpToPageInput(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, JumpToPageInput);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onChange = _this.onChange.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(JumpToPageInput, [{
|
|
key: "onChange",
|
|
value: function onChange(event) {
|
|
if (this.props.onChange) {
|
|
this.props.onChange(this.props.rows * (event.value - 1), this.props.rows);
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var value = this.props.pageCount > 0 ? this.props.page + 1 : 0;
|
|
var element = /*#__PURE__*/React.createElement(InputNumber, {
|
|
value: value,
|
|
onChange: this.onChange,
|
|
className: "p-paginator-page-input",
|
|
disabled: this.props.disabled
|
|
});
|
|
|
|
if (this.props.template) {
|
|
var defaultOptions = {
|
|
value: value,
|
|
onChange: this.onChange,
|
|
disabled: this.props.disabled,
|
|
className: 'p-paginator-page-input',
|
|
element: element,
|
|
props: this.props
|
|
};
|
|
return ObjectUtils.getJSXElement(this.props.template, defaultOptions);
|
|
}
|
|
|
|
return element;
|
|
}
|
|
}]);
|
|
|
|
return JumpToPageInput;
|
|
}(Component);
|
|
|
|
_defineProperty(JumpToPageInput, "defaultProps", {
|
|
page: null,
|
|
rows: null,
|
|
pageCount: null,
|
|
disabled: false,
|
|
template: null,
|
|
onChange: null
|
|
});
|
|
|
|
function _createSuper$1D(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1D(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1D() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Paginator = /*#__PURE__*/function (_Component) {
|
|
_inherits(Paginator, _Component);
|
|
|
|
var _super = _createSuper$1D(Paginator);
|
|
|
|
function Paginator(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Paginator);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.changePageToFirst = _this.changePageToFirst.bind(_assertThisInitialized(_this));
|
|
_this.changePageToPrev = _this.changePageToPrev.bind(_assertThisInitialized(_this));
|
|
_this.changePageToNext = _this.changePageToNext.bind(_assertThisInitialized(_this));
|
|
_this.changePageToLast = _this.changePageToLast.bind(_assertThisInitialized(_this));
|
|
_this.onRowsChange = _this.onRowsChange.bind(_assertThisInitialized(_this));
|
|
_this.changePage = _this.changePage.bind(_assertThisInitialized(_this));
|
|
_this.onPageLinkClick = _this.onPageLinkClick.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Paginator, [{
|
|
key: "isFirstPage",
|
|
value: function isFirstPage() {
|
|
return this.getPage() === 0;
|
|
}
|
|
}, {
|
|
key: "isLastPage",
|
|
value: function isLastPage() {
|
|
return this.getPage() === this.getPageCount() - 1;
|
|
}
|
|
}, {
|
|
key: "getPageCount",
|
|
value: function getPageCount() {
|
|
return Math.ceil(this.props.totalRecords / this.props.rows);
|
|
}
|
|
}, {
|
|
key: "calculatePageLinkBoundaries",
|
|
value: function calculatePageLinkBoundaries() {
|
|
var numberOfPages = this.getPageCount();
|
|
var visiblePages = Math.min(this.props.pageLinkSize, numberOfPages); //calculate range, keep current in middle if necessary
|
|
|
|
var start = Math.max(0, Math.ceil(this.getPage() - visiblePages / 2));
|
|
var end = Math.min(numberOfPages - 1, start + visiblePages - 1); //check when approaching to last page
|
|
|
|
var delta = this.props.pageLinkSize - (end - start + 1);
|
|
start = Math.max(0, start - delta);
|
|
return [start, end];
|
|
}
|
|
}, {
|
|
key: "updatePageLinks",
|
|
value: function updatePageLinks() {
|
|
var pageLinks = [];
|
|
var boundaries = this.calculatePageLinkBoundaries();
|
|
var start = boundaries[0];
|
|
var end = boundaries[1];
|
|
|
|
for (var i = start; i <= end; i++) {
|
|
pageLinks.push(i + 1);
|
|
}
|
|
|
|
return pageLinks;
|
|
}
|
|
}, {
|
|
key: "changePage",
|
|
value: function changePage(first, rows) {
|
|
var pc = this.getPageCount();
|
|
var p = Math.floor(first / rows);
|
|
|
|
if (p >= 0 && p < pc) {
|
|
var newPageState = {
|
|
first: first,
|
|
rows: rows,
|
|
page: p,
|
|
pageCount: pc
|
|
};
|
|
|
|
if (this.props.onPageChange) {
|
|
this.props.onPageChange(newPageState);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "getPage",
|
|
value: function getPage() {
|
|
return Math.floor(this.props.first / this.props.rows);
|
|
}
|
|
}, {
|
|
key: "empty",
|
|
value: function empty() {
|
|
var pageCount = this.getPageCount();
|
|
return pageCount === 0;
|
|
}
|
|
}, {
|
|
key: "changePageToFirst",
|
|
value: function changePageToFirst(event) {
|
|
this.changePage(0, this.props.rows);
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "changePageToPrev",
|
|
value: function changePageToPrev(event) {
|
|
this.changePage(this.props.first - this.props.rows, this.props.rows);
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onPageLinkClick",
|
|
value: function onPageLinkClick(event) {
|
|
this.changePage((event.value - 1) * this.props.rows, this.props.rows);
|
|
}
|
|
}, {
|
|
key: "changePageToNext",
|
|
value: function changePageToNext(event) {
|
|
this.changePage(this.props.first + this.props.rows, this.props.rows);
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "changePageToLast",
|
|
value: function changePageToLast(event) {
|
|
this.changePage((this.getPageCount() - 1) * this.props.rows, this.props.rows);
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onRowsChange",
|
|
value: function onRowsChange(event) {
|
|
var rows = event.value;
|
|
this.isRowChanged = rows !== this.props.rows;
|
|
this.changePage(0, rows);
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps, prevState) {
|
|
if (this.props.rows !== prevProps.rows && !this.isRowChanged) {
|
|
this.changePage(0, this.props.rows);
|
|
} else if (this.getPage() > 0 && prevProps.totalRecords !== this.props.totalRecords && this.props.first >= this.props.totalRecords) {
|
|
this.changePage((this.getPageCount() - 1) * this.props.rows, this.props.rows);
|
|
}
|
|
|
|
this.isRowChanged = false;
|
|
}
|
|
}, {
|
|
key: "renderElement",
|
|
value: function renderElement(key, template) {
|
|
var element;
|
|
|
|
switch (key) {
|
|
case 'FirstPageLink':
|
|
element = /*#__PURE__*/React.createElement(FirstPageLink, {
|
|
key: key,
|
|
onClick: this.changePageToFirst,
|
|
disabled: this.isFirstPage() || this.empty(),
|
|
template: template
|
|
});
|
|
break;
|
|
|
|
case 'PrevPageLink':
|
|
element = /*#__PURE__*/React.createElement(PrevPageLink, {
|
|
key: key,
|
|
onClick: this.changePageToPrev,
|
|
disabled: this.isFirstPage() || this.empty(),
|
|
template: template
|
|
});
|
|
break;
|
|
|
|
case 'NextPageLink':
|
|
element = /*#__PURE__*/React.createElement(NextPageLink, {
|
|
key: key,
|
|
onClick: this.changePageToNext,
|
|
disabled: this.isLastPage() || this.empty(),
|
|
template: template
|
|
});
|
|
break;
|
|
|
|
case 'LastPageLink':
|
|
element = /*#__PURE__*/React.createElement(LastPageLink, {
|
|
key: key,
|
|
onClick: this.changePageToLast,
|
|
disabled: this.isLastPage() || this.empty(),
|
|
template: template
|
|
});
|
|
break;
|
|
|
|
case 'PageLinks':
|
|
element = /*#__PURE__*/React.createElement(PageLinks, {
|
|
key: key,
|
|
value: this.updatePageLinks(),
|
|
page: this.getPage(),
|
|
rows: this.props.rows,
|
|
pageCount: this.getPageCount(),
|
|
onClick: this.onPageLinkClick,
|
|
template: template
|
|
});
|
|
break;
|
|
|
|
case 'RowsPerPageDropdown':
|
|
element = /*#__PURE__*/React.createElement(RowsPerPageDropdown, {
|
|
key: key,
|
|
value: this.props.rows,
|
|
page: this.getPage(),
|
|
pageCount: this.getPageCount(),
|
|
totalRecords: this.props.totalRecords,
|
|
options: this.props.rowsPerPageOptions,
|
|
onChange: this.onRowsChange,
|
|
appendTo: this.props.dropdownAppendTo,
|
|
template: template,
|
|
disabled: this.empty()
|
|
});
|
|
break;
|
|
|
|
case 'CurrentPageReport':
|
|
element = /*#__PURE__*/React.createElement(CurrentPageReport, {
|
|
reportTemplate: this.props.currentPageReportTemplate,
|
|
key: key,
|
|
page: this.getPage(),
|
|
pageCount: this.getPageCount(),
|
|
first: this.props.first,
|
|
rows: this.props.rows,
|
|
totalRecords: this.props.totalRecords,
|
|
template: template
|
|
});
|
|
break;
|
|
|
|
case 'JumpToPageInput':
|
|
element = /*#__PURE__*/React.createElement(JumpToPageInput, {
|
|
key: key,
|
|
rows: this.props.rows,
|
|
page: this.getPage(),
|
|
pageCount: this.getPageCount(),
|
|
onChange: this.changePage,
|
|
disabled: this.empty(),
|
|
template: template
|
|
});
|
|
break;
|
|
|
|
default:
|
|
element = null;
|
|
break;
|
|
}
|
|
|
|
return element;
|
|
}
|
|
}, {
|
|
key: "renderElements",
|
|
value: function renderElements() {
|
|
var _this2 = this;
|
|
|
|
var template = this.props.template;
|
|
|
|
if (template) {
|
|
if (_typeof(template) === 'object') {
|
|
return template.layout ? template.layout.split(' ').map(function (value) {
|
|
var key = value.trim();
|
|
return _this2.renderElement(key, template[key]);
|
|
}) : Object.entries(template).map(function (_ref) {
|
|
var _ref2 = _slicedToArray(_ref, 2),
|
|
key = _ref2[0],
|
|
_template = _ref2[1];
|
|
|
|
return _this2.renderElement(key, _template);
|
|
});
|
|
}
|
|
|
|
return template.split(' ').map(function (value) {
|
|
return _this2.renderElement(value.trim());
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
if (!this.props.alwaysShow && this.getPageCount() === 1) {
|
|
return null;
|
|
} else {
|
|
var className = classNames('p-paginator p-component', this.props.className);
|
|
var leftContent = ObjectUtils.getJSXElement(this.props.leftContent, this.props);
|
|
var rightContent = ObjectUtils.getJSXElement(this.props.rightContent, this.props);
|
|
var elements = this.renderElements();
|
|
var leftElement = leftContent && /*#__PURE__*/React.createElement("div", {
|
|
className: "p-paginator-left-content"
|
|
}, leftContent);
|
|
var rightElement = rightContent && /*#__PURE__*/React.createElement("div", {
|
|
className: "p-paginator-right-content"
|
|
}, rightContent);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: className,
|
|
style: this.props.style
|
|
}, leftElement, elements, rightElement);
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return Paginator;
|
|
}(Component);
|
|
|
|
_defineProperty(Paginator, "defaultProps", {
|
|
totalRecords: 0,
|
|
rows: 0,
|
|
first: 0,
|
|
pageLinkSize: 5,
|
|
rowsPerPageOptions: null,
|
|
alwaysShow: true,
|
|
style: null,
|
|
className: null,
|
|
template: 'FirstPageLink PrevPageLink PageLinks NextPageLink LastPageLink RowsPerPageDropdown',
|
|
onPageChange: null,
|
|
leftContent: null,
|
|
rightContent: null,
|
|
dropdownAppendTo: null,
|
|
currentPageReportTemplate: '({currentPage} of {totalPages})'
|
|
});
|
|
|
|
function _objectWithoutPropertiesLoose(source, excluded) {
|
|
if (source == null) return {};
|
|
var target = {};
|
|
var sourceKeys = Object.keys(source);
|
|
var key, i;
|
|
|
|
for (i = 0; i < sourceKeys.length; i++) {
|
|
key = sourceKeys[i];
|
|
if (excluded.indexOf(key) >= 0) continue;
|
|
target[key] = source[key];
|
|
}
|
|
|
|
return target;
|
|
}
|
|
|
|
function _objectWithoutProperties(source, excluded) {
|
|
if (source == null) return {};
|
|
var target = _objectWithoutPropertiesLoose(source, excluded);
|
|
var key, i;
|
|
|
|
if (Object.getOwnPropertySymbols) {
|
|
var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
|
|
|
|
for (i = 0; i < sourceSymbolKeys.length; i++) {
|
|
key = sourceSymbolKeys[i];
|
|
if (excluded.indexOf(key) >= 0) continue;
|
|
if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
|
|
target[key] = source[key];
|
|
}
|
|
}
|
|
|
|
return target;
|
|
}
|
|
|
|
function _createSuper$1C(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1C(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1C() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var RowRadioButton = /*#__PURE__*/function (_Component) {
|
|
_inherits(RowRadioButton, _Component);
|
|
|
|
var _super = _createSuper$1C(RowRadioButton);
|
|
|
|
function RowRadioButton(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, RowRadioButton);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
focused: false
|
|
};
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onFocus = _this.onFocus.bind(_assertThisInitialized(_this));
|
|
_this.onBlur = _this.onBlur.bind(_assertThisInitialized(_this));
|
|
_this.onChange = _this.onChange.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(RowRadioButton, [{
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
if (!this.props.disabled) {
|
|
this.props.onChange(event);
|
|
this.input.focus();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onFocus",
|
|
value: function onFocus() {
|
|
this.setState({
|
|
focused: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "onBlur",
|
|
value: function onBlur() {
|
|
this.setState({
|
|
focused: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "onChange",
|
|
value: function onChange(event) {
|
|
this.onClick(event);
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event) {
|
|
if (event.code === 'Space') {
|
|
this.onClick(event);
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this2 = this;
|
|
|
|
var className = classNames('p-radiobutton p-component', {
|
|
'p-radiobutton-focused': this.state.focused
|
|
});
|
|
var boxClassName = classNames('p-radiobutton-box p-component', {
|
|
'p-highlight': this.props.checked,
|
|
'p-focus': this.state.focused,
|
|
'p-disabled': this.props.disabled
|
|
});
|
|
var name = "".concat(this.props.tableSelector, "_dt_radio");
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: className
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-hidden-accessible"
|
|
}, /*#__PURE__*/React.createElement("input", {
|
|
name: name,
|
|
ref: function ref(el) {
|
|
return _this2.input = el;
|
|
},
|
|
type: "radio",
|
|
checked: this.props.checked,
|
|
onFocus: this.onFocus,
|
|
onBlur: this.onBlur,
|
|
onChange: this.onChange,
|
|
onKeyDown: this.onKeyDown
|
|
})), /*#__PURE__*/React.createElement("div", {
|
|
className: boxClassName,
|
|
onClick: this.onClick,
|
|
role: "radio",
|
|
"aria-checked": this.props.checked
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-radiobutton-icon"
|
|
})));
|
|
}
|
|
}]);
|
|
|
|
return RowRadioButton;
|
|
}(Component);
|
|
|
|
function _createSuper$1B(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1B(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1B() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var RowCheckbox = /*#__PURE__*/function (_Component) {
|
|
_inherits(RowCheckbox, _Component);
|
|
|
|
var _super = _createSuper$1B(RowCheckbox);
|
|
|
|
function RowCheckbox(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, RowCheckbox);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
focused: false
|
|
};
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onFocus = _this.onFocus.bind(_assertThisInitialized(_this));
|
|
_this.onBlur = _this.onBlur.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(RowCheckbox, [{
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
if (!this.props.disabled) {
|
|
this.setState({
|
|
focused: true
|
|
});
|
|
this.props.onChange(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onFocus",
|
|
value: function onFocus() {
|
|
this.setState({
|
|
focused: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "onBlur",
|
|
value: function onBlur() {
|
|
this.setState({
|
|
focused: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event) {
|
|
if (event.code === 'Space') {
|
|
this.onClick(event);
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-checkbox p-component', {
|
|
'p-checkbox-focused': this.state.focused
|
|
});
|
|
var boxClassName = classNames('p-checkbox-box p-component', {
|
|
'p-highlight': this.props.checked,
|
|
'p-disabled': this.props.disabled,
|
|
'p-focus': this.state.focused
|
|
});
|
|
var iconClassName = classNames('p-checkbox-icon', {
|
|
'pi pi-check': this.props.checked
|
|
});
|
|
var tabIndex = this.props.disabled ? null : '0';
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: className,
|
|
onClick: this.onClick
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: boxClassName,
|
|
role: "checkbox",
|
|
"aria-checked": this.props.checked,
|
|
tabIndex: tabIndex,
|
|
onKeyDown: this.onKeyDown,
|
|
onFocus: this.onFocus,
|
|
onBlur: this.onBlur
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
})));
|
|
}
|
|
}]);
|
|
|
|
return RowCheckbox;
|
|
}(Component);
|
|
|
|
function ownKeys$z(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$z(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$z(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$z(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$1A(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1A(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1A() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var BodyCell = /*#__PURE__*/function (_Component) {
|
|
_inherits(BodyCell, _Component);
|
|
|
|
var _super = _createSuper$1A(BodyCell);
|
|
|
|
function BodyCell(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, BodyCell);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
editing: props.editing,
|
|
editingRowData: props.rowData,
|
|
styleObject: {}
|
|
};
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onMouseDown = _this.onMouseDown.bind(_assertThisInitialized(_this));
|
|
_this.onMouseUp = _this.onMouseUp.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onBlur = _this.onBlur.bind(_assertThisInitialized(_this));
|
|
_this.onEditorFocus = _this.onEditorFocus.bind(_assertThisInitialized(_this));
|
|
_this.onRowToggle = _this.onRowToggle.bind(_assertThisInitialized(_this));
|
|
_this.onRadioChange = _this.onRadioChange.bind(_assertThisInitialized(_this));
|
|
_this.onCheckboxChange = _this.onCheckboxChange.bind(_assertThisInitialized(_this));
|
|
_this.onRowEditSave = _this.onRowEditSave.bind(_assertThisInitialized(_this));
|
|
_this.onRowEditCancel = _this.onRowEditCancel.bind(_assertThisInitialized(_this));
|
|
_this.onRowEditInit = _this.onRowEditInit.bind(_assertThisInitialized(_this));
|
|
_this.editorCallback = _this.editorCallback.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(BodyCell, [{
|
|
key: "field",
|
|
get: function get() {
|
|
return this.getColumnProp('field') || "field_".concat(this.props.index);
|
|
}
|
|
}, {
|
|
key: "isEditable",
|
|
value: function isEditable() {
|
|
return this.getColumnProp('editor');
|
|
}
|
|
}, {
|
|
key: "isSelected",
|
|
value: function isSelected() {
|
|
return this.props.selection ? this.props.selection instanceof Array ? this.findIndex(this.props.selection) > -1 : this.equals(this.props.selection) : false;
|
|
}
|
|
}, {
|
|
key: "equalsData",
|
|
value: function equalsData(data) {
|
|
return this.props.compareSelectionBy === 'equals' ? data === this.props.rowData : ObjectUtils.equals(data, this.props.rowData, this.props.dataKey);
|
|
}
|
|
}, {
|
|
key: "equals",
|
|
value: function equals(selectedCell) {
|
|
return (selectedCell.rowIndex === this.props.rowIndex || this.equalsData(selectedCell.rowData)) && (selectedCell.field === this.field || selectedCell.cellIndex === this.props.index);
|
|
}
|
|
}, {
|
|
key: "isOutsideClicked",
|
|
value: function isOutsideClicked(target) {
|
|
return this.el && !(this.el.isSameNode(target) || this.el.contains(target));
|
|
}
|
|
}, {
|
|
key: "getColumnProp",
|
|
value: function getColumnProp(prop) {
|
|
return this.props.column ? this.props.column.props[prop] : null;
|
|
}
|
|
}, {
|
|
key: "getVirtualScrollerOption",
|
|
value: function getVirtualScrollerOption(option) {
|
|
return this.props.virtualScrollerOptions ? this.props.virtualScrollerOptions[option] : null;
|
|
}
|
|
}, {
|
|
key: "getStyle",
|
|
value: function getStyle() {
|
|
var bodyStyle = this.getColumnProp('bodyStyle');
|
|
var columnStyle = this.getColumnProp('style');
|
|
return this.getColumnProp('frozen') ? Object.assign({}, columnStyle, bodyStyle, this.state.styleObject) : Object.assign({}, columnStyle, bodyStyle);
|
|
}
|
|
}, {
|
|
key: "getCellParams",
|
|
value: function getCellParams() {
|
|
return {
|
|
value: this.resolveFieldData(),
|
|
field: this.field,
|
|
rowData: this.props.rowData,
|
|
rowIndex: this.props.rowIndex,
|
|
cellIndex: this.props.index,
|
|
selected: this.isSelected(),
|
|
column: this.props.column,
|
|
props: this.props
|
|
};
|
|
}
|
|
}, {
|
|
key: "getCellCallbackParams",
|
|
value: function getCellCallbackParams(event) {
|
|
var params = this.getCellParams();
|
|
return _objectSpread$z({
|
|
originalEvent: event
|
|
}, params);
|
|
}
|
|
}, {
|
|
key: "resolveFieldData",
|
|
value: function resolveFieldData(data) {
|
|
return ObjectUtils.resolveFieldData(data || this.props.rowData, this.field);
|
|
}
|
|
}, {
|
|
key: "getEditingRowData",
|
|
value: function getEditingRowData() {
|
|
return this.props.editingMeta && this.props.editingMeta[this.props.rowIndex] ? this.props.editingMeta[this.props.rowIndex].data : this.props.rowData;
|
|
}
|
|
}, {
|
|
key: "getTabIndex",
|
|
value: function getTabIndex(cellSelected) {
|
|
return this.props.allowCellSelection ? cellSelected ? 0 : this.props.rowIndex === 0 && this.props.index === 0 ? this.props.tabIndex : -1 : null;
|
|
}
|
|
}, {
|
|
key: "findIndex",
|
|
value: function findIndex(collection) {
|
|
var _this2 = this;
|
|
|
|
return (collection || []).findIndex(function (data) {
|
|
return _this2.equals(data);
|
|
});
|
|
}
|
|
}, {
|
|
key: "closeCell",
|
|
value: function closeCell(event) {
|
|
var _this3 = this;
|
|
|
|
var params = this.getCellCallbackParams(event);
|
|
var onBeforeCellEditHide = this.getColumnProp('onBeforeCellEditHide');
|
|
|
|
if (onBeforeCellEditHide) {
|
|
onBeforeCellEditHide(params);
|
|
}
|
|
/* When using the 'tab' key, the focus event of the next cell is not called in IE. */
|
|
|
|
|
|
setTimeout(function () {
|
|
_this3.setState({
|
|
editing: false
|
|
}, function () {
|
|
_this3.unbindDocumentEditListener();
|
|
|
|
OverlayService.off('overlay-click', _this3.overlayEventListener);
|
|
_this3.overlayEventListener = null;
|
|
});
|
|
}, 1);
|
|
}
|
|
}, {
|
|
key: "switchCellToViewMode",
|
|
value: function switchCellToViewMode(event, submit) {
|
|
var callbackParams = this.getCellCallbackParams(event);
|
|
var newRowData = this.state.editingRowData;
|
|
var newValue = this.resolveFieldData(newRowData);
|
|
|
|
var params = _objectSpread$z(_objectSpread$z({}, callbackParams), {}, {
|
|
newRowData: newRowData,
|
|
newValue: newValue
|
|
});
|
|
|
|
var onCellEditCancel = this.getColumnProp('onCellEditCancel');
|
|
var cellEditValidator = this.getColumnProp('cellEditValidator');
|
|
var onCellEditComplete = this.getColumnProp('onCellEditComplete');
|
|
|
|
if (!submit && onCellEditCancel) {
|
|
onCellEditCancel(params);
|
|
}
|
|
|
|
var valid = true;
|
|
|
|
if (cellEditValidator) {
|
|
valid = cellEditValidator(params);
|
|
}
|
|
|
|
if (valid) {
|
|
if (submit && onCellEditComplete) {
|
|
onCellEditComplete(params);
|
|
}
|
|
|
|
this.closeCell(event);
|
|
} else {
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "findNextSelectableCell",
|
|
value: function findNextSelectableCell(cell) {
|
|
var nextCell = cell.nextElementSibling;
|
|
return nextCell ? DomHandler.hasClass(nextCell, 'p-selectable-cell') ? nextCell : this.findNextSelectableCell(nextCell) : null;
|
|
}
|
|
}, {
|
|
key: "findPrevSelectableCell",
|
|
value: function findPrevSelectableCell(cell) {
|
|
var prevCell = cell.previousElementSibling;
|
|
return prevCell ? DomHandler.hasClass(prevCell, 'p-selectable-cell') ? prevCell : this.findPrevSelectableCell(prevCell) : null;
|
|
}
|
|
}, {
|
|
key: "findDownSelectableCell",
|
|
value: function findDownSelectableCell(cell) {
|
|
var downRow = cell.parentElement.nextElementSibling;
|
|
var downCell = downRow ? downRow.children[this.props.index] : null;
|
|
return downRow && downCell ? DomHandler.hasClass(downRow, 'p-selectable-row') && DomHandler.hasClass(downCell, 'p-selectable-cell') ? downCell : this.findDownSelectableCell(downCell) : null;
|
|
}
|
|
}, {
|
|
key: "findUpSelectableCell",
|
|
value: function findUpSelectableCell(cell) {
|
|
var upRow = cell.parentElement.previousElementSibling;
|
|
var upCell = upRow ? upRow.children[this.props.index] : null;
|
|
return upRow && upCell ? DomHandler.hasClass(upRow, 'p-selectable-row') && DomHandler.hasClass(upCell, 'p-selectable-cell') ? upCell : this.findUpSelectableCell(upCell) : null;
|
|
}
|
|
}, {
|
|
key: "changeTabIndex",
|
|
value: function changeTabIndex(currentCell, nextCell) {
|
|
if (currentCell && nextCell) {
|
|
currentCell.tabIndex = -1;
|
|
nextCell.tabIndex = this.props.tabIndex;
|
|
}
|
|
}
|
|
}, {
|
|
key: "focusOnElement",
|
|
value: function focusOnElement() {
|
|
var _this4 = this;
|
|
|
|
clearTimeout(this.tabindexTimeout);
|
|
this.tabindexTimeout = setTimeout(function () {
|
|
if (_this4.state.editing) {
|
|
var focusableEl = _this4.props.editMode === 'cell' ? DomHandler.getFirstFocusableElement(_this4.el, ':not(.p-cell-editor-key-helper)') : DomHandler.findSingle(_this4.el, '.p-row-editor-save');
|
|
focusableEl && focusableEl.focus();
|
|
}
|
|
|
|
_this4.keyHelper && (_this4.keyHelper.tabIndex = _this4.state.editing ? -1 : 0);
|
|
}, 1);
|
|
}
|
|
}, {
|
|
key: "focusOnInit",
|
|
value: function focusOnInit() {
|
|
var _this5 = this;
|
|
|
|
clearTimeout(this.initFocusTimeout);
|
|
this.initFocusTimeout = setTimeout(function () {
|
|
var focusableEl = _this5.props.editMode === 'row' ? DomHandler.findSingle(_this5.el, '.p-row-editor-init') : null;
|
|
focusableEl && focusableEl.focus();
|
|
}, 1);
|
|
}
|
|
}, {
|
|
key: "updateStickyPosition",
|
|
value: function updateStickyPosition() {
|
|
if (this.getColumnProp('frozen')) {
|
|
var styleObject = _objectSpread$z({}, this.state.styleObject);
|
|
|
|
var align = this.getColumnProp('alignFrozen');
|
|
|
|
if (align === 'right') {
|
|
var right = 0;
|
|
var next = this.el.nextElementSibling;
|
|
|
|
if (next) {
|
|
right = DomHandler.getOuterWidth(next) + parseFloat(next.style.right || 0);
|
|
}
|
|
|
|
styleObject['right'] = right + 'px';
|
|
} else {
|
|
var left = 0;
|
|
var prev = this.el.previousElementSibling;
|
|
|
|
if (prev) {
|
|
left = DomHandler.getOuterWidth(prev) + parseFloat(prev.style.left || 0);
|
|
}
|
|
|
|
styleObject['left'] = left + 'px';
|
|
}
|
|
|
|
var isSameStyle = this.state.styleObject['left'] === styleObject['left'] && this.state.styleObject['right'] === styleObject['right'];
|
|
!isSameStyle && this.setState({
|
|
styleObject: styleObject
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "editorCallback",
|
|
value: function editorCallback(val) {
|
|
var editingRowData = _objectSpread$z({}, this.state.editingRowData);
|
|
|
|
editingRowData[this.field] = val;
|
|
this.setState({
|
|
editingRowData: editingRowData
|
|
}); // update editing meta for complete methods on row mode
|
|
|
|
this.props.editingMeta[this.props.rowIndex].data[this.field] = val;
|
|
}
|
|
}, {
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
var _this6 = this;
|
|
|
|
var params = this.getCellCallbackParams(event);
|
|
|
|
if (this.props.editMode !== 'row' && this.isEditable() && !this.state.editing && (this.props.selectOnEdit || !this.props.selectOnEdit && this.props.selected)) {
|
|
this.selfClick = true;
|
|
var onBeforeCellEditShow = this.getColumnProp('onBeforeCellEditShow');
|
|
var onCellEditInit = this.getColumnProp('onCellEditInit');
|
|
var cellEditValidatorEvent = this.getColumnProp('cellEditValidatorEvent');
|
|
|
|
if (onBeforeCellEditShow) {
|
|
onBeforeCellEditShow(params);
|
|
} // If the data is sorted using sort icon, it has been added to wait for the sort operation when any cell is wanted to be opened.
|
|
|
|
|
|
setTimeout(function () {
|
|
_this6.setState({
|
|
editing: true
|
|
}, function () {
|
|
if (onCellEditInit) {
|
|
onCellEditInit(params);
|
|
}
|
|
|
|
if (cellEditValidatorEvent === 'click') {
|
|
_this6.bindDocumentEditListener();
|
|
|
|
_this6.overlayEventListener = function (e) {
|
|
if (!_this6.isOutsideClicked(e.target)) {
|
|
_this6.selfClick = true;
|
|
}
|
|
};
|
|
|
|
OverlayService.on('overlay-click', _this6.overlayEventListener);
|
|
}
|
|
});
|
|
}, 1);
|
|
}
|
|
|
|
if (this.props.allowCellSelection && this.props.onClick) {
|
|
this.props.onClick(params);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onMouseDown",
|
|
value: function onMouseDown(event) {
|
|
var params = this.getCellCallbackParams(event);
|
|
|
|
if (this.props.onMouseDown) {
|
|
this.props.onMouseDown(params);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onMouseUp",
|
|
value: function onMouseUp(event) {
|
|
var params = this.getCellCallbackParams(event);
|
|
|
|
if (this.props.onMouseUp) {
|
|
this.props.onMouseUp(params);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event) {
|
|
if (this.props.editMode !== 'row') {
|
|
if (event.which === 13 || event.which === 9) {
|
|
// tab || enter
|
|
this.switchCellToViewMode(event, true);
|
|
}
|
|
|
|
if (event.which === 27) {
|
|
// escape
|
|
this.switchCellToViewMode(event, false);
|
|
}
|
|
}
|
|
|
|
if (this.props.allowCellSelection) {
|
|
var target = event.target,
|
|
cell = event.currentTarget;
|
|
|
|
switch (event.which) {
|
|
//left arrow
|
|
case 37:
|
|
var prevCell = this.findPrevSelectableCell(cell);
|
|
|
|
if (prevCell) {
|
|
this.changeTabIndex(cell, prevCell);
|
|
prevCell.focus();
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//right arrow
|
|
|
|
case 39:
|
|
var nextCell = this.findNextSelectableCell(cell);
|
|
|
|
if (nextCell) {
|
|
this.changeTabIndex(cell, nextCell);
|
|
nextCell.focus();
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//up arrow
|
|
|
|
case 38:
|
|
var upCell = this.findUpSelectableCell(cell);
|
|
|
|
if (upCell) {
|
|
this.changeTabIndex(cell, upCell);
|
|
upCell.focus();
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//down arrow
|
|
|
|
case 40:
|
|
var downCell = this.findDownSelectableCell(cell);
|
|
|
|
if (downCell) {
|
|
this.changeTabIndex(cell, downCell);
|
|
downCell.focus();
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//enter
|
|
|
|
case 13:
|
|
// @deprecated
|
|
if (!DomHandler.isClickable(target)) {
|
|
this.onClick(event);
|
|
event.preventDefault();
|
|
}
|
|
|
|
break;
|
|
//space
|
|
|
|
case 32:
|
|
if (!DomHandler.isClickable(target) && !target.readOnly) {
|
|
this.onClick(event);
|
|
event.preventDefault();
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onBlur",
|
|
value: function onBlur(event) {
|
|
this.selfClick = false;
|
|
|
|
if (this.props.editMode !== 'row' && this.state.editing && this.getColumnProp('cellEditValidatorEvent') === 'blur') {
|
|
this.switchCellToViewMode(event, true);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onEditorFocus",
|
|
value: function onEditorFocus(event) {
|
|
this.onClick(event);
|
|
}
|
|
}, {
|
|
key: "onRadioChange",
|
|
value: function onRadioChange(event) {
|
|
this.props.onRadioChange({
|
|
originalEvent: event,
|
|
data: this.props.rowData,
|
|
index: this.props.rowIndex
|
|
});
|
|
}
|
|
}, {
|
|
key: "onCheckboxChange",
|
|
value: function onCheckboxChange(event) {
|
|
this.props.onCheckboxChange({
|
|
originalEvent: event,
|
|
data: this.props.rowData,
|
|
index: this.props.rowIndex
|
|
});
|
|
}
|
|
}, {
|
|
key: "onRowToggle",
|
|
value: function onRowToggle(event) {
|
|
this.props.onRowToggle({
|
|
originalEvent: event,
|
|
data: this.props.rowData
|
|
});
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onRowEditInit",
|
|
value: function onRowEditInit(event) {
|
|
this.props.onRowEditInit({
|
|
originalEvent: event,
|
|
data: this.props.rowData,
|
|
newData: this.getEditingRowData(),
|
|
field: this.field,
|
|
index: this.props.rowIndex
|
|
});
|
|
}
|
|
}, {
|
|
key: "onRowEditSave",
|
|
value: function onRowEditSave(event) {
|
|
this.props.onRowEditSave({
|
|
originalEvent: event,
|
|
data: this.props.rowData,
|
|
newData: this.getEditingRowData(),
|
|
field: this.field,
|
|
index: this.props.rowIndex
|
|
});
|
|
this.focusOnInit();
|
|
}
|
|
}, {
|
|
key: "onRowEditCancel",
|
|
value: function onRowEditCancel(event) {
|
|
this.props.onRowEditCancel({
|
|
originalEvent: event,
|
|
data: this.props.rowData,
|
|
newData: this.getEditingRowData(),
|
|
field: this.field,
|
|
index: this.props.rowIndex
|
|
});
|
|
this.focusOnInit();
|
|
}
|
|
}, {
|
|
key: "bindDocumentEditListener",
|
|
value: function bindDocumentEditListener() {
|
|
var _this7 = this;
|
|
|
|
if (!this.documentEditListener) {
|
|
this.documentEditListener = function (e) {
|
|
if (!_this7.selfClick && _this7.isOutsideClicked(e.target)) {
|
|
_this7.switchCellToViewMode(e, true);
|
|
}
|
|
|
|
_this7.selfClick = false;
|
|
};
|
|
|
|
document.addEventListener('click', this.documentEditListener, true);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentEditListener",
|
|
value: function unbindDocumentEditListener() {
|
|
if (this.documentEditListener) {
|
|
document.removeEventListener('click', this.documentEditListener, true);
|
|
this.documentEditListener = null;
|
|
this.selfClick = false;
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (this.getColumnProp('frozen')) {
|
|
this.updateStickyPosition();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps, prevState) {
|
|
if (this.getColumnProp('frozen')) {
|
|
this.updateStickyPosition();
|
|
}
|
|
|
|
if (this.props.editMode === 'cell' || this.props.editMode === 'row') {
|
|
this.focusOnElement();
|
|
|
|
if (prevProps.editingMeta !== this.props.editingMeta) {
|
|
this.setState({
|
|
editingRowData: this.getEditingRowData()
|
|
});
|
|
}
|
|
|
|
if (prevState.editing !== this.state.editing) {
|
|
var callbackParams = this.getCellCallbackParams();
|
|
|
|
var params = _objectSpread$z(_objectSpread$z({}, callbackParams), {}, {
|
|
editing: this.state.editing
|
|
});
|
|
|
|
this.props.onEditingMetaChange(params);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.unbindDocumentEditListener();
|
|
|
|
if (this.overlayEventListener) {
|
|
OverlayService.off('overlay-click', this.overlayEventListener);
|
|
this.overlayEventListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderLoading",
|
|
value: function renderLoading() {
|
|
var options = this.getVirtualScrollerOption('getLoaderOptions')(this.props.rowIndex, {
|
|
cellIndex: this.props.index,
|
|
cellFirst: this.props.index === 0,
|
|
cellLast: this.props.index === this.getVirtualScrollerOption('columns').length - 1,
|
|
cellEven: this.props.index % 2 === 0,
|
|
cellOdd: this.props.index % 2 !== 0,
|
|
column: this.props.column,
|
|
field: this.field
|
|
});
|
|
var content = ObjectUtils.getJSXElement(this.getVirtualScrollerOption('loadingTemplate'), options);
|
|
return /*#__PURE__*/React.createElement("td", null, content);
|
|
}
|
|
}, {
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
var _this8 = this;
|
|
|
|
var content, editorKeyHelper;
|
|
var cellSelected = this.props.allowCellSelection && this.isSelected();
|
|
var isRowEditor = this.props.editMode === 'row';
|
|
var tabIndex = this.getTabIndex(cellSelected);
|
|
var selectionMode = this.getColumnProp('selectionMode');
|
|
var rowReorder = this.getColumnProp('rowReorder');
|
|
var expander = this.getColumnProp('expander');
|
|
var rowEditor = this.getColumnProp('rowEditor');
|
|
var header = this.getColumnProp('header');
|
|
var body = this.getColumnProp('body');
|
|
var editor = this.getColumnProp('editor');
|
|
var frozen = this.getColumnProp('frozen');
|
|
var align = this.getColumnProp('align');
|
|
var value = this.resolveFieldData();
|
|
var cellClassName = ObjectUtils.getPropValue(this.props.cellClassName, value, {
|
|
props: this.props.tableProps,
|
|
rowData: this.props.rowData,
|
|
column: this.props.column
|
|
});
|
|
var className = classNames(this.getColumnProp('bodyClassName'), this.getColumnProp('className'), cellClassName, _defineProperty({
|
|
'p-selection-column': selectionMode !== null,
|
|
'p-editable-column': editor,
|
|
'p-cell-editing': editor && this.state.editing,
|
|
'p-frozen-column': frozen,
|
|
'p-selectable-cell': this.props.allowCellSelection && this.props.isSelectable({
|
|
data: this.getCellParams(),
|
|
index: this.props.rowIndex
|
|
}),
|
|
'p-highlight': cellSelected
|
|
}, "p-align-".concat(align), !!align));
|
|
var style = this.getStyle();
|
|
var title = this.props.responsiveLayout === 'stack' && /*#__PURE__*/React.createElement("span", {
|
|
className: "p-column-title"
|
|
}, ObjectUtils.getJSXElement(header, {
|
|
props: this.props.tableProps
|
|
}));
|
|
|
|
if (selectionMode) {
|
|
var showSelection = this.props.showSelectionElement ? this.props.showSelectionElement(this.props.rowData, {
|
|
rowIndex: this.props.rowIndex,
|
|
props: this.props.tableProps
|
|
}) : true;
|
|
content = showSelection && /*#__PURE__*/React.createElement(React.Fragment, null, selectionMode === 'single' && /*#__PURE__*/React.createElement(RowRadioButton, {
|
|
checked: this.props.selected,
|
|
onChange: this.onRadioChange,
|
|
tabIndex: this.props.tabIndex,
|
|
tableSelector: this.props.tableSelector
|
|
}), selectionMode === 'multiple' && /*#__PURE__*/React.createElement(RowCheckbox, {
|
|
checked: this.props.selected,
|
|
onChange: this.onCheckboxChange,
|
|
tabIndex: this.props.tabIndex
|
|
}));
|
|
} else if (rowReorder) {
|
|
var showReorder = this.props.showRowReorderElement ? this.props.showRowReorderElement(this.props.rowData, {
|
|
rowIndex: this.props.rowIndex,
|
|
props: this.props.tableProps
|
|
}) : true;
|
|
content = showReorder && /*#__PURE__*/React.createElement("i", {
|
|
className: classNames('p-datatable-reorderablerow-handle', this.getColumnProp('rowReorderIcon'))
|
|
});
|
|
} else if (expander) {
|
|
var iconClassName = classNames('p-row-toggler-icon', this.props.expanded ? this.props.expandedRowIcon : this.props.collapsedRowIcon);
|
|
var ariaControls = "".concat(this.props.tableSelector, "_content_").concat(this.props.rowIndex, "_expanded");
|
|
var expanderProps = {
|
|
onClick: this.onRowToggle,
|
|
className: 'p-row-toggler p-link',
|
|
iconClassName: iconClassName
|
|
};
|
|
content = /*#__PURE__*/React.createElement("button", {
|
|
className: expanderProps.className,
|
|
onClick: expanderProps.onClick,
|
|
type: "button",
|
|
"aria-expanded": this.props.expanded,
|
|
"aria-controls": ariaControls,
|
|
tabIndex: this.props.tabIndex
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: expanderProps.iconClassName
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
|
|
if (body) {
|
|
expanderProps['element'] = content;
|
|
content = ObjectUtils.getJSXElement(body, this.props.rowData, {
|
|
column: this.props.column,
|
|
field: this.field,
|
|
rowIndex: this.props.rowIndex,
|
|
frozenRow: this.props.frozenRow,
|
|
props: this.props.tableProps,
|
|
expander: expanderProps
|
|
});
|
|
}
|
|
} else if (isRowEditor && rowEditor) {
|
|
var rowEditorProps = {};
|
|
|
|
if (this.state.editing) {
|
|
rowEditorProps = {
|
|
editing: true,
|
|
onSaveClick: this.onRowEditSave,
|
|
saveClassName: 'p-row-editor-save p-link',
|
|
saveIconClassName: 'p-row-editor-save-icon pi pi-fw pi-check',
|
|
onCancelClick: this.onRowEditCancel,
|
|
cancelClassName: 'p-row-editor-cancel p-link',
|
|
cancelIconClassName: 'p-row-editor-cancel-icon pi pi-fw pi-times'
|
|
};
|
|
content = /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
onClick: rowEditorProps.onSaveClick,
|
|
className: rowEditorProps.saveClassName,
|
|
tabIndex: this.props.tabIndex
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: rowEditorProps.saveIconClassName
|
|
}), /*#__PURE__*/React.createElement(Ripple, null)), /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
onClick: rowEditorProps.onCancelClick,
|
|
className: rowEditorProps.cancelClassName,
|
|
tabIndex: this.props.tabIndex
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: rowEditorProps.cancelIconClassName
|
|
}), /*#__PURE__*/React.createElement(Ripple, null)));
|
|
} else {
|
|
rowEditorProps = {
|
|
editing: false,
|
|
onInitClick: this.onRowEditInit,
|
|
initClassName: 'p-row-editor-init p-link',
|
|
initIconClassName: 'p-row-editor-init-icon pi pi-fw pi-pencil'
|
|
};
|
|
content = /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
onClick: rowEditorProps.onInitClick,
|
|
className: rowEditorProps.initClassName,
|
|
tabIndex: this.props.tabIndex
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: rowEditorProps.initIconClassName
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
|
|
if (body) {
|
|
rowEditorProps['element'] = content;
|
|
content = ObjectUtils.getJSXElement(body, this.props.rowData, {
|
|
column: this.props.column,
|
|
field: this.field,
|
|
rowIndex: this.props.rowIndex,
|
|
frozenRow: this.props.frozenRow,
|
|
props: this.props.tableProps,
|
|
rowEditor: rowEditorProps
|
|
});
|
|
}
|
|
} else if (body && !this.state.editing) {
|
|
content = body ? ObjectUtils.getJSXElement(body, this.props.rowData, {
|
|
column: this.props.column,
|
|
field: this.field,
|
|
rowIndex: this.props.rowIndex,
|
|
frozenRow: this.props.frozenRow,
|
|
props: this.props.tableProps
|
|
}) : value;
|
|
} else if (editor && this.state.editing) {
|
|
content = ObjectUtils.getJSXElement(editor, {
|
|
rowData: this.state.editingRowData,
|
|
value: this.resolveFieldData(this.state.editingRowData),
|
|
column: this.props.column,
|
|
field: this.field,
|
|
rowIndex: this.props.rowIndex,
|
|
frozenRow: this.props.frozenRow,
|
|
props: this.props.tableProps,
|
|
editorCallback: this.editorCallback
|
|
});
|
|
} else {
|
|
content = value;
|
|
}
|
|
|
|
if (!isRowEditor && editor) {
|
|
/* eslint-disable */
|
|
editorKeyHelper = /*#__PURE__*/React.createElement("a", {
|
|
tabIndex: "0",
|
|
ref: function ref(el) {
|
|
return _this8.keyHelper = el;
|
|
},
|
|
className: "p-cell-editor-key-helper p-hidden-accessible",
|
|
onFocus: this.onEditorFocus
|
|
}, /*#__PURE__*/React.createElement("span", null));
|
|
/* eslint-enable */
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("td", {
|
|
ref: function ref(el) {
|
|
return _this8.el = el;
|
|
},
|
|
style: style,
|
|
className: className,
|
|
rowSpan: this.props.rowSpan,
|
|
tabIndex: tabIndex,
|
|
role: "cell",
|
|
onClick: this.onClick,
|
|
onKeyDown: this.onKeyDown,
|
|
onBlur: this.onBlur,
|
|
onMouseDown: this.onMouseDown,
|
|
onMouseUp: this.onMouseUp
|
|
}, editorKeyHelper, title, content);
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
return this.getVirtualScrollerOption('loading') ? this.renderLoading() : this.renderElement();
|
|
}
|
|
}], [{
|
|
key: "getDerivedStateFromProps",
|
|
value: function getDerivedStateFromProps(nextProps, prevState) {
|
|
if (nextProps.editMode === 'row' && nextProps.editing !== prevState.editing) {
|
|
return {
|
|
editing: nextProps.editing
|
|
};
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}]);
|
|
|
|
return BodyCell;
|
|
}(Component);
|
|
|
|
function ownKeys$y(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$y(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$y(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$y(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$1z(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1z(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1z() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var BodyRow = /*#__PURE__*/function (_Component) {
|
|
_inherits(BodyRow, _Component);
|
|
|
|
var _super = _createSuper$1z(BodyRow);
|
|
|
|
function BodyRow(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, BodyRow);
|
|
|
|
_this = _super.call(this, props);
|
|
|
|
if (!_this.props.onRowEditChange) {
|
|
_this.state = {
|
|
editing: false
|
|
};
|
|
}
|
|
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onDoubleClick = _this.onDoubleClick.bind(_assertThisInitialized(_this));
|
|
_this.onRightClick = _this.onRightClick.bind(_assertThisInitialized(_this));
|
|
_this.onTouchEnd = _this.onTouchEnd.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onMouseDown = _this.onMouseDown.bind(_assertThisInitialized(_this));
|
|
_this.onMouseUp = _this.onMouseUp.bind(_assertThisInitialized(_this));
|
|
_this.onDragStart = _this.onDragStart.bind(_assertThisInitialized(_this));
|
|
_this.onDragEnd = _this.onDragEnd.bind(_assertThisInitialized(_this));
|
|
_this.onDragOver = _this.onDragOver.bind(_assertThisInitialized(_this));
|
|
_this.onDragLeave = _this.onDragLeave.bind(_assertThisInitialized(_this));
|
|
_this.onDrop = _this.onDrop.bind(_assertThisInitialized(_this));
|
|
_this.onEditInit = _this.onEditInit.bind(_assertThisInitialized(_this));
|
|
_this.onEditSave = _this.onEditSave.bind(_assertThisInitialized(_this));
|
|
_this.onEditCancel = _this.onEditCancel.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(BodyRow, [{
|
|
key: "isFocusable",
|
|
value: function isFocusable() {
|
|
return this.props.selectionMode && this.props.selectionModeInColumn !== 'single' && this.props.selectionModeInColumn !== 'multiple';
|
|
}
|
|
}, {
|
|
key: "isGrouped",
|
|
value: function isGrouped(column) {
|
|
if (this.props.groupRowsBy && this.getColumnProp(column, 'field')) {
|
|
if (Array.isArray(this.props.groupRowsBy)) return this.props.groupRowsBy.indexOf(column.props.field) > -1;else return this.props.groupRowsBy === column.props.field;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "equals",
|
|
value: function equals(data1, data2) {
|
|
return this.props.compareSelectionBy === 'equals' ? data1 === data2 : ObjectUtils.equals(data1, data2, this.props.dataKey);
|
|
}
|
|
}, {
|
|
key: "getColumnProp",
|
|
value: function getColumnProp(col, prop) {
|
|
return col ? col.props[prop] : null;
|
|
}
|
|
}, {
|
|
key: "getEditing",
|
|
value: function getEditing() {
|
|
return this.props.onRowEditChange ? this.props.editing : this.state.editing;
|
|
}
|
|
}, {
|
|
key: "getTabIndex",
|
|
value: function getTabIndex() {
|
|
return this.isFocusable() && !this.props.allowCellSelection ? this.props.index === 0 ? this.props.tabIndex : -1 : null;
|
|
}
|
|
}, {
|
|
key: "findIndex",
|
|
value: function findIndex(collection, rowData) {
|
|
var _this2 = this;
|
|
|
|
return (collection || []).findIndex(function (data) {
|
|
return _this2.equals(rowData, data);
|
|
});
|
|
}
|
|
}, {
|
|
key: "changeTabIndex",
|
|
value: function changeTabIndex(currentRow, nextRow) {
|
|
if (currentRow && nextRow) {
|
|
currentRow.tabIndex = -1;
|
|
nextRow.tabIndex = this.props.tabIndex;
|
|
}
|
|
}
|
|
}, {
|
|
key: "findNextSelectableRow",
|
|
value: function findNextSelectableRow(row) {
|
|
var nextRow = row.nextElementSibling;
|
|
return nextRow ? DomHandler.hasClass(nextRow, 'p-selectable-row') ? nextRow : this.findNextSelectableRow(nextRow) : null;
|
|
}
|
|
}, {
|
|
key: "findPrevSelectableRow",
|
|
value: function findPrevSelectableRow(row) {
|
|
var prevRow = row.previousElementSibling;
|
|
return prevRow ? DomHandler.hasClass(prevRow, 'p-selectable-row') ? prevRow : this.findPrevSelectableRow(prevRow) : null;
|
|
}
|
|
}, {
|
|
key: "shouldRenderBodyCell",
|
|
value: function shouldRenderBodyCell(value, column, i) {
|
|
if (this.getColumnProp(column, 'hidden')) {
|
|
return false;
|
|
} else if (this.props.rowGroupMode && this.props.rowGroupMode === 'rowspan' && this.isGrouped(column)) {
|
|
var prevRowData = value[i - 1];
|
|
|
|
if (prevRowData) {
|
|
var currentRowFieldData = ObjectUtils.resolveFieldData(value[i], this.getColumnProp(column, 'field'));
|
|
var previousRowFieldData = ObjectUtils.resolveFieldData(prevRowData, this.getColumnProp(column, 'field'));
|
|
return currentRowFieldData !== previousRowFieldData;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}, {
|
|
key: "calculateRowGroupSize",
|
|
value: function calculateRowGroupSize(value, column, index) {
|
|
if (this.isGrouped(column)) {
|
|
var currentRowFieldData = ObjectUtils.resolveFieldData(value[index], this.getColumnProp(column, 'field'));
|
|
var nextRowFieldData = currentRowFieldData;
|
|
var groupRowSpan = 0;
|
|
|
|
while (currentRowFieldData === nextRowFieldData) {
|
|
groupRowSpan++;
|
|
var nextRowData = value[++index];
|
|
|
|
if (nextRowData) {
|
|
nextRowFieldData = ObjectUtils.resolveFieldData(nextRowData, this.getColumnProp(column, 'field'));
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return groupRowSpan === 1 ? null : groupRowSpan;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
this.props.onRowClick({
|
|
originalEvent: event,
|
|
data: this.props.rowData,
|
|
index: this.props.index
|
|
});
|
|
}
|
|
}, {
|
|
key: "onDoubleClick",
|
|
value: function onDoubleClick(event) {
|
|
this.props.onRowDoubleClick({
|
|
originalEvent: event,
|
|
data: this.props.rowData,
|
|
index: this.props.index
|
|
});
|
|
}
|
|
}, {
|
|
key: "onRightClick",
|
|
value: function onRightClick(event) {
|
|
this.props.onRowRightClick({
|
|
originalEvent: event,
|
|
data: this.props.rowData,
|
|
index: this.props.index
|
|
});
|
|
}
|
|
}, {
|
|
key: "onTouchEnd",
|
|
value: function onTouchEnd(event) {
|
|
this.props.onRowTouchEnd(event);
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event) {
|
|
if (this.isFocusable() && !this.props.allowCellSelection) {
|
|
var target = event.target,
|
|
row = event.currentTarget;
|
|
|
|
switch (event.which) {
|
|
//down arrow
|
|
case 40:
|
|
var nextRow = this.findNextSelectableRow(row);
|
|
|
|
if (nextRow) {
|
|
this.changeTabIndex(row, nextRow);
|
|
nextRow.focus();
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//up arrow
|
|
|
|
case 38:
|
|
var prevRow = this.findPrevSelectableRow(row);
|
|
|
|
if (prevRow) {
|
|
this.changeTabIndex(row, prevRow);
|
|
prevRow.focus();
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//enter
|
|
|
|
case 13:
|
|
// @deprecated
|
|
if (!DomHandler.isClickable(target)) {
|
|
this.onClick(event);
|
|
event.preventDefault();
|
|
}
|
|
|
|
break;
|
|
//space
|
|
|
|
case 32:
|
|
if (!DomHandler.isClickable(target) && !target.readOnly) {
|
|
this.onClick(event);
|
|
event.preventDefault();
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onMouseDown",
|
|
value: function onMouseDown(event) {
|
|
this.props.onRowMouseDown({
|
|
originalEvent: event,
|
|
data: this.props.rowData,
|
|
index: this.props.index
|
|
});
|
|
}
|
|
}, {
|
|
key: "onMouseUp",
|
|
value: function onMouseUp(event) {
|
|
this.props.onRowMouseUp({
|
|
originalEvent: event,
|
|
data: this.props.rowData,
|
|
index: this.props.index
|
|
});
|
|
}
|
|
}, {
|
|
key: "onDragStart",
|
|
value: function onDragStart(event) {
|
|
this.props.onRowDragStart({
|
|
originalEvent: event,
|
|
data: this.props.rowData,
|
|
index: this.props.index
|
|
});
|
|
}
|
|
}, {
|
|
key: "onDragOver",
|
|
value: function onDragOver(event) {
|
|
this.props.onRowDragOver({
|
|
originalEvent: event,
|
|
data: this.props.rowData,
|
|
index: this.props.index
|
|
});
|
|
}
|
|
}, {
|
|
key: "onDragLeave",
|
|
value: function onDragLeave(event) {
|
|
this.props.onRowDragLeave({
|
|
originalEvent: event,
|
|
data: this.props.rowData,
|
|
index: this.props.index
|
|
});
|
|
}
|
|
}, {
|
|
key: "onDragEnd",
|
|
value: function onDragEnd(event) {
|
|
this.props.onRowDragEnd({
|
|
originalEvent: event,
|
|
data: this.props.rowData,
|
|
index: this.props.index
|
|
});
|
|
}
|
|
}, {
|
|
key: "onDrop",
|
|
value: function onDrop(event) {
|
|
this.props.onRowDrop({
|
|
originalEvent: event,
|
|
data: this.props.rowData,
|
|
index: this.props.index
|
|
});
|
|
}
|
|
}, {
|
|
key: "onEditChange",
|
|
value: function onEditChange(e, editing) {
|
|
if (this.props.onRowEditChange) {
|
|
var editingRows;
|
|
var dataKey = this.props.dataKey;
|
|
var originalEvent = e.originalEvent,
|
|
data = e.data,
|
|
index = e.index;
|
|
|
|
if (dataKey) {
|
|
var dataKeyValue = String(ObjectUtils.resolveFieldData(data, dataKey));
|
|
editingRows = this.props.editingRows ? _objectSpread$y({}, this.props.editingRows) : {};
|
|
if (editingRows[dataKeyValue] != null) delete editingRows[dataKeyValue];else editingRows[dataKeyValue] = true;
|
|
} else {
|
|
var editingRowIndex = this.findIndex(this.props.editingRows, data);
|
|
editingRows = this.props.editingRows ? _toConsumableArray(this.props.editingRows) : [];
|
|
if (editingRowIndex !== -1) editingRows = editingRows.filter(function (val, i) {
|
|
return i !== editingRowIndex;
|
|
});else editingRows.push(data);
|
|
}
|
|
|
|
this.props.onRowEditChange({
|
|
originalEvent: originalEvent,
|
|
data: editingRows,
|
|
index: index
|
|
});
|
|
} else {
|
|
this.setState({
|
|
editing: editing
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onEditInit",
|
|
value: function onEditInit(e) {
|
|
var event = e.originalEvent;
|
|
|
|
if (this.props.onRowEditInit) {
|
|
this.props.onRowEditInit({
|
|
originalEvent: event,
|
|
data: this.props.rowData,
|
|
index: this.props.index
|
|
});
|
|
}
|
|
|
|
this.onEditChange(e, true);
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onEditSave",
|
|
value: function onEditSave(e) {
|
|
var event = e.originalEvent;
|
|
var valid = this.props.rowEditValidator ? this.props.rowEditValidator(this.props.rowData, {
|
|
props: this.props.tableProps
|
|
}) : true;
|
|
|
|
if (this.props.onRowEditSave) {
|
|
this.props.onRowEditSave({
|
|
originalEvent: event,
|
|
data: this.props.rowData,
|
|
index: this.props.index,
|
|
valid: valid
|
|
});
|
|
}
|
|
|
|
if (valid) {
|
|
if (this.props.onRowEditComplete) {
|
|
this.props.onRowEditComplete(e);
|
|
}
|
|
|
|
this.onEditChange(e, false);
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onEditCancel",
|
|
value: function onEditCancel(e) {
|
|
var event = e.originalEvent;
|
|
|
|
if (this.props.onRowEditCancel) {
|
|
this.props.onRowEditCancel({
|
|
originalEvent: event,
|
|
data: this.props.rowData,
|
|
index: this.props.index
|
|
});
|
|
}
|
|
|
|
this.onEditChange(e, false);
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
var _this3 = this;
|
|
|
|
return this.props.columns.map(function (col, i) {
|
|
if (_this3.shouldRenderBodyCell(_this3.props.value, col, _this3.props.index)) {
|
|
var key = "".concat(_this3.getColumnProp(col, 'columnKey') || _this3.getColumnProp(col, 'field'), "_").concat(i);
|
|
var rowSpan = _this3.props.rowGroupMode === 'rowspan' ? _this3.calculateRowGroupSize(_this3.props.value, col, _this3.props.index) : null;
|
|
|
|
var editing = _this3.getEditing();
|
|
|
|
return /*#__PURE__*/React.createElement(BodyCell, {
|
|
key: key,
|
|
value: _this3.props.value,
|
|
tableProps: _this3.props.tableProps,
|
|
tableSelector: _this3.props.tableSelector,
|
|
column: col,
|
|
rowData: _this3.props.rowData,
|
|
rowIndex: _this3.props.index,
|
|
index: i,
|
|
rowSpan: rowSpan,
|
|
dataKey: _this3.props.dataKey,
|
|
editing: editing,
|
|
editingMeta: _this3.props.editingMeta,
|
|
editMode: _this3.props.editMode,
|
|
onRowEditInit: _this3.onEditInit,
|
|
onRowEditSave: _this3.onEditSave,
|
|
onRowEditCancel: _this3.onEditCancel,
|
|
onEditingMetaChange: _this3.props.onEditingMetaChange,
|
|
onRowToggle: _this3.props.onRowToggle,
|
|
selection: _this3.props.selection,
|
|
allowCellSelection: _this3.props.allowCellSelection,
|
|
compareSelectionBy: _this3.props.compareSelectionBy,
|
|
selectOnEdit: _this3.props.selectOnEdit,
|
|
selected: _this3.props.selected,
|
|
onClick: _this3.props.onCellClick,
|
|
onMouseDown: _this3.props.onCellMouseDown,
|
|
onMouseUp: _this3.props.onCellMouseUp,
|
|
tabIndex: _this3.props.tabIndex,
|
|
cellClassName: _this3.props.cellClassName,
|
|
responsiveLayout: _this3.props.responsiveLayout,
|
|
frozenRow: _this3.props.frozenRow,
|
|
isSelectable: _this3.props.isSelectable,
|
|
showSelectionElement: _this3.props.showSelectionElement,
|
|
showRowReorderElement: _this3.props.showRowReorderElement,
|
|
onRadioChange: _this3.props.onRadioChange,
|
|
onCheckboxChange: _this3.props.onCheckboxChange,
|
|
expanded: _this3.props.expanded,
|
|
expandedRowIcon: _this3.props.expandedRowIcon,
|
|
collapsedRowIcon: _this3.props.collapsedRowIcon,
|
|
virtualScrollerOptions: _this3.props.virtualScrollerOptions
|
|
});
|
|
}
|
|
|
|
return null;
|
|
});
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this4 = this;
|
|
|
|
var rowClassName = ObjectUtils.getPropValue(this.props.rowClassName, this.props.rowData, {
|
|
props: this.props.tableProps
|
|
});
|
|
var className = classNames(rowClassName, {
|
|
'p-highlight': !this.props.allowCellSelection && this.props.selected,
|
|
'p-highlight-contextmenu': this.props.contextMenuSelected,
|
|
'p-selectable-row': this.props.allowRowSelection && this.props.isSelectable({
|
|
data: this.props.rowData,
|
|
index: this.props.index
|
|
}),
|
|
'p-row-odd': this.props.index % 2 !== 0
|
|
});
|
|
var content = this.renderContent();
|
|
var tabIndex = this.getTabIndex();
|
|
return /*#__PURE__*/React.createElement("tr", {
|
|
ref: function ref(el) {
|
|
return _this4.el = el;
|
|
},
|
|
role: "row",
|
|
tabIndex: tabIndex,
|
|
className: className,
|
|
onMouseDown: this.onMouseDown,
|
|
onMouseUp: this.onMouseUp,
|
|
onClick: this.onClick,
|
|
onDoubleClick: this.onDoubleClick,
|
|
onContextMenu: this.onRightClick,
|
|
onTouchEnd: this.onTouchEnd,
|
|
onKeyDown: this.onKeyDown,
|
|
onDragStart: this.onDragStart,
|
|
onDragOver: this.onDragOver,
|
|
onDragLeave: this.onDragLeave,
|
|
onDragEnd: this.onDragEnd,
|
|
onDrop: this.onDrop
|
|
}, content);
|
|
}
|
|
}]);
|
|
|
|
return BodyRow;
|
|
}(Component);
|
|
|
|
function _createSuper$1y(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1y(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1y() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var RowTogglerButton = /*#__PURE__*/function (_Component) {
|
|
_inherits(RowTogglerButton, _Component);
|
|
|
|
var _super = _createSuper$1y(RowTogglerButton);
|
|
|
|
function RowTogglerButton(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, RowTogglerButton);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(RowTogglerButton, [{
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
this.props.onClick({
|
|
originalEvent: event,
|
|
data: this.props.rowData
|
|
});
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var iconClassName = classNames('p-row-toggler-icon', this.props.expanded ? this.props.expandedRowIcon : this.props.collapsedRowIcon);
|
|
return /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
onClick: this.onClick,
|
|
className: "p-row-toggler p-link",
|
|
tabIndex: this.props.tabIndex
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
}]);
|
|
|
|
return RowTogglerButton;
|
|
}(Component);
|
|
|
|
var _excluded = ["originalEvent"];
|
|
|
|
function ownKeys$x(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$x(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$x(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$x(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$1x(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1x(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1x() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var TableBody = /*#__PURE__*/function (_Component) {
|
|
_inherits(TableBody, _Component);
|
|
|
|
var _super = _createSuper$1x(TableBody);
|
|
|
|
function TableBody(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, TableBody);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
rowGroupHeaderStyleObject: {}
|
|
}; // row
|
|
|
|
_this.onRowClick = _this.onRowClick.bind(_assertThisInitialized(_this));
|
|
_this.onRowDoubleClick = _this.onRowDoubleClick.bind(_assertThisInitialized(_this));
|
|
_this.onRowRightClick = _this.onRowRightClick.bind(_assertThisInitialized(_this));
|
|
_this.onRowTouchEnd = _this.onRowTouchEnd.bind(_assertThisInitialized(_this));
|
|
_this.onRowMouseDown = _this.onRowMouseDown.bind(_assertThisInitialized(_this));
|
|
_this.onRowMouseUp = _this.onRowMouseUp.bind(_assertThisInitialized(_this));
|
|
_this.onRowToggle = _this.onRowToggle.bind(_assertThisInitialized(_this)); // drag
|
|
|
|
_this.onRowDragStart = _this.onRowDragStart.bind(_assertThisInitialized(_this));
|
|
_this.onRowDragOver = _this.onRowDragOver.bind(_assertThisInitialized(_this));
|
|
_this.onRowDragLeave = _this.onRowDragLeave.bind(_assertThisInitialized(_this));
|
|
_this.onRowDragEnd = _this.onRowDragEnd.bind(_assertThisInitialized(_this));
|
|
_this.onRowDrop = _this.onRowDrop.bind(_assertThisInitialized(_this)); // selection
|
|
|
|
_this.onRadioChange = _this.onRadioChange.bind(_assertThisInitialized(_this));
|
|
_this.onCheckboxChange = _this.onCheckboxChange.bind(_assertThisInitialized(_this));
|
|
_this.onDragSelectionMouseMove = _this.onDragSelectionMouseMove.bind(_assertThisInitialized(_this));
|
|
_this.onDragSelectionMouseUp = _this.onDragSelectionMouseUp.bind(_assertThisInitialized(_this));
|
|
_this.isSelectable = _this.isSelectable.bind(_assertThisInitialized(_this)); // cell
|
|
|
|
_this.onCellClick = _this.onCellClick.bind(_assertThisInitialized(_this));
|
|
_this.onCellMouseDown = _this.onCellMouseDown.bind(_assertThisInitialized(_this));
|
|
_this.onCellMouseUp = _this.onCellMouseUp.bind(_assertThisInitialized(_this));
|
|
_this.ref = _this.ref.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(TableBody, [{
|
|
key: "ref",
|
|
value: function ref(el) {
|
|
this.el = el;
|
|
this.props.virtualScrollerContentRef && this.props.virtualScrollerContentRef(el);
|
|
}
|
|
}, {
|
|
key: "equals",
|
|
value: function equals(data1, data2) {
|
|
if (this.allowCellSelection()) return (data1.rowIndex === data2.rowIndex || data1.rowData === data2.rowData) && (data1.field === data2.field || data1.cellIndex === data2.cellIndex);else return this.props.compareSelectionBy === 'equals' ? data1 === data2 : ObjectUtils.equals(data1, data2, this.props.dataKey);
|
|
}
|
|
}, {
|
|
key: "isSubheaderGrouping",
|
|
value: function isSubheaderGrouping() {
|
|
return this.props.rowGroupMode && this.props.rowGroupMode === 'subheader';
|
|
}
|
|
}, {
|
|
key: "isSelectionEnabled",
|
|
value: function isSelectionEnabled() {
|
|
return this.props.selectionMode || this.props.selectionModeInColumn !== null || this.props.columns && this.props.columns.some(function (col) {
|
|
return col && !!col.props.selectionMode;
|
|
});
|
|
}
|
|
}, {
|
|
key: "isRadioSelectionMode",
|
|
value: function isRadioSelectionMode() {
|
|
return this.props.selectionMode === 'radiobutton';
|
|
}
|
|
}, {
|
|
key: "isCheckboxSelectionMode",
|
|
value: function isCheckboxSelectionMode() {
|
|
return this.props.selectionMode === 'checkbox';
|
|
}
|
|
}, {
|
|
key: "isRadioSelectionModeInColumn",
|
|
value: function isRadioSelectionModeInColumn() {
|
|
return this.props.selectionModeInColumn === 'single';
|
|
}
|
|
}, {
|
|
key: "isCheckboxSelectionModeInColumn",
|
|
value: function isCheckboxSelectionModeInColumn() {
|
|
return this.props.selectionModeInColumn === 'multiple';
|
|
}
|
|
}, {
|
|
key: "isSingleSelection",
|
|
value: function isSingleSelection() {
|
|
return this.props.selectionMode === 'single' && !this.isCheckboxSelectionModeInColumn() || !this.isRadioSelectionMode() && this.isRadioSelectionModeInColumn();
|
|
}
|
|
}, {
|
|
key: "isMultipleSelection",
|
|
value: function isMultipleSelection() {
|
|
return this.props.selectionMode === 'multiple' && !this.isRadioSelectionModeInColumn() || this.isCheckboxSelectionModeInColumn();
|
|
}
|
|
}, {
|
|
key: "isRadioOnlySelection",
|
|
value: function isRadioOnlySelection() {
|
|
return this.isRadioSelectionMode() && this.isRadioSelectionModeInColumn();
|
|
}
|
|
}, {
|
|
key: "isCheckboxOnlySelection",
|
|
value: function isCheckboxOnlySelection() {
|
|
return this.isCheckboxSelectionMode() && this.isCheckboxSelectionModeInColumn();
|
|
}
|
|
}, {
|
|
key: "isSelected",
|
|
value: function isSelected(rowData) {
|
|
if (rowData && this.props.selection) {
|
|
return this.props.selection instanceof Array ? this.findIndex(this.props.selection, rowData) > -1 : this.equals(rowData, this.props.selection);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "isContextMenuSelected",
|
|
value: function isContextMenuSelected(rowData) {
|
|
if (rowData && this.props.contextMenuSelection) {
|
|
return this.equals(rowData, this.props.contextMenuSelection);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "isSelectable",
|
|
value: function isSelectable(options) {
|
|
return this.props.isDataSelectable ? this.props.isDataSelectable(options) : true;
|
|
}
|
|
}, {
|
|
key: "isRowExpanded",
|
|
value: function isRowExpanded(rowData) {
|
|
if (rowData && this.props.expandedRows) {
|
|
if (this.isSubheaderGrouping() && this.props.expandableRowGroups) {
|
|
return this.isRowGroupExpanded(rowData);
|
|
} else {
|
|
if (this.props.dataKey) return this.props.expandedRows ? this.props.expandedRows[ObjectUtils.resolveFieldData(rowData, this.props.dataKey)] !== undefined : false;else return this.findIndex(this.props.expandedRows, rowData) !== -1;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "isRowGroupExpanded",
|
|
value: function isRowGroupExpanded(rowData) {
|
|
var _this2 = this;
|
|
|
|
if (this.props.dataKey === this.props.groupRowsBy) return Object.keys(this.props.expandedRows).some(function (data) {
|
|
return ObjectUtils.equals(data, ObjectUtils.resolveFieldData(rowData, _this2.props.dataKey));
|
|
});else return this.props.expandedRows.some(function (data) {
|
|
return ObjectUtils.equals(data, rowData, _this2.props.groupRowsBy);
|
|
});
|
|
}
|
|
}, {
|
|
key: "isRowEditing",
|
|
value: function isRowEditing(rowData) {
|
|
if (this.props.editMode === 'row' && rowData && this.props.editingRows) {
|
|
if (this.props.dataKey) return this.props.editingRows ? this.props.editingRows[ObjectUtils.resolveFieldData(rowData, this.props.dataKey)] !== undefined : false;else return this.findIndex(this.props.editingRows, rowData) !== -1;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "allowDrag",
|
|
value: function allowDrag(event) {
|
|
return this.props.dragSelection && this.isMultipleSelection() && !event.originalEvent.shiftKey;
|
|
}
|
|
}, {
|
|
key: "allowRowDrag",
|
|
value: function allowRowDrag(event) {
|
|
return !this.allowCellSelection() && this.allowDrag(event);
|
|
}
|
|
}, {
|
|
key: "allowCellDrag",
|
|
value: function allowCellDrag(event) {
|
|
return this.allowCellSelection() && this.allowDrag(event);
|
|
}
|
|
}, {
|
|
key: "allowSelection",
|
|
value: function allowSelection(event) {
|
|
return !DomHandler.isClickable(event.originalEvent.target);
|
|
}
|
|
}, {
|
|
key: "allowMetaKeySelection",
|
|
value: function allowMetaKeySelection(event) {
|
|
return !this.rowTouched && (!this.props.metaKeySelection || this.props.metaKeySelection && (event.originalEvent.metaKey || event.originalEvent.ctrlKey));
|
|
}
|
|
}, {
|
|
key: "allowRangeSelection",
|
|
value: function allowRangeSelection(event) {
|
|
return this.isMultipleSelection() && event.originalEvent.shiftKey && this.anchorRowIndex !== null;
|
|
}
|
|
}, {
|
|
key: "allowRowSelection",
|
|
value: function allowRowSelection() {
|
|
return (this.props.selectionMode || this.props.selectionModeInColumn) && !this.isRadioOnlySelection() && !this.isCheckboxOnlySelection();
|
|
}
|
|
}, {
|
|
key: "allowCellSelection",
|
|
value: function allowCellSelection() {
|
|
return this.props.cellSelection && !this.isRadioSelectionModeInColumn() && !this.isCheckboxSelectionModeInColumn();
|
|
}
|
|
}, {
|
|
key: "getColumnsLength",
|
|
value: function getColumnsLength() {
|
|
return this.props.columns ? this.props.columns.length : 0;
|
|
}
|
|
}, {
|
|
key: "getVirtualScrollerOption",
|
|
value: function getVirtualScrollerOption(option, options) {
|
|
options = options || this.props.virtualScrollerOptions;
|
|
return options ? options[option] : null;
|
|
}
|
|
}, {
|
|
key: "findIndex",
|
|
value: function findIndex(collection, rowData) {
|
|
var _this3 = this;
|
|
|
|
return (collection || []).findIndex(function (data) {
|
|
return _this3.equals(rowData, data);
|
|
});
|
|
}
|
|
}, {
|
|
key: "rowGroupHeaderStyle",
|
|
value: function rowGroupHeaderStyle() {
|
|
if (this.props.scrollable) {
|
|
return {
|
|
top: this.state.rowGroupHeaderStyleObject['top']
|
|
};
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "getRowKey",
|
|
value: function getRowKey(rowData, index) {
|
|
return this.props.dataKey ? ObjectUtils.resolveFieldData(rowData, this.props.dataKey) + '_' + index : index;
|
|
}
|
|
}, {
|
|
key: "shouldRenderRowGroupHeader",
|
|
value: function shouldRenderRowGroupHeader(value, rowData, i) {
|
|
var currentRowFieldData = ObjectUtils.resolveFieldData(rowData, this.props.groupRowsBy);
|
|
var prevRowData = value[i - 1];
|
|
|
|
if (prevRowData) {
|
|
var previousRowFieldData = ObjectUtils.resolveFieldData(prevRowData, this.props.groupRowsBy);
|
|
return currentRowFieldData !== previousRowFieldData;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
}, {
|
|
key: "shouldRenderRowGroupFooter",
|
|
value: function shouldRenderRowGroupFooter(value, rowData, i, expanded) {
|
|
if (this.props.expandableRowGroups && !expanded) {
|
|
return false;
|
|
} else {
|
|
var currentRowFieldData = ObjectUtils.resolveFieldData(rowData, this.props.groupRowsBy);
|
|
var nextRowData = value[i + 1];
|
|
|
|
if (nextRowData) {
|
|
var nextRowFieldData = ObjectUtils.resolveFieldData(nextRowData, this.props.groupRowsBy);
|
|
return currentRowFieldData !== nextRowFieldData;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateFrozenRowStickyPosition",
|
|
value: function updateFrozenRowStickyPosition() {
|
|
this.el.style.top = DomHandler.getOuterHeight(this.el.previousElementSibling) + 'px';
|
|
}
|
|
}, {
|
|
key: "updateFrozenRowGroupHeaderStickyPosition",
|
|
value: function updateFrozenRowGroupHeaderStickyPosition() {
|
|
var tableHeaderHeight = DomHandler.getOuterHeight(this.el.previousElementSibling);
|
|
var top = tableHeaderHeight + 'px';
|
|
|
|
if (this.state.rowGroupHeaderStyleObject && this.state.rowGroupHeaderStyleObject.top !== top) {
|
|
this.setState({
|
|
rowGroupHeaderStyleObject: {
|
|
top: top
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateVirtualScrollerPosition",
|
|
value: function updateVirtualScrollerPosition() {
|
|
var tableHeaderHeight = DomHandler.getOuterHeight(this.el.previousElementSibling);
|
|
this.el.style.top = (this.el.style.top || 0) + tableHeaderHeight + 'px';
|
|
}
|
|
}, {
|
|
key: "onSingleSelection",
|
|
value: function onSingleSelection(_ref) {
|
|
var originalEvent = _ref.originalEvent,
|
|
data = _ref.data,
|
|
index = _ref.index,
|
|
toggleable = _ref.toggleable,
|
|
type = _ref.type;
|
|
|
|
if (!this.isSelectable({
|
|
data: data,
|
|
index: index
|
|
})) {
|
|
return;
|
|
}
|
|
|
|
var selected = this.isSelected(data);
|
|
var selection = this.props.selection;
|
|
|
|
if (selected) {
|
|
if (toggleable) {
|
|
selection = null;
|
|
this.onUnselect({
|
|
originalEvent: originalEvent,
|
|
data: data,
|
|
type: type
|
|
});
|
|
}
|
|
} else {
|
|
selection = data;
|
|
this.onSelect({
|
|
originalEvent: originalEvent,
|
|
data: data,
|
|
type: type
|
|
});
|
|
}
|
|
|
|
this.focusOnElement(originalEvent, true);
|
|
|
|
if (this.props.onSelectionChange && selection !== this.props.selection) {
|
|
this.props.onSelectionChange({
|
|
originalEvent: originalEvent,
|
|
value: selection,
|
|
type: type
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onMultipleSelection",
|
|
value: function onMultipleSelection(_ref2) {
|
|
var _this4 = this;
|
|
|
|
var originalEvent = _ref2.originalEvent,
|
|
data = _ref2.data,
|
|
index = _ref2.index,
|
|
toggleable = _ref2.toggleable,
|
|
type = _ref2.type;
|
|
|
|
if (!this.isSelectable({
|
|
data: data,
|
|
index: index
|
|
})) {
|
|
return;
|
|
}
|
|
|
|
var selected = this.isSelected(data);
|
|
var selection = this.props.selection || [];
|
|
|
|
if (selected) {
|
|
if (toggleable) {
|
|
var selectionIndex = this.findIndex(selection, data);
|
|
selection = this.props.selection.filter(function (val, i) {
|
|
return i !== selectionIndex;
|
|
});
|
|
this.onUnselect({
|
|
originalEvent: originalEvent,
|
|
data: data,
|
|
type: type
|
|
});
|
|
} else if (selection.length) {
|
|
this.props.selection.forEach(function (d) {
|
|
return _this4.onUnselect({
|
|
originalEvent: originalEvent,
|
|
data: d,
|
|
type: type
|
|
});
|
|
});
|
|
selection = [data];
|
|
this.onSelect({
|
|
originalEvent: originalEvent,
|
|
data: data,
|
|
type: type
|
|
});
|
|
}
|
|
} else {
|
|
selection = toggleable && this.isMultipleSelection() ? [].concat(_toConsumableArray(selection), [data]) : [data];
|
|
this.onSelect({
|
|
originalEvent: originalEvent,
|
|
data: data,
|
|
type: type
|
|
});
|
|
}
|
|
|
|
this.focusOnElement(originalEvent, true);
|
|
|
|
if (this.props.onSelectionChange && selection !== this.props.selection) {
|
|
this.props.onSelectionChange({
|
|
originalEvent: originalEvent,
|
|
value: selection,
|
|
type: type
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onRangeSelection",
|
|
value: function onRangeSelection(event, type) {
|
|
DomHandler.clearSelection();
|
|
this.rangeRowIndex = this.allowCellSelection() ? event.rowIndex : event.index;
|
|
var selectionInRange = this.selectRange(event);
|
|
var selection = this.isMultipleSelection() ? _toConsumableArray(new Set([].concat(_toConsumableArray(this.props.selection || []), _toConsumableArray(selectionInRange)))) : selectionInRange;
|
|
|
|
if (this.props.onSelectionChange && selection !== this.props.selection) {
|
|
this.props.onSelectionChange({
|
|
originalEvent: event.originalEvent,
|
|
value: selection,
|
|
type: type
|
|
});
|
|
}
|
|
|
|
this.anchorRowIndex = this.rangeRowIndex;
|
|
this.anchorCellIndex = event.cellIndex;
|
|
this.focusOnElement(event.originalEvent, false);
|
|
}
|
|
}, {
|
|
key: "selectRange",
|
|
value: function selectRange(event) {
|
|
var rangeStart, rangeEnd;
|
|
var isLazyAndPaginator = this.props.lazy && this.props.paginator;
|
|
|
|
if (isLazyAndPaginator) {
|
|
this.anchorRowIndex += this.anchorRowFirst;
|
|
this.rangeRowIndex += this.props.first;
|
|
}
|
|
|
|
if (this.rangeRowIndex > this.anchorRowIndex) {
|
|
rangeStart = this.anchorRowIndex;
|
|
rangeEnd = this.rangeRowIndex;
|
|
} else if (this.rangeRowIndex < this.anchorRowIndex) {
|
|
rangeStart = this.rangeRowIndex;
|
|
rangeEnd = this.anchorRowIndex;
|
|
} else {
|
|
rangeStart = rangeEnd = this.rangeRowIndex;
|
|
}
|
|
|
|
if (isLazyAndPaginator) {
|
|
rangeStart = Math.max(rangeStart - this.props.first, 0);
|
|
rangeEnd -= this.props.first;
|
|
}
|
|
|
|
return this.allowCellSelection() ? this.selectRangeOnCell(event, rangeStart, rangeEnd) : this.selectRangeOnRow(event, rangeStart, rangeEnd);
|
|
}
|
|
}, {
|
|
key: "selectRangeOnRow",
|
|
value: function selectRangeOnRow(event, rowRangeStart, rowRangeEnd) {
|
|
var value = this.props.value;
|
|
var selection = [];
|
|
|
|
for (var i = rowRangeStart; i <= rowRangeEnd; i++) {
|
|
var rangeRowData = value[i];
|
|
|
|
if (!this.isSelectable({
|
|
data: rangeRowData,
|
|
index: i
|
|
})) {
|
|
continue;
|
|
}
|
|
|
|
selection.push(rangeRowData);
|
|
this.onSelect({
|
|
originalEvent: event.originalEvent,
|
|
data: rangeRowData,
|
|
type: 'row'
|
|
});
|
|
}
|
|
|
|
return selection;
|
|
}
|
|
}, {
|
|
key: "selectRangeOnCell",
|
|
value: function selectRangeOnCell(event, rowRangeStart, rowRangeEnd) {
|
|
var cellRangeStart,
|
|
cellRangeEnd,
|
|
cellIndex = event.cellIndex;
|
|
|
|
if (cellIndex > this.anchorCellIndex) {
|
|
cellRangeStart = this.anchorCellIndex;
|
|
cellRangeEnd = cellIndex;
|
|
} else if (cellIndex < this.anchorCellIndex) {
|
|
cellRangeStart = cellIndex;
|
|
cellRangeEnd = this.anchorCellIndex;
|
|
} else {
|
|
cellRangeStart = cellRangeEnd = cellIndex;
|
|
}
|
|
|
|
var value = this.props.value;
|
|
var selection = [];
|
|
|
|
for (var i = rowRangeStart; i <= rowRangeEnd; i++) {
|
|
var rowData = value[i];
|
|
var columns = this.props.columns;
|
|
|
|
for (var j = cellRangeStart; j <= cellRangeEnd; j++) {
|
|
var field = columns[j].props.field;
|
|
|
|
var _value = ObjectUtils.resolveFieldData(rowData, field);
|
|
|
|
var rangeRowData = {
|
|
value: _value,
|
|
field: field,
|
|
rowData: rowData,
|
|
rowIndex: i,
|
|
cellIndex: j,
|
|
selected: true
|
|
};
|
|
|
|
if (!this.isSelectable({
|
|
data: rangeRowData,
|
|
index: i
|
|
})) {
|
|
continue;
|
|
}
|
|
|
|
selection.push(rangeRowData);
|
|
this.onSelect({
|
|
originalEvent: event.originalEvent,
|
|
data: rangeRowData,
|
|
type: 'cell'
|
|
});
|
|
}
|
|
}
|
|
|
|
return selection;
|
|
}
|
|
}, {
|
|
key: "onSelect",
|
|
value: function onSelect(event) {
|
|
if (this.allowCellSelection()) this.props.onCellSelect && this.props.onCellSelect(_objectSpread$x(_objectSpread$x({
|
|
originalEvent: event.originalEvent
|
|
}, event.data), {}, {
|
|
type: event.type
|
|
}));else this.props.onRowSelect && this.props.onRowSelect(event);
|
|
}
|
|
}, {
|
|
key: "onUnselect",
|
|
value: function onUnselect(event) {
|
|
if (this.allowCellSelection()) this.props.onCellUnselect && this.props.onCellUnselect(_objectSpread$x(_objectSpread$x({
|
|
originalEvent: event.originalEvent
|
|
}, event.data), {}, {
|
|
type: event.type
|
|
}));else this.props.onRowUnselect && this.props.onRowUnselect(event);
|
|
}
|
|
}, {
|
|
key: "enableDragSelection",
|
|
value: function enableDragSelection(event) {
|
|
if (this.props.dragSelection && !this.dragSelectionHelper) {
|
|
this.dragSelectionHelper = document.createElement('div');
|
|
DomHandler.addClass(this.dragSelectionHelper, 'p-datatable-drag-selection-helper');
|
|
this.initialDragPosition = {
|
|
x: event.clientX,
|
|
y: event.clientY
|
|
};
|
|
this.dragSelectionHelper.style.top = "".concat(event.pageY, "px");
|
|
this.dragSelectionHelper.style.left = "".concat(event.pageX, "px");
|
|
this.bindDragSelectionEvents();
|
|
}
|
|
}
|
|
}, {
|
|
key: "focusOnElement",
|
|
value: function focusOnElement(event, isFocused) {
|
|
var target = event.currentTarget;
|
|
|
|
if (!this.allowCellSelection() && this.props.selectionAutoFocus) {
|
|
if (this.isCheckboxSelectionModeInColumn()) {
|
|
var checkbox = DomHandler.findSingle(target, 'td.p-selection-column .p-checkbox-box');
|
|
checkbox && checkbox.focus();
|
|
} else if (this.isRadioSelectionModeInColumn()) {
|
|
var radio = DomHandler.findSingle(target, 'td.p-selection-column input[type="radio"]');
|
|
radio && radio.focus();
|
|
}
|
|
}
|
|
|
|
!isFocused && target && target.focus();
|
|
}
|
|
}, {
|
|
key: "changeTabIndex",
|
|
value: function changeTabIndex(event, type) {
|
|
var target = event.currentTarget;
|
|
var isSelectable = DomHandler.hasClass(target, type === 'cell' ? 'p-selectable-cell' : 'p-selectable-row');
|
|
|
|
if (isSelectable) {
|
|
var selector = type === 'cell' ? 'tr > td' : 'tr';
|
|
var tabbableEl = DomHandler.findSingle(this.el, "".concat(selector, "[tabindex=\"").concat(this.props.tabIndex, "\"]"));
|
|
|
|
if (tabbableEl && target) {
|
|
tabbableEl.tabIndex = -1;
|
|
target.tabIndex = this.props.tabIndex;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onRowClick",
|
|
value: function onRowClick(event) {
|
|
if (this.allowCellSelection() || !this.allowSelection(event)) {
|
|
return;
|
|
}
|
|
|
|
this.props.onRowClick && this.props.onRowClick(event);
|
|
|
|
if (this.allowRowSelection()) {
|
|
if (this.allowRangeSelection(event)) {
|
|
this.onRangeSelection(event, 'row');
|
|
} else {
|
|
var toggleable = this.isRadioSelectionModeInColumn() || this.isCheckboxSelectionModeInColumn() || this.allowMetaKeySelection(event);
|
|
this.anchorRowIndex = event.index;
|
|
this.rangeRowIndex = event.index;
|
|
this.anchorRowFirst = this.props.first;
|
|
|
|
if (this.isSingleSelection()) {
|
|
this.onSingleSelection(_objectSpread$x(_objectSpread$x({}, event), {}, {
|
|
toggleable: toggleable,
|
|
type: 'row'
|
|
}));
|
|
} else {
|
|
this.onMultipleSelection(_objectSpread$x(_objectSpread$x({}, event), {}, {
|
|
toggleable: toggleable,
|
|
type: 'row'
|
|
}));
|
|
}
|
|
}
|
|
|
|
this.changeTabIndex(event.originalEvent, 'row');
|
|
} else {
|
|
this.focusOnElement(event.originalEvent);
|
|
}
|
|
|
|
this.rowTouched = false;
|
|
}
|
|
}, {
|
|
key: "onRowDoubleClick",
|
|
value: function onRowDoubleClick(e) {
|
|
var event = e.originalEvent;
|
|
|
|
if (DomHandler.isClickable(event.target)) {
|
|
return;
|
|
}
|
|
|
|
if (this.props.onRowDoubleClick) {
|
|
this.props.onRowDoubleClick(e);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onRowRightClick",
|
|
value: function onRowRightClick(event) {
|
|
if (this.props.onContextMenu || this.props.onContextMenuSelectionChange) {
|
|
DomHandler.clearSelection();
|
|
|
|
if (this.props.onContextMenuSelectionChange) {
|
|
this.props.onContextMenuSelectionChange({
|
|
originalEvent: event.originalEvent,
|
|
value: event.data
|
|
});
|
|
}
|
|
|
|
if (this.props.onContextMenu) {
|
|
this.props.onContextMenu({
|
|
originalEvent: event.originalEvent,
|
|
data: event.data
|
|
});
|
|
}
|
|
|
|
event.originalEvent.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onRowTouchEnd",
|
|
value: function onRowTouchEnd() {
|
|
this.rowTouched = true;
|
|
}
|
|
}, {
|
|
key: "onRowMouseDown",
|
|
value: function onRowMouseDown(e) {
|
|
DomHandler.clearSelection();
|
|
var event = e.originalEvent;
|
|
if (DomHandler.hasClass(event.target, 'p-datatable-reorderablerow-handle')) event.currentTarget.draggable = true;else event.currentTarget.draggable = false;
|
|
|
|
if (this.allowRowDrag(e)) {
|
|
this.enableDragSelection(event, 'row');
|
|
this.anchorRowIndex = e.index;
|
|
this.rangeRowIndex = e.index;
|
|
this.anchorRowFirst = this.props.first;
|
|
}
|
|
}
|
|
}, {
|
|
key: "onRowMouseUp",
|
|
value: function onRowMouseUp(event) {
|
|
var isSameRow = event.index === this.anchorRowIndex;
|
|
|
|
if (this.allowRowDrag(event) && !isSameRow) {
|
|
this.onRangeSelection(event, 'row');
|
|
}
|
|
}
|
|
}, {
|
|
key: "onRowToggle",
|
|
value: function onRowToggle(event) {
|
|
var expandedRows;
|
|
var dataKey = this.props.dataKey;
|
|
var hasDataKey = this.props.groupRowsBy ? dataKey === this.props.groupRowsBy : !!dataKey;
|
|
|
|
if (hasDataKey) {
|
|
var dataKeyValue = String(ObjectUtils.resolveFieldData(event.data, dataKey));
|
|
expandedRows = this.props.expandedRows ? _objectSpread$x({}, this.props.expandedRows) : {};
|
|
|
|
if (expandedRows[dataKeyValue] != null) {
|
|
delete expandedRows[dataKeyValue];
|
|
|
|
if (this.props.onRowCollapse) {
|
|
this.props.onRowCollapse({
|
|
originalEvent: event,
|
|
data: event.data
|
|
});
|
|
}
|
|
} else {
|
|
expandedRows[dataKeyValue] = true;
|
|
|
|
if (this.props.onRowExpand) {
|
|
this.props.onRowExpand({
|
|
originalEvent: event,
|
|
data: event.data
|
|
});
|
|
}
|
|
}
|
|
} else {
|
|
var expandedRowIndex = this.findIndex(this.props.expandedRows, event.data);
|
|
expandedRows = this.props.expandedRows ? _toConsumableArray(this.props.expandedRows) : [];
|
|
|
|
if (expandedRowIndex !== -1) {
|
|
expandedRows = expandedRows.filter(function (val, i) {
|
|
return i !== expandedRowIndex;
|
|
});
|
|
|
|
if (this.props.onRowCollapse) {
|
|
this.props.onRowCollapse({
|
|
originalEvent: event,
|
|
data: event.data
|
|
});
|
|
}
|
|
} else {
|
|
expandedRows.push(event.data);
|
|
|
|
if (this.props.onRowExpand) {
|
|
this.props.onRowExpand({
|
|
originalEvent: event,
|
|
data: event.data
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.props.onRowToggle) {
|
|
this.props.onRowToggle({
|
|
data: expandedRows
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onRowDragStart",
|
|
value: function onRowDragStart(e) {
|
|
var event = e.originalEvent,
|
|
index = e.index;
|
|
this.rowDragging = true;
|
|
this.draggedRowIndex = index;
|
|
event.dataTransfer.setData('text', 'b'); // For firefox
|
|
}
|
|
}, {
|
|
key: "onRowDragOver",
|
|
value: function onRowDragOver(e) {
|
|
var event = e.originalEvent,
|
|
index = e.index;
|
|
|
|
if (this.rowDragging && this.draggedRowIndex !== index) {
|
|
var rowElement = event.currentTarget;
|
|
var rowY = DomHandler.getOffset(rowElement).top + DomHandler.getWindowScrollTop();
|
|
var pageY = event.pageY;
|
|
var rowMidY = rowY + DomHandler.getOuterHeight(rowElement) / 2;
|
|
var prevRowElement = rowElement.previousElementSibling;
|
|
|
|
if (pageY < rowMidY) {
|
|
DomHandler.removeClass(rowElement, 'p-datatable-dragpoint-bottom');
|
|
this.droppedRowIndex = index;
|
|
if (prevRowElement) DomHandler.addClass(prevRowElement, 'p-datatable-dragpoint-bottom');else DomHandler.addClass(rowElement, 'p-datatable-dragpoint-top');
|
|
} else {
|
|
if (prevRowElement) DomHandler.removeClass(prevRowElement, 'p-datatable-dragpoint-bottom');else DomHandler.addClass(rowElement, 'p-datatable-dragpoint-top');
|
|
this.droppedRowIndex = index + 1;
|
|
DomHandler.addClass(rowElement, 'p-datatable-dragpoint-bottom');
|
|
}
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onRowDragLeave",
|
|
value: function onRowDragLeave(e) {
|
|
var event = e.originalEvent;
|
|
var rowElement = event.currentTarget;
|
|
var prevRowElement = rowElement.previousElementSibling;
|
|
|
|
if (prevRowElement) {
|
|
DomHandler.removeClass(prevRowElement, 'p-datatable-dragpoint-bottom');
|
|
}
|
|
|
|
DomHandler.removeClass(rowElement, 'p-datatable-dragpoint-bottom');
|
|
DomHandler.removeClass(rowElement, 'p-datatable-dragpoint-top');
|
|
}
|
|
}, {
|
|
key: "onRowDragEnd",
|
|
value: function onRowDragEnd(e) {
|
|
var event = e.originalEvent;
|
|
this.rowDragging = false;
|
|
this.draggedRowIndex = null;
|
|
this.droppedRowIndex = null;
|
|
event.currentTarget.draggable = false;
|
|
}
|
|
}, {
|
|
key: "onRowDrop",
|
|
value: function onRowDrop(e) {
|
|
var event = e.originalEvent;
|
|
|
|
if (this.droppedRowIndex != null) {
|
|
var dropIndex = this.draggedRowIndex > this.droppedRowIndex ? this.droppedRowIndex : this.droppedRowIndex === 0 ? 0 : this.droppedRowIndex - 1;
|
|
|
|
var val = _toConsumableArray(this.props.value);
|
|
|
|
ObjectUtils.reorderArray(val, this.draggedRowIndex, dropIndex);
|
|
|
|
if (this.props.onRowReorder) {
|
|
this.props.onRowReorder({
|
|
originalEvent: event,
|
|
value: val,
|
|
dragIndex: this.draggedRowIndex,
|
|
dropIndex: this.droppedRowIndex
|
|
});
|
|
}
|
|
} //cleanup
|
|
|
|
|
|
this.onRowDragLeave(e);
|
|
this.onRowDragEnd(e);
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onRadioChange",
|
|
value: function onRadioChange(event) {
|
|
this.onSingleSelection(_objectSpread$x(_objectSpread$x({}, event), {}, {
|
|
toggleable: true,
|
|
type: 'radio'
|
|
}));
|
|
}
|
|
}, {
|
|
key: "onCheckboxChange",
|
|
value: function onCheckboxChange(event) {
|
|
this.onMultipleSelection(_objectSpread$x(_objectSpread$x({}, event), {}, {
|
|
toggleable: true,
|
|
type: 'checkbox'
|
|
}));
|
|
}
|
|
}, {
|
|
key: "onDragSelectionMouseMove",
|
|
value: function onDragSelectionMouseMove(event) {
|
|
var _this$initialDragPosi = this.initialDragPosition,
|
|
x = _this$initialDragPosi.x,
|
|
y = _this$initialDragPosi.y;
|
|
var dx = event.clientX - x;
|
|
var dy = event.clientY - y;
|
|
if (dy < 0) this.dragSelectionHelper.style.top = "".concat(event.pageY + 5, "px");
|
|
if (dx < 0) this.dragSelectionHelper.style.left = "".concat(event.pageX + 5, "px");
|
|
this.dragSelectionHelper.style.height = "".concat(Math.abs(dy), "px");
|
|
this.dragSelectionHelper.style.width = "".concat(Math.abs(dx), "px");
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onDragSelectionMouseUp",
|
|
value: function onDragSelectionMouseUp() {
|
|
if (this.dragSelectionHelper) {
|
|
this.dragSelectionHelper.remove();
|
|
this.dragSelectionHelper = null;
|
|
}
|
|
|
|
document.removeEventListener('mousemove', this.onDragSelectionMouseMove);
|
|
document.removeEventListener('mouseup', this.onDragSelectionMouseUp);
|
|
}
|
|
}, {
|
|
key: "onCellClick",
|
|
value: function onCellClick(event) {
|
|
if (!this.allowSelection(event)) {
|
|
return;
|
|
}
|
|
|
|
this.props.onCellClick && this.props.onCellClick(event);
|
|
|
|
if (this.allowCellSelection()) {
|
|
if (this.allowRangeSelection(event)) {
|
|
this.onRangeSelection(event, 'cell');
|
|
} else {
|
|
var toggleable = this.allowMetaKeySelection(event);
|
|
|
|
var originalEvent = event.originalEvent,
|
|
data = _objectWithoutProperties(event, _excluded);
|
|
|
|
this.anchorRowIndex = event.rowIndex;
|
|
this.rangeRowIndex = event.rowIndex;
|
|
this.anchorRowFirst = this.props.first;
|
|
this.anchorCellIndex = event.cellIndex;
|
|
|
|
if (this.isSingleSelection()) {
|
|
this.onSingleSelection({
|
|
originalEvent: originalEvent,
|
|
data: data,
|
|
index: event.rowIndex,
|
|
toggleable: toggleable,
|
|
type: 'cell'
|
|
});
|
|
} else {
|
|
this.onMultipleSelection({
|
|
originalEvent: originalEvent,
|
|
data: data,
|
|
index: event.rowIndex,
|
|
toggleable: toggleable,
|
|
type: 'cell'
|
|
});
|
|
}
|
|
}
|
|
|
|
this.changeTabIndex(event.originalEvent, 'cell');
|
|
}
|
|
|
|
this.rowTouched = false;
|
|
}
|
|
}, {
|
|
key: "onCellMouseDown",
|
|
value: function onCellMouseDown(event) {
|
|
if (this.allowCellDrag(event)) {
|
|
this.enableDragSelection(event.originalEvent);
|
|
this.anchorRowIndex = event.rowIndex;
|
|
this.rangeRowIndex = event.rowIndex;
|
|
this.anchorRowFirst = this.props.first;
|
|
this.anchorCellIndex = event.cellIndex;
|
|
}
|
|
}
|
|
}, {
|
|
key: "onCellMouseUp",
|
|
value: function onCellMouseUp(event) {
|
|
var isSameCell = event.rowIndex === this.anchorRowIndex && event.cellIndex === this.anchorCellIndex;
|
|
|
|
if (this.allowCellDrag(event) && !isSameCell) {
|
|
this.onRangeSelection(event, 'cell');
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindDragSelectionEvents",
|
|
value: function bindDragSelectionEvents() {
|
|
document.addEventListener('mousemove', this.onDragSelectionMouseMove);
|
|
document.addEventListener('mouseup', this.onDragSelectionMouseUp);
|
|
document.body.appendChild(this.dragSelectionHelper);
|
|
}
|
|
}, {
|
|
key: "unbindDragSelectionEvents",
|
|
value: function unbindDragSelectionEvents() {
|
|
this.onDragSelectionMouseUp();
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (this.props.frozenRow) {
|
|
this.updateFrozenRowStickyPosition();
|
|
}
|
|
|
|
if (this.props.scrollable && this.props.rowGroupMode === 'subheader') {
|
|
this.updateFrozenRowGroupHeaderStickyPosition();
|
|
}
|
|
|
|
if (!this.props.isVirtualScrollerDisabled && this.getVirtualScrollerOption('vertical')) {
|
|
this.updateVirtualScrollerPosition();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps, prevState) {
|
|
if (this.props.frozenRow) {
|
|
this.updateFrozenRowStickyPosition();
|
|
}
|
|
|
|
if (this.props.scrollable && this.props.rowGroupMode === 'subheader') {
|
|
this.updateFrozenRowGroupHeaderStickyPosition();
|
|
}
|
|
|
|
if (!this.props.isVirtualScrollerDisabled && this.getVirtualScrollerOption('vertical') && this.getVirtualScrollerOption('itemSize', prevProps.virtualScrollerOptions) !== this.getVirtualScrollerOption('itemSize')) {
|
|
this.updateVirtualScrollerPosition();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.props.dragSelection) {
|
|
this.unbindDragSelectionEvents();
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderEmptyContent",
|
|
value: function renderEmptyContent() {
|
|
if (!this.props.loading) {
|
|
var colSpan = this.getColumnsLength();
|
|
var content = ObjectUtils.getJSXElement(this.props.emptyMessage, {
|
|
props: this.props,
|
|
frozen: this.props.frozenRow
|
|
}) || localeOption('emptyMessage');
|
|
return /*#__PURE__*/React.createElement("tr", {
|
|
className: "p-datatable-emptymessage",
|
|
role: "row"
|
|
}, /*#__PURE__*/React.createElement("td", {
|
|
colSpan: colSpan,
|
|
role: "cell"
|
|
}, content));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderGroupHeader",
|
|
value: function renderGroupHeader(rowData, index, expanded, isSubheaderGrouping, colSpan) {
|
|
if (isSubheaderGrouping && this.shouldRenderRowGroupHeader(this.props.value, rowData, index - this.props.first)) {
|
|
var style = this.rowGroupHeaderStyle();
|
|
var toggler = this.props.expandableRowGroups && /*#__PURE__*/React.createElement(RowTogglerButton, {
|
|
onClick: this.onRowToggle,
|
|
rowData: rowData,
|
|
expanded: expanded,
|
|
expandedRowIcon: this.props.expandedRowIcon,
|
|
collapsedRowIcon: this.props.collapsedRowIcon
|
|
});
|
|
var content = ObjectUtils.getJSXElement(this.props.rowGroupHeaderTemplate, rowData, {
|
|
index: index,
|
|
props: this.props.tableProps
|
|
});
|
|
return /*#__PURE__*/React.createElement("tr", {
|
|
className: "p-rowgroup-header",
|
|
style: style,
|
|
role: "row"
|
|
}, /*#__PURE__*/React.createElement("td", {
|
|
colSpan: colSpan
|
|
}, toggler, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-rowgroup-header-name"
|
|
}, content)));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderRow",
|
|
value: function renderRow(rowData, index, expanded) {
|
|
if (!this.props.expandableRowGroups || expanded) {
|
|
var selected = this.isSelectionEnabled() ? this.isSelected(rowData) : false;
|
|
var contextMenuSelected = this.isContextMenuSelected(rowData);
|
|
var allowRowSelection = this.allowRowSelection();
|
|
var allowCellSelection = this.allowCellSelection();
|
|
var editing = this.isRowEditing(rowData);
|
|
return /*#__PURE__*/React.createElement(BodyRow, {
|
|
tableProps: this.props.tableProps,
|
|
tableSelector: this.props.tableSelector,
|
|
value: this.props.value,
|
|
columns: this.props.columns,
|
|
rowData: rowData,
|
|
index: index,
|
|
selected: selected,
|
|
contextMenuSelected: contextMenuSelected,
|
|
onRowClick: this.onRowClick,
|
|
onRowDoubleClick: this.onRowDoubleClick,
|
|
onRowRightClick: this.onRowRightClick,
|
|
tabIndex: this.props.tabIndex,
|
|
isSelectable: this.isSelectable,
|
|
onRowTouchEnd: this.onRowTouchEnd,
|
|
onRowMouseDown: this.onRowMouseDown,
|
|
onRowMouseUp: this.onRowMouseUp,
|
|
onRowToggle: this.onRowToggle,
|
|
onRowDragStart: this.onRowDragStart,
|
|
onRowDragOver: this.onRowDragOver,
|
|
onRowDragLeave: this.onRowDragLeave,
|
|
onRowDragEnd: this.onRowDragEnd,
|
|
onRowDrop: this.onRowDrop,
|
|
onRadioChange: this.onRadioChange,
|
|
onCheckboxChange: this.onCheckboxChange,
|
|
onCellClick: this.onCellClick,
|
|
onCellMouseDown: this.onCellMouseDown,
|
|
onCellMouseUp: this.onCellMouseUp,
|
|
editing: editing,
|
|
editingRows: this.props.editingRows,
|
|
editingMeta: this.props.editingMeta,
|
|
editMode: this.props.editMode,
|
|
onRowEditChange: this.props.onRowEditChange,
|
|
onEditingMetaChange: this.props.onEditingMetaChange,
|
|
groupRowsBy: this.props.groupRowsBy,
|
|
compareSelectionBy: this.props.compareSelectionBy,
|
|
dataKey: this.props.dataKey,
|
|
rowGroupMode: this.props.rowGroupMode,
|
|
onRowEditInit: this.props.onRowEditInit,
|
|
rowEditValidator: this.props.rowEditValidator,
|
|
onRowEditSave: this.props.onRowEditSave,
|
|
onRowEditComplete: this.props.onRowEditComplete,
|
|
onRowEditCancel: this.props.onRowEditCancel,
|
|
selection: this.props.selection,
|
|
allowRowSelection: allowRowSelection,
|
|
allowCellSelection: allowCellSelection,
|
|
selectOnEdit: this.props.selectOnEdit,
|
|
selectionMode: this.props.selectionMode,
|
|
selectionModeInColumn: this.props.selectionModeInColumn,
|
|
cellClassName: this.props.cellClassName,
|
|
responsiveLayout: this.props.responsiveLayout,
|
|
frozenRow: this.props.frozenRow,
|
|
showSelectionElement: this.props.showSelectionElement,
|
|
showRowReorderElement: this.props.showRowReorderElement,
|
|
expanded: expanded,
|
|
expandedRowIcon: this.props.expandedRowIcon,
|
|
collapsedRowIcon: this.props.collapsedRowIcon,
|
|
rowClassName: this.props.rowClassName,
|
|
virtualScrollerOptions: this.props.virtualScrollerOptions
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderExpansion",
|
|
value: function renderExpansion(rowData, index, expanded, isSubheaderGrouping, colSpan) {
|
|
if (expanded && !(isSubheaderGrouping && this.props.expandableRowGroups)) {
|
|
var content = ObjectUtils.getJSXElement(this.props.rowExpansionTemplate, rowData, {
|
|
index: index
|
|
});
|
|
var id = "".concat(this.props.tableSelector, "_content_").concat(index, "_expanded");
|
|
return /*#__PURE__*/React.createElement("tr", {
|
|
id: id,
|
|
className: "p-datatable-row-expansion",
|
|
role: "row"
|
|
}, /*#__PURE__*/React.createElement("td", {
|
|
role: "cell",
|
|
colSpan: colSpan
|
|
}, content));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderGroupFooter",
|
|
value: function renderGroupFooter(rowData, index, expanded, isSubheaderGrouping, colSpan) {
|
|
if (isSubheaderGrouping && this.shouldRenderRowGroupFooter(this.props.value, rowData, index - this.props.first, expanded)) {
|
|
var content = ObjectUtils.getJSXElement(this.props.rowGroupFooterTemplate, rowData, {
|
|
index: index,
|
|
colSpan: colSpan,
|
|
props: this.props.tableProps
|
|
});
|
|
return /*#__PURE__*/React.createElement("tr", {
|
|
className: "p-rowgroup-footer",
|
|
role: "row"
|
|
}, content);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
var _this5 = this;
|
|
|
|
return this.props.value.map(function (rowData, i) {
|
|
var index = _this5.getVirtualScrollerOption('getItemOptions') ? _this5.getVirtualScrollerOption('getItemOptions')(i).index : _this5.props.first + i;
|
|
|
|
var key = _this5.getRowKey(rowData, index);
|
|
|
|
var expanded = _this5.isRowExpanded(rowData);
|
|
|
|
var isSubheaderGrouping = _this5.isSubheaderGrouping();
|
|
|
|
var colSpan = _this5.getColumnsLength();
|
|
|
|
var groupHeader = _this5.renderGroupHeader(rowData, index, expanded, isSubheaderGrouping, colSpan);
|
|
|
|
var row = _this5.renderRow(rowData, index, expanded);
|
|
|
|
var expansion = _this5.renderExpansion(rowData, index, expanded, isSubheaderGrouping, colSpan);
|
|
|
|
var groupFooter = _this5.renderGroupFooter(rowData, index, expanded, isSubheaderGrouping, colSpan);
|
|
|
|
return /*#__PURE__*/React.createElement(React.Fragment, {
|
|
key: key
|
|
}, groupHeader, row, expansion, groupFooter);
|
|
});
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-datatable-tbody', this.props.className);
|
|
var content = this.props.empty ? this.renderEmptyContent() : this.renderContent();
|
|
return /*#__PURE__*/React.createElement("tbody", {
|
|
ref: this.ref,
|
|
className: className
|
|
}, content);
|
|
}
|
|
}]);
|
|
|
|
return TableBody;
|
|
}(Component);
|
|
|
|
function ownKeys$w(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$w(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$w(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$w(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$1w(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1w(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1w() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var FooterCell = /*#__PURE__*/function (_Component) {
|
|
_inherits(FooterCell, _Component);
|
|
|
|
var _super = _createSuper$1w(FooterCell);
|
|
|
|
function FooterCell(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, FooterCell);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
styleObject: {}
|
|
};
|
|
return _this;
|
|
}
|
|
|
|
_createClass(FooterCell, [{
|
|
key: "getColumnProp",
|
|
value: function getColumnProp(prop) {
|
|
return this.props.column.props[prop];
|
|
}
|
|
}, {
|
|
key: "getStyle",
|
|
value: function getStyle() {
|
|
var footerStyle = this.getColumnProp('footerStyle');
|
|
var columnStyle = this.getColumnProp('style');
|
|
return this.getColumnProp('frozen') ? Object.assign({}, columnStyle, footerStyle, this.state.styleObject) : Object.assign({}, columnStyle, footerStyle);
|
|
}
|
|
}, {
|
|
key: "updateStickyPosition",
|
|
value: function updateStickyPosition() {
|
|
if (this.getColumnProp('frozen')) {
|
|
var styleObject = _objectSpread$w({}, this.state.styleObject);
|
|
|
|
var align = this.getColumnProp('alignFrozen');
|
|
|
|
if (align === 'right') {
|
|
var right = 0;
|
|
var next = this.el.nextElementSibling;
|
|
|
|
if (next) {
|
|
right = DomHandler.getOuterWidth(next) + parseFloat(next.style.right || 0);
|
|
}
|
|
|
|
styleObject['right'] = right + 'px';
|
|
} else {
|
|
var left = 0;
|
|
var prev = this.el.previousElementSibling;
|
|
|
|
if (prev) {
|
|
left = DomHandler.getOuterWidth(prev) + parseFloat(prev.style.left || 0);
|
|
}
|
|
|
|
styleObject['left'] = left + 'px';
|
|
}
|
|
|
|
this.setState({
|
|
styleObject: styleObject
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (this.getColumnProp('frozen')) {
|
|
this.updateStickyPosition();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps, prevState) {
|
|
if (this.getColumnProp('frozen')) {
|
|
this.updateStickyPosition();
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this2 = this;
|
|
|
|
var style = this.getStyle();
|
|
var align = this.getColumnProp('align');
|
|
var className = classNames(this.getColumnProp('footerClassName'), this.getColumnProp('className'), _defineProperty({
|
|
'p-frozen-column': this.getColumnProp('frozen')
|
|
}, "p-align-".concat(align), !!align));
|
|
var colSpan = this.getColumnProp('colSpan');
|
|
var rowSpan = this.getColumnProp('rowSpan');
|
|
var content = ObjectUtils.getJSXElement(this.getColumnProp('footer'), {
|
|
props: this.props.tableProps
|
|
});
|
|
return /*#__PURE__*/React.createElement("td", {
|
|
ref: function ref(el) {
|
|
return _this2.el = el;
|
|
},
|
|
style: style,
|
|
className: className,
|
|
role: "cell",
|
|
colSpan: colSpan,
|
|
rowSpan: rowSpan
|
|
}, content);
|
|
}
|
|
}]);
|
|
|
|
return FooterCell;
|
|
}(Component);
|
|
|
|
function _createSuper$1v(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1v(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1v() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var TableFooter = /*#__PURE__*/function (_Component) {
|
|
_inherits(TableFooter, _Component);
|
|
|
|
var _super = _createSuper$1v(TableFooter);
|
|
|
|
function TableFooter() {
|
|
_classCallCheck(this, TableFooter);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(TableFooter, [{
|
|
key: "hasFooter",
|
|
value: function hasFooter() {
|
|
return this.props.footerColumnGroup ? true : this.props.columns ? this.props.columns.some(function (col) {
|
|
return col && col.props.footer;
|
|
}) : false;
|
|
}
|
|
}, {
|
|
key: "renderGroupFooterCells",
|
|
value: function renderGroupFooterCells(row) {
|
|
var columns = React.Children.toArray(row.props.children);
|
|
return this.renderFooterCells(columns);
|
|
}
|
|
}, {
|
|
key: "renderFooterCells",
|
|
value: function renderFooterCells(columns) {
|
|
var _this = this;
|
|
|
|
return React.Children.map(columns, function (col, i) {
|
|
var isVisible = col ? !col.props.hidden : true;
|
|
var key = col ? col.props.columnKey || col.props.field || i : i;
|
|
return isVisible && /*#__PURE__*/React.createElement(FooterCell, {
|
|
key: key,
|
|
tableProps: _this.props.tableProps,
|
|
column: col
|
|
});
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
var _this2 = this;
|
|
|
|
if (this.props.footerColumnGroup) {
|
|
var rows = React.Children.toArray(this.props.footerColumnGroup.props.children);
|
|
return rows.map(function (row, i) {
|
|
return /*#__PURE__*/React.createElement("tr", {
|
|
key: i,
|
|
role: "row"
|
|
}, _this2.renderGroupFooterCells(row));
|
|
});
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("tr", {
|
|
role: "row"
|
|
}, this.renderFooterCells(this.props.columns));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
if (this.hasFooter()) {
|
|
var content = this.renderContent();
|
|
return /*#__PURE__*/React.createElement("tfoot", {
|
|
className: "p-datatable-tfoot"
|
|
}, content);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}]);
|
|
|
|
return TableFooter;
|
|
}(Component);
|
|
|
|
function _createSuper$1u(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1u(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1u() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var HeaderCheckbox = /*#__PURE__*/function (_Component) {
|
|
_inherits(HeaderCheckbox, _Component);
|
|
|
|
var _super = _createSuper$1u(HeaderCheckbox);
|
|
|
|
function HeaderCheckbox(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, HeaderCheckbox);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
focused: false
|
|
};
|
|
_this.onFocus = _this.onFocus.bind(_assertThisInitialized(_this));
|
|
_this.onBlur = _this.onBlur.bind(_assertThisInitialized(_this));
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(HeaderCheckbox, [{
|
|
key: "onFocus",
|
|
value: function onFocus() {
|
|
this.setState({
|
|
focused: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "onBlur",
|
|
value: function onBlur() {
|
|
this.setState({
|
|
focused: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
if (!this.props.disabled) {
|
|
this.setState({
|
|
focused: true
|
|
});
|
|
this.props.onChange({
|
|
originalEvent: event,
|
|
checked: !this.props.checked
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event) {
|
|
if (event.code === 'Space') {
|
|
this.onClick(event);
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var boxClassName = classNames('p-checkbox-box p-component', {
|
|
'p-highlight': this.props.checked,
|
|
'p-disabled': this.props.disabled,
|
|
'p-focus': this.state.focused
|
|
});
|
|
var iconClassName = classNames('p-checkbox-icon', {
|
|
'pi pi-check': this.props.checked
|
|
});
|
|
var tabIndex = this.props.disabled ? null : 0;
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-checkbox p-component",
|
|
onClick: this.onClick
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: boxClassName,
|
|
role: "checkbox",
|
|
"aria-checked": this.props.checked,
|
|
tabIndex: tabIndex,
|
|
onFocus: this.onFocus,
|
|
onBlur: this.onBlur,
|
|
onKeyDown: this.onKeyDown
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
})));
|
|
}
|
|
}]);
|
|
|
|
return HeaderCheckbox;
|
|
}(Component);
|
|
|
|
function ownKeys$v(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$v(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$v(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$v(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$1t(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1t(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1t() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var ColumnFilter = /*#__PURE__*/function (_Component) {
|
|
_inherits(ColumnFilter, _Component);
|
|
|
|
var _super = _createSuper$1t(ColumnFilter);
|
|
|
|
function ColumnFilter(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, ColumnFilter);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
overlayVisible: false
|
|
};
|
|
_this.overlayRef = /*#__PURE__*/React.createRef();
|
|
_this.filterCallback = _this.filterCallback.bind(_assertThisInitialized(_this));
|
|
_this.filterApplyCallback = _this.filterApplyCallback.bind(_assertThisInitialized(_this));
|
|
_this.onOperatorChange = _this.onOperatorChange.bind(_assertThisInitialized(_this));
|
|
_this.addConstraint = _this.addConstraint.bind(_assertThisInitialized(_this));
|
|
_this.clearFilter = _this.clearFilter.bind(_assertThisInitialized(_this));
|
|
_this.applyFilter = _this.applyFilter.bind(_assertThisInitialized(_this));
|
|
_this.onInputChange = _this.onInputChange.bind(_assertThisInitialized(_this));
|
|
_this.toggleMenu = _this.toggleMenu.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEnter = _this.onOverlayEnter.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExit = _this.onOverlayExit.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExited = _this.onOverlayExited.bind(_assertThisInitialized(_this));
|
|
_this.onContentKeyDown = _this.onContentKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onContentClick = _this.onContentClick.bind(_assertThisInitialized(_this));
|
|
_this.onContentMouseDown = _this.onContentMouseDown.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(ColumnFilter, [{
|
|
key: "field",
|
|
get: function get() {
|
|
return this.getColumnProp('filterField') || this.getColumnProp('field');
|
|
}
|
|
}, {
|
|
key: "overlay",
|
|
get: function get() {
|
|
return this.overlayRef ? this.overlayRef.current : null;
|
|
}
|
|
}, {
|
|
key: "filterModel",
|
|
get: function get() {
|
|
return this.props.filters[this.field];
|
|
}
|
|
}, {
|
|
key: "filterStoreModel",
|
|
get: function get() {
|
|
return this.props.filtersStore[this.field];
|
|
}
|
|
}, {
|
|
key: "hasFilter",
|
|
value: function hasFilter() {
|
|
if (this.props.filtersStore) {
|
|
var fieldFilter = this.props.filtersStore[this.field];
|
|
return fieldFilter && (fieldFilter.operator ? !this.isFilterBlank(fieldFilter.constraints[0].value) : !this.isFilterBlank(fieldFilter.value));
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "hasRowFilter",
|
|
value: function hasRowFilter() {
|
|
return this.filterModel && !this.isFilterBlank(this.filterModel.value);
|
|
}
|
|
}, {
|
|
key: "isFilterBlank",
|
|
value: function isFilterBlank(filter) {
|
|
return ObjectUtils.isEmpty(filter);
|
|
}
|
|
}, {
|
|
key: "isRowMatchModeSelected",
|
|
value: function isRowMatchModeSelected(matchMode) {
|
|
return this.filterModel && this.filterModel.matchMode === matchMode;
|
|
}
|
|
}, {
|
|
key: "showMenuButton",
|
|
value: function showMenuButton() {
|
|
return this.getColumnProp('showFilterMenu') && (this.props.display === 'row' ? this.getColumnProp('dataType') !== 'boolean' : true);
|
|
}
|
|
}, {
|
|
key: "matchModes",
|
|
value: function matchModes() {
|
|
return this.getColumnProp('filterMatchModeOptions') || PrimeReact.filterMatchModeOptions[this.findDataType()].map(function (key) {
|
|
return {
|
|
label: localeOption(key),
|
|
value: key
|
|
};
|
|
});
|
|
}
|
|
}, {
|
|
key: "isShowMatchModes",
|
|
value: function isShowMatchModes() {
|
|
return this.getColumnProp('dataType') !== 'boolean' && this.getColumnProp('showFilterMatchModes') && this.matchModes() && this.getColumnProp('showFilterMenuOptions');
|
|
}
|
|
}, {
|
|
key: "isShowOperator",
|
|
value: function isShowOperator() {
|
|
return this.getColumnProp('showFilterOperator') && this.filterModel && this.filterModel.operator && this.getColumnProp('showFilterMenuOptions');
|
|
}
|
|
}, {
|
|
key: "showRemoveIcon",
|
|
value: function showRemoveIcon() {
|
|
return this.fieldConstraints().length > 1;
|
|
}
|
|
}, {
|
|
key: "isShowAddConstraint",
|
|
value: function isShowAddConstraint() {
|
|
return this.getColumnProp('showAddButton') && this.filterModel && this.filterModel.operator && this.fieldConstraints() && this.fieldConstraints().length < this.getColumnProp('maxConstraints') && this.getColumnProp('showFilterMenuOptions');
|
|
}
|
|
}, {
|
|
key: "isOutsideClicked",
|
|
value: function isOutsideClicked(target) {
|
|
return !this.isTargetClicked(target) && this.overlayRef && this.overlayRef.current && !(this.overlayRef.current.isSameNode(target) || this.overlayRef.current.contains(target));
|
|
}
|
|
}, {
|
|
key: "isTargetClicked",
|
|
value: function isTargetClicked(target) {
|
|
return this.icon && (this.icon.isSameNode(target) || this.icon.contains(target));
|
|
}
|
|
}, {
|
|
key: "getColumnProp",
|
|
value: function getColumnProp(prop) {
|
|
return this.props.column.props[prop];
|
|
}
|
|
}, {
|
|
key: "getDefaultConstraint",
|
|
value: function getDefaultConstraint() {
|
|
if (this.props.filtersStore && this.filterStoreModel) {
|
|
if (this.filterStoreModel.operator) {
|
|
return {
|
|
matchMode: this.filterStoreModel.constraints[0].matchMode,
|
|
operator: this.filterStoreModel.operator
|
|
};
|
|
} else {
|
|
return {
|
|
matchMode: this.filterStoreModel.matchMode
|
|
};
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "findDataType",
|
|
value: function findDataType() {
|
|
var dataType = this.getColumnProp('dataType');
|
|
var matchMode = this.getColumnProp('filterMatchMode');
|
|
|
|
var hasMatchMode = function hasMatchMode(key) {
|
|
return PrimeReact.filterMatchModeOptions[key].some(function (mode) {
|
|
return mode === matchMode;
|
|
});
|
|
};
|
|
|
|
if (matchMode === 'custom' && !hasMatchMode(dataType)) {
|
|
PrimeReact.filterMatchModeOptions[dataType].push(FilterMatchMode.CUSTOM);
|
|
return dataType;
|
|
} else if (matchMode) {
|
|
return Object.keys(PrimeReact.filterMatchModeOptions).find(function (key) {
|
|
return hasMatchMode(key);
|
|
}) || dataType;
|
|
}
|
|
|
|
return dataType;
|
|
}
|
|
}, {
|
|
key: "clearFilter",
|
|
value: function clearFilter() {
|
|
var field = this.field;
|
|
var filterClearCallback = this.getColumnProp('onFilterClear');
|
|
var defaultConstraint = this.getDefaultConstraint();
|
|
|
|
var filters = _objectSpread$v({}, this.props.filters);
|
|
|
|
if (filters[field].operator) {
|
|
filters[field].constraints.splice(1);
|
|
filters[field].operator = defaultConstraint.operator;
|
|
filters[field].constraints[0] = {
|
|
value: null,
|
|
matchMode: defaultConstraint.matchMode
|
|
};
|
|
} else {
|
|
filters[field].value = null;
|
|
filters[field].matchMode = defaultConstraint.matchMode;
|
|
}
|
|
|
|
filterClearCallback && filterClearCallback();
|
|
this.props.onFilterChange(filters);
|
|
this.props.onFilterApply();
|
|
this.hide();
|
|
}
|
|
}, {
|
|
key: "applyFilter",
|
|
value: function applyFilter() {
|
|
var filterApplyClickCallback = this.getColumnProp('onFilterApplyClick');
|
|
filterApplyClickCallback && filterApplyClickCallback({
|
|
field: this.field,
|
|
constraints: this.filterModel
|
|
});
|
|
this.props.onFilterApply();
|
|
this.hide();
|
|
}
|
|
}, {
|
|
key: "toggleMenu",
|
|
value: function toggleMenu() {
|
|
this.setState(function (prevState) {
|
|
return {
|
|
overlayVisible: !prevState.overlayVisible
|
|
};
|
|
});
|
|
}
|
|
}, {
|
|
key: "onToggleButtonKeyDown",
|
|
value: function onToggleButtonKeyDown(event) {
|
|
switch (event.key) {
|
|
case 'Escape':
|
|
case 'Tab':
|
|
this.hide();
|
|
break;
|
|
|
|
case 'ArrowDown':
|
|
if (this.state.overlayVisible) {
|
|
var focusable = DomHandler.getFirstFocusableElement(this.overlay);
|
|
focusable && focusable.focus();
|
|
event.preventDefault();
|
|
} else if (event.altKey) {
|
|
this.setState({
|
|
overlayVisible: true
|
|
});
|
|
event.preventDefault();
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}, {
|
|
key: "onContentKeyDown",
|
|
value: function onContentKeyDown(event) {
|
|
if (event.key === 'Escape') {
|
|
this.hide();
|
|
this.icon && this.icon.focus();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onInputChange",
|
|
value: function onInputChange(event, index) {
|
|
var filters = _objectSpread$v({}, this.props.filters);
|
|
|
|
var value = event.target.value;
|
|
|
|
if (this.props.display === 'menu') {
|
|
filters[this.field].constraints[index].value = value;
|
|
} else {
|
|
filters[this.field].value = value;
|
|
}
|
|
|
|
this.props.onFilterChange(filters);
|
|
|
|
if (!this.getColumnProp('showApplyButton') || this.props.display === 'row') {
|
|
this.props.onFilterApply();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onRowMatchModeChange",
|
|
value: function onRowMatchModeChange(matchMode) {
|
|
var filterMatchModeChangeCallback = this.getColumnProp('onFilterMatchModeChange');
|
|
|
|
var filters = _objectSpread$v({}, this.props.filters);
|
|
|
|
filters[this.field].matchMode = matchMode;
|
|
filterMatchModeChangeCallback && filterMatchModeChangeCallback({
|
|
field: this.field,
|
|
matchMode: matchMode
|
|
});
|
|
this.props.onFilterChange(filters);
|
|
this.props.onFilterApply();
|
|
this.hide();
|
|
}
|
|
}, {
|
|
key: "onRowMatchModeKeyDown",
|
|
value: function onRowMatchModeKeyDown(event, matchMode, clear) {
|
|
var item = event.target;
|
|
|
|
switch (event.key) {
|
|
case 'ArrowDown':
|
|
var nextItem = this.findNextItem(item);
|
|
|
|
if (nextItem) {
|
|
item.removeAttribute('tabindex');
|
|
nextItem.tabIndex = 0;
|
|
nextItem.focus();
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
|
|
case 'ArrowUp':
|
|
var prevItem = this.findPrevItem(item);
|
|
|
|
if (prevItem) {
|
|
item.removeAttribute('tabindex');
|
|
prevItem.tabIndex = 0;
|
|
prevItem.focus();
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
|
|
case 'Enter':
|
|
clear ? this.clearFilter() : this.onRowMatchModeChange(matchMode.value);
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
}
|
|
}, {
|
|
key: "onOperatorChange",
|
|
value: function onOperatorChange(e) {
|
|
var filterOperationChangeCallback = this.getColumnProp('onFilterOperatorChange');
|
|
var value = e.value;
|
|
|
|
var filters = _objectSpread$v({}, this.props.filters);
|
|
|
|
filters[this.field].operator = value;
|
|
this.props.onFilterChange(filters);
|
|
filterOperationChangeCallback && filterOperationChangeCallback({
|
|
field: this.field,
|
|
operator: value
|
|
});
|
|
|
|
if (!this.getColumnProp('showApplyButton')) {
|
|
this.props.onFilterApply();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onMenuMatchModeChange",
|
|
value: function onMenuMatchModeChange(value, index) {
|
|
var filterMatchModeChangeCallback = this.getColumnProp('onFilterMatchModeChange');
|
|
|
|
var filters = _objectSpread$v({}, this.props.filters);
|
|
|
|
filters[this.field].constraints[index].matchMode = value;
|
|
this.props.onFilterChange(filters);
|
|
filterMatchModeChangeCallback && filterMatchModeChangeCallback({
|
|
field: this.field,
|
|
matchMode: value,
|
|
index: index
|
|
});
|
|
|
|
if (!this.getColumnProp('showApplyButton')) {
|
|
this.props.onFilterApply();
|
|
}
|
|
}
|
|
}, {
|
|
key: "addConstraint",
|
|
value: function addConstraint() {
|
|
var filterConstraintAddCallback = this.getColumnProp('onFilterConstraintAdd');
|
|
var defaultConstraint = this.getDefaultConstraint();
|
|
|
|
var filters = _objectSpread$v({}, this.props.filters);
|
|
|
|
var newConstraint = {
|
|
value: null,
|
|
matchMode: defaultConstraint.matchMode
|
|
};
|
|
filters[this.field].constraints.push(newConstraint);
|
|
filterConstraintAddCallback && filterConstraintAddCallback({
|
|
field: this.field,
|
|
constraint: newConstraint
|
|
});
|
|
this.props.onFilterChange(filters);
|
|
|
|
if (!this.getColumnProp('showApplyButton')) {
|
|
this.props.onFilterApply();
|
|
}
|
|
}
|
|
}, {
|
|
key: "removeConstraint",
|
|
value: function removeConstraint(index) {
|
|
var filterConstraintRemoveCallback = this.getColumnProp('onFilterConstraintRemove');
|
|
|
|
var filters = _objectSpread$v({}, this.props.filters);
|
|
|
|
var removedConstraint = filters[this.field].constraints.splice(index, 1);
|
|
filterConstraintRemoveCallback && filterConstraintRemoveCallback({
|
|
field: this.field,
|
|
constraint: removedConstraint
|
|
});
|
|
this.props.onFilterChange(filters);
|
|
|
|
if (!this.getColumnProp('showApplyButton')) {
|
|
this.props.onFilterApply();
|
|
}
|
|
}
|
|
}, {
|
|
key: "findNextItem",
|
|
value: function findNextItem(item) {
|
|
var nextItem = item.nextElementSibling;
|
|
if (nextItem) return DomHandler.hasClass(nextItem, 'p-column-filter-separator') ? this.findNextItem(nextItem) : nextItem;else return item.parentElement.firstElementChild;
|
|
}
|
|
}, {
|
|
key: "findPrevItem",
|
|
value: function findPrevItem(item) {
|
|
var prevItem = item.previousElementSibling;
|
|
if (prevItem) return DomHandler.hasClass(prevItem, 'p-column-filter-separator') ? this.findPrevItem(prevItem) : prevItem;else return item.parentElement.lastElementChild;
|
|
}
|
|
}, {
|
|
key: "hide",
|
|
value: function hide() {
|
|
this.setState({
|
|
overlayVisible: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "onContentClick",
|
|
value: function onContentClick(event) {
|
|
this.selfClick = true;
|
|
OverlayService.emit('overlay-click', {
|
|
originalEvent: event,
|
|
target: this.overlay
|
|
});
|
|
}
|
|
}, {
|
|
key: "onContentMouseDown",
|
|
value: function onContentMouseDown() {
|
|
this.selfClick = true;
|
|
}
|
|
}, {
|
|
key: "onOverlayEnter",
|
|
value: function onOverlayEnter() {
|
|
var _this2 = this;
|
|
|
|
ZIndexUtils.set('overlay', this.overlay, PrimeReact.autoZIndex, PrimeReact.zIndex['overlay']);
|
|
DomHandler.alignOverlay(this.overlay, this.icon, PrimeReact.appendTo, false);
|
|
this.bindOutsideClickListener();
|
|
this.bindScrollListener();
|
|
this.bindResizeListener();
|
|
|
|
this.overlayEventListener = function (e) {
|
|
if (!_this2.isOutsideClicked(e.target)) {
|
|
_this2.selfClick = true;
|
|
}
|
|
};
|
|
|
|
OverlayService.on('overlay-click', this.overlayEventListener);
|
|
}
|
|
}, {
|
|
key: "onOverlayExit",
|
|
value: function onOverlayExit() {
|
|
this.onOverlayHide();
|
|
}
|
|
}, {
|
|
key: "onOverlayExited",
|
|
value: function onOverlayExited() {
|
|
ZIndexUtils.clear(this.overlay);
|
|
}
|
|
}, {
|
|
key: "onOverlayHide",
|
|
value: function onOverlayHide() {
|
|
this.unbindOutsideClickListener();
|
|
this.unbindResizeListener();
|
|
this.unbindScrollListener();
|
|
OverlayService.off('overlay-click', this.overlayEventListener);
|
|
this.overlayEventListener = null;
|
|
}
|
|
}, {
|
|
key: "bindOutsideClickListener",
|
|
value: function bindOutsideClickListener() {
|
|
var _this3 = this;
|
|
|
|
if (!this.outsideClickListener) {
|
|
this.outsideClickListener = function (event) {
|
|
if (!_this3.selfClick && _this3.isOutsideClicked(event.target)) {
|
|
_this3.hide();
|
|
}
|
|
|
|
_this3.selfClick = false;
|
|
};
|
|
|
|
document.addEventListener('click', this.outsideClickListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindOutsideClickListener",
|
|
value: function unbindOutsideClickListener() {
|
|
if (this.outsideClickListener) {
|
|
document.removeEventListener('click', this.outsideClickListener);
|
|
this.outsideClickListener = null;
|
|
this.selfClick = false;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindScrollListener",
|
|
value: function bindScrollListener() {
|
|
var _this4 = this;
|
|
|
|
if (!this.scrollHandler) {
|
|
this.scrollHandler = new ConnectedOverlayScrollHandler(this.icon, function () {
|
|
if (_this4.state.overlayVisible) {
|
|
_this4.hide();
|
|
}
|
|
});
|
|
}
|
|
|
|
this.scrollHandler.bindScrollListener();
|
|
}
|
|
}, {
|
|
key: "unbindScrollListener",
|
|
value: function unbindScrollListener() {
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.unbindScrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindResizeListener",
|
|
value: function bindResizeListener() {
|
|
var _this5 = this;
|
|
|
|
if (!this.resizeListener) {
|
|
this.resizeListener = function () {
|
|
if (_this5.state.overlayVisible && !DomHandler.isTouchDevice()) {
|
|
_this5.hide();
|
|
}
|
|
};
|
|
|
|
window.addEventListener('resize', this.resizeListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindResizeListener",
|
|
value: function unbindResizeListener() {
|
|
if (this.resizeListener) {
|
|
window.removeEventListener('resize', this.resizeListener);
|
|
this.resizeListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "fieldConstraints",
|
|
value: function fieldConstraints() {
|
|
return this.filterModel ? this.filterModel.constraints || [this.filterModel] : [];
|
|
}
|
|
}, {
|
|
key: "operator",
|
|
value: function operator() {
|
|
return this.filterModel.operator;
|
|
}
|
|
}, {
|
|
key: "operatorOptions",
|
|
value: function operatorOptions() {
|
|
return [{
|
|
label: localeOption('matchAll'),
|
|
value: FilterOperator.AND
|
|
}, {
|
|
label: localeOption('matchAny'),
|
|
value: FilterOperator.OR
|
|
}];
|
|
}
|
|
}, {
|
|
key: "noFilterLabel",
|
|
value: function noFilterLabel() {
|
|
return localeOption('noFilter');
|
|
}
|
|
}, {
|
|
key: "removeRuleButtonLabel",
|
|
value: function removeRuleButtonLabel() {
|
|
return localeOption('removeRule');
|
|
}
|
|
}, {
|
|
key: "addRuleButtonLabel",
|
|
value: function addRuleButtonLabel() {
|
|
return localeOption('addRule');
|
|
}
|
|
}, {
|
|
key: "clearButtonLabel",
|
|
value: function clearButtonLabel() {
|
|
return localeOption('clear');
|
|
}
|
|
}, {
|
|
key: "applyButtonLabel",
|
|
value: function applyButtonLabel() {
|
|
return localeOption('apply');
|
|
}
|
|
}, {
|
|
key: "filterCallback",
|
|
value: function filterCallback(value) {
|
|
var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
|
|
|
|
var filters = _objectSpread$v({}, this.props.filters);
|
|
|
|
var meta = filters[this.field];
|
|
this.props.display === 'menu' && meta && meta.operator ? filters[this.field].constraints[index].value = value : filters[this.field].value = value;
|
|
this.props.onFilterChange(filters);
|
|
}
|
|
}, {
|
|
key: "filterApplyCallback",
|
|
value: function filterApplyCallback() {
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
args && this.filterCallback(args[0], args[1]);
|
|
this.props.onFilterApply();
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps, prevState) {
|
|
if (this.props.display === 'menu' && this.state.overlayVisible) {
|
|
DomHandler.alignOverlay(this.overlay, this.icon, PrimeReact.appendTo, false);
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.overlayEventListener) {
|
|
OverlayService.off('overlay-click', this.overlayEventListener);
|
|
this.overlayEventListener = null;
|
|
}
|
|
|
|
if (this.overlay) {
|
|
ZIndexUtils.clear(this.overlay);
|
|
this.onOverlayHide();
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderFilterElement",
|
|
value: function renderFilterElement(model, index) {
|
|
var _this6 = this;
|
|
|
|
var value = model ? model.value : null;
|
|
return this.getColumnProp('filterElement') ? ObjectUtils.getJSXElement(this.getColumnProp('filterElement'), {
|
|
field: this.field,
|
|
index: index,
|
|
filterModel: model,
|
|
value: value,
|
|
filterApplyCallback: this.filterApplyCallback,
|
|
filterCallback: this.filterCallback
|
|
}) : /*#__PURE__*/React.createElement(InputText, {
|
|
type: this.getColumnProp('filterType'),
|
|
value: value || '',
|
|
onChange: function onChange(e) {
|
|
return _this6.onInputChange(e, index);
|
|
},
|
|
className: "p-column-filter",
|
|
placeholder: this.getColumnProp('filterPlaceholder'),
|
|
maxLength: this.getColumnProp('filterMaxLength')
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderRowFilterElement",
|
|
value: function renderRowFilterElement() {
|
|
if (this.props.display === 'row') {
|
|
var content = this.renderFilterElement(this.filterModel, 0);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-fluid p-column-filter-element"
|
|
}, content);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderMenuFilterElement",
|
|
value: function renderMenuFilterElement(fieldConstraint, index) {
|
|
if (this.props.display === 'menu') {
|
|
return this.renderFilterElement(fieldConstraint, index);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderMenuButton",
|
|
value: function renderMenuButton() {
|
|
var _this7 = this;
|
|
|
|
if (this.showMenuButton()) {
|
|
var className = classNames('p-column-filter-menu-button p-link', {
|
|
'p-column-filter-menu-button-open': this.state.overlayVisible,
|
|
'p-column-filter-menu-button-active': this.hasFilter()
|
|
});
|
|
return /*#__PURE__*/React.createElement("button", {
|
|
ref: function ref(el) {
|
|
return _this7.icon = el;
|
|
},
|
|
type: "button",
|
|
className: className,
|
|
"aria-haspopup": true,
|
|
"aria-expanded": this.state.overlayVisible,
|
|
onClick: this.toggleMenu,
|
|
onKeyDown: this.onToggleButtonKeyDown
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "pi pi-filter-icon pi-filter"
|
|
}));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderClearButton",
|
|
value: function renderClearButton() {
|
|
if (this.getColumnProp('showClearButton') && this.props.display === 'row') {
|
|
var className = classNames('p-column-filter-clear-button p-link', {
|
|
'p-hidden-space': !this.hasRowFilter()
|
|
});
|
|
return /*#__PURE__*/React.createElement("button", {
|
|
className: className,
|
|
type: "button",
|
|
onClick: this.clearFilter
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "pi pi-filter-slash"
|
|
}));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderRowItems",
|
|
value: function renderRowItems() {
|
|
var _this8 = this;
|
|
|
|
if (this.isShowMatchModes()) {
|
|
var matchModes = this.matchModes();
|
|
var noFilterLabel = this.noFilterLabel();
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
className: "p-column-filter-row-items"
|
|
}, matchModes.map(function (matchMode, i) {
|
|
var value = matchMode.value,
|
|
label = matchMode.label;
|
|
var className = classNames('p-column-filter-row-item', {
|
|
'p-highlight': _this8.isRowMatchModeSelected(value)
|
|
});
|
|
var tabIndex = i === 0 ? 0 : null;
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
className: className,
|
|
key: label,
|
|
onClick: function onClick() {
|
|
return _this8.onRowMatchModeChange(value);
|
|
},
|
|
onKeyDown: function onKeyDown(e) {
|
|
return _this8.onRowMatchModeKeyDown(e, matchMode);
|
|
},
|
|
tabIndex: tabIndex
|
|
}, label);
|
|
}), /*#__PURE__*/React.createElement("li", {
|
|
className: "p-column-filter-separator"
|
|
}), /*#__PURE__*/React.createElement("li", {
|
|
className: "p-column-filter-row-item",
|
|
onClick: this.clearFilter,
|
|
onKeyDown: function onKeyDown(e) {
|
|
return _this8.onRowMatchModeKeyDown(e, null, true);
|
|
}
|
|
}, noFilterLabel));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderOperator",
|
|
value: function renderOperator() {
|
|
if (this.isShowOperator()) {
|
|
var options = this.operatorOptions();
|
|
var value = this.operator();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-column-filter-operator"
|
|
}, /*#__PURE__*/React.createElement(Dropdown, {
|
|
options: options,
|
|
value: value,
|
|
onChange: this.onOperatorChange,
|
|
className: "p-column-filter-operator-dropdown"
|
|
}));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderMatchModeDropdown",
|
|
value: function renderMatchModeDropdown(constraint, index) {
|
|
var _this9 = this;
|
|
|
|
if (this.isShowMatchModes()) {
|
|
var options = this.matchModes();
|
|
return /*#__PURE__*/React.createElement(Dropdown, {
|
|
options: options,
|
|
value: constraint.matchMode,
|
|
onChange: function onChange(e) {
|
|
return _this9.onMenuMatchModeChange(e.value, index);
|
|
},
|
|
className: "p-column-filter-matchmode-dropdown"
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderRemoveButton",
|
|
value: function renderRemoveButton(index) {
|
|
var _this10 = this;
|
|
|
|
if (this.showRemoveIcon()) {
|
|
var removeRuleLabel = this.removeRuleButtonLabel();
|
|
return /*#__PURE__*/React.createElement(Button, {
|
|
type: "button",
|
|
icon: "pi pi-trash",
|
|
className: "p-column-filter-remove-button p-button-text p-button-danger p-button-sm",
|
|
onClick: function onClick() {
|
|
return _this10.removeConstraint(index);
|
|
},
|
|
label: removeRuleLabel
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderConstraints",
|
|
value: function renderConstraints() {
|
|
var _this11 = this;
|
|
|
|
var fieldConstraints = this.fieldConstraints();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-column-filter-constraints"
|
|
}, fieldConstraints.map(function (fieldConstraint, i) {
|
|
var matchModeDropdown = _this11.renderMatchModeDropdown(fieldConstraint, i);
|
|
|
|
var menuFilterElement = _this11.renderMenuFilterElement(fieldConstraint, i);
|
|
|
|
var removeButton = _this11.renderRemoveButton(i);
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
key: i,
|
|
className: "p-column-filter-constraint"
|
|
}, matchModeDropdown, menuFilterElement, /*#__PURE__*/React.createElement("div", null, removeButton));
|
|
}));
|
|
}
|
|
}, {
|
|
key: "renderAddRule",
|
|
value: function renderAddRule() {
|
|
if (this.isShowAddConstraint()) {
|
|
var addRuleLabel = this.addRuleButtonLabel();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-column-filter-add-rule"
|
|
}, /*#__PURE__*/React.createElement(Button, {
|
|
type: "button",
|
|
label: addRuleLabel,
|
|
icon: "pi pi-plus",
|
|
className: "p-column-filter-add-button p-button-text p-button-sm",
|
|
onClick: this.addConstraint
|
|
}));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderFilterClearButton",
|
|
value: function renderFilterClearButton() {
|
|
if (this.getColumnProp('showClearButton')) {
|
|
if (!this.getColumnProp('filterClear')) {
|
|
var clearLabel = this.clearButtonLabel();
|
|
return /*#__PURE__*/React.createElement(Button, {
|
|
type: "button",
|
|
className: "p-button-outlined p-button-sm",
|
|
onClick: this.clearFilter,
|
|
label: clearLabel
|
|
});
|
|
}
|
|
|
|
return ObjectUtils.getJSXElement(this.getColumnProp('filterClear'), {
|
|
field: this.field,
|
|
filterModel: this.filterModel,
|
|
filterClearCallback: this.clearFilter
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderFilterApplyButton",
|
|
value: function renderFilterApplyButton() {
|
|
if (this.getColumnProp('showApplyButton')) {
|
|
if (!this.getColumnProp('filterApply')) {
|
|
var applyLabel = this.applyButtonLabel();
|
|
return /*#__PURE__*/React.createElement(Button, {
|
|
type: "button",
|
|
className: "p-button-sm",
|
|
onClick: this.applyFilter,
|
|
label: applyLabel
|
|
});
|
|
}
|
|
|
|
return ObjectUtils.getJSXElement(this.getColumnProp('filterApply'), {
|
|
field: this.field,
|
|
filterModel: this.filterModel,
|
|
filterApplyCallback: this.applyFilter
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderButtonBar",
|
|
value: function renderButtonBar() {
|
|
var clearButton = this.renderFilterClearButton();
|
|
var applyButton = this.renderFilterApplyButton();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-column-filter-buttonbar"
|
|
}, clearButton, applyButton);
|
|
}
|
|
}, {
|
|
key: "renderItems",
|
|
value: function renderItems() {
|
|
var operator = this.renderOperator();
|
|
var constraints = this.renderConstraints();
|
|
var addRule = this.renderAddRule();
|
|
var buttonBar = this.renderButtonBar();
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, operator, constraints, addRule, buttonBar);
|
|
}
|
|
}, {
|
|
key: "renderOverlay",
|
|
value: function renderOverlay() {
|
|
var style = this.getColumnProp('filterMenuStyle');
|
|
var className = classNames('p-column-filter-overlay p-component p-fluid', this.getColumnProp('filterMenuClassName'), {
|
|
'p-column-filter-overlay-menu': this.props.display === 'menu',
|
|
'p-input-filled': PrimeReact.inputStyle === 'filled',
|
|
'p-ripple-disabled': PrimeReact.ripple === false
|
|
});
|
|
var filterHeader = ObjectUtils.getJSXElement(this.getColumnProp('filterHeader'), {
|
|
field: this.field,
|
|
filterModel: this.filterModel,
|
|
filterApplyCallback: this.filterApplyCallback
|
|
});
|
|
var filterFooter = ObjectUtils.getJSXElement(this.getColumnProp('filterFooter'), {
|
|
field: this.field,
|
|
filterModel: this.filterModel,
|
|
filterApplyCallback: this.filterApplyCallback
|
|
});
|
|
var items = this.props.display === 'row' ? this.renderRowItems() : this.renderItems();
|
|
return /*#__PURE__*/React.createElement(Portal, null, /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.overlayRef,
|
|
classNames: "p-connected-overlay",
|
|
"in": this.state.overlayVisible,
|
|
timeout: {
|
|
enter: 120,
|
|
exit: 100
|
|
},
|
|
unmountOnExit: true,
|
|
onEnter: this.onOverlayEnter,
|
|
onExit: this.onOverlayExit,
|
|
onExited: this.onOverlayExited
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.overlayRef,
|
|
style: style,
|
|
className: className,
|
|
onKeyDown: this.onContentKeyDown,
|
|
onClick: this.onContentClick,
|
|
onMouseDown: this.onContentMouseDown
|
|
}, filterHeader, items, filterFooter)));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-column-filter p-fluid', {
|
|
'p-column-filter-row': this.props.display === 'row',
|
|
'p-column-filter-menu': this.props.display === 'menu'
|
|
});
|
|
var rowFilterElement = this.renderRowFilterElement();
|
|
var menuButton = this.renderMenuButton();
|
|
var clearButton = this.renderClearButton();
|
|
var overlay = this.renderOverlay();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: className
|
|
}, rowFilterElement, menuButton, clearButton, overlay);
|
|
}
|
|
}]);
|
|
|
|
return ColumnFilter;
|
|
}(Component);
|
|
|
|
function ownKeys$u(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$u(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$u(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$u(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$1s(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1s(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1s() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var HeaderCell = /*#__PURE__*/function (_Component) {
|
|
_inherits(HeaderCell, _Component);
|
|
|
|
var _super = _createSuper$1s(HeaderCell);
|
|
|
|
function HeaderCell(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, HeaderCell);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
styleObject: {}
|
|
};
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onMouseDown = _this.onMouseDown.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this)); // drag
|
|
|
|
_this.onDragStart = _this.onDragStart.bind(_assertThisInitialized(_this));
|
|
_this.onDragOver = _this.onDragOver.bind(_assertThisInitialized(_this));
|
|
_this.onDragLeave = _this.onDragLeave.bind(_assertThisInitialized(_this));
|
|
_this.onDrop = _this.onDrop.bind(_assertThisInitialized(_this)); // resize
|
|
|
|
_this.onResizerMouseDown = _this.onResizerMouseDown.bind(_assertThisInitialized(_this));
|
|
_this.onResizerClick = _this.onResizerClick.bind(_assertThisInitialized(_this));
|
|
_this.onResizerDoubleClick = _this.onResizerDoubleClick.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(HeaderCell, [{
|
|
key: "isBadgeVisible",
|
|
value: function isBadgeVisible() {
|
|
return this.props.multiSortMeta && this.props.multiSortMeta.length > 1;
|
|
}
|
|
}, {
|
|
key: "isSortableDisabled",
|
|
value: function isSortableDisabled() {
|
|
return !this.getColumnProp('sortable') || this.getColumnProp('sortable') && (this.props.allSortableDisabled || this.getColumnProp('sortableDisabled'));
|
|
}
|
|
}, {
|
|
key: "getColumnProp",
|
|
value: function getColumnProp() {
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
return this.props.column ? typeof args[0] === 'string' ? this.props.column.props[args[0]] : (args[0] || this.props.column).props[args[1]] : null;
|
|
}
|
|
}, {
|
|
key: "getStyle",
|
|
value: function getStyle() {
|
|
var headerStyle = this.getColumnProp('headerStyle');
|
|
var columnStyle = this.getColumnProp('style');
|
|
return this.getColumnProp('frozen') ? Object.assign({}, columnStyle, headerStyle, this.state.styleObject) : Object.assign({}, columnStyle, headerStyle);
|
|
}
|
|
}, {
|
|
key: "getMultiSortMetaIndex",
|
|
value: function getMultiSortMetaIndex() {
|
|
var _this2 = this;
|
|
|
|
return this.props.multiSortMeta.findIndex(function (meta) {
|
|
return meta.field === _this2.getColumnProp('field') || meta.field === _this2.getColumnProp('sortField');
|
|
});
|
|
}
|
|
}, {
|
|
key: "getSortMeta",
|
|
value: function getSortMeta() {
|
|
var sorted = false;
|
|
var sortOrder = 0;
|
|
var metaIndex = -1;
|
|
|
|
if (this.props.sortMode === 'single') {
|
|
sorted = this.props.sortField && (this.props.sortField === this.getColumnProp('field') || this.props.sortField === this.getColumnProp('sortField'));
|
|
sortOrder = sorted ? this.props.sortOrder : 0;
|
|
} else if (this.props.sortMode === 'multiple') {
|
|
metaIndex = this.getMultiSortMetaIndex();
|
|
|
|
if (metaIndex > -1) {
|
|
sorted = true;
|
|
sortOrder = this.props.multiSortMeta[metaIndex].order;
|
|
}
|
|
}
|
|
|
|
return {
|
|
sorted: sorted,
|
|
sortOrder: sortOrder,
|
|
metaIndex: metaIndex
|
|
};
|
|
}
|
|
}, {
|
|
key: "getAriaSort",
|
|
value: function getAriaSort(_ref) {
|
|
var sorted = _ref.sorted,
|
|
sortOrder = _ref.sortOrder;
|
|
|
|
if (this.getColumnProp('sortable')) {
|
|
var sortIcon = sorted ? sortOrder < 0 ? 'pi-sort-amount-down' : 'pi-sort-amount-up-alt' : 'pi-sort-alt';
|
|
if (sortIcon === 'pi-sort-amount-down') return 'descending';else if (sortIcon === 'pi-sort-amount-up-alt') return 'ascending';else return 'none';
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "updateStickyPosition",
|
|
value: function updateStickyPosition() {
|
|
if (this.getColumnProp('frozen')) {
|
|
var styleObject = _objectSpread$u({}, this.state.styleObject);
|
|
|
|
var align = this.getColumnProp('alignFrozen');
|
|
|
|
if (align === 'right') {
|
|
var right = 0;
|
|
var next = this.el.nextElementSibling;
|
|
|
|
if (next) {
|
|
right = DomHandler.getOuterWidth(next) + parseFloat(next.style.right || 0);
|
|
}
|
|
|
|
styleObject['right'] = right + 'px';
|
|
} else {
|
|
var left = 0;
|
|
var prev = this.el.previousElementSibling;
|
|
|
|
if (prev) {
|
|
left = DomHandler.getOuterWidth(prev) + parseFloat(prev.style.left || 0);
|
|
}
|
|
|
|
styleObject['left'] = left + 'px';
|
|
}
|
|
|
|
var filterRow = this.el.parentElement.nextElementSibling;
|
|
|
|
if (filterRow) {
|
|
var index = DomHandler.index(this.el);
|
|
filterRow.children[index].style.left = styleObject['left'];
|
|
filterRow.children[index].style.right = styleObject['right'];
|
|
}
|
|
|
|
var isSameStyle = this.state.styleObject['left'] === styleObject['left'] && this.state.styleObject['right'] === styleObject['right'];
|
|
!isSameStyle && this.setState({
|
|
styleObject: styleObject
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateSortableDisabled",
|
|
value: function updateSortableDisabled(prevColumn) {
|
|
if (this.getColumnProp(prevColumn, 'sortableDisabled') !== this.getColumnProp('sortableDisabled') || this.getColumnProp(prevColumn, 'sortable') !== this.getColumnProp('sortable')) {
|
|
this.props.onSortableChange();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
if (!this.isSortableDisabled()) {
|
|
var targetNode = event.target;
|
|
|
|
if (DomHandler.hasClass(targetNode, 'p-sortable-column') || DomHandler.hasClass(targetNode, 'p-column-title') || DomHandler.hasClass(targetNode, 'p-column-header-content') || DomHandler.hasClass(targetNode, 'p-sortable-column-icon') || DomHandler.hasClass(targetNode.parentElement, 'p-sortable-column-icon')) {
|
|
DomHandler.clearSelection();
|
|
this.props.onSortChange({
|
|
originalEvent: event,
|
|
column: this.props.column,
|
|
sortableDisabledFields: this.props.sortableDisabledFields
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onMouseDown",
|
|
value: function onMouseDown(event) {
|
|
this.props.onColumnMouseDown({
|
|
originalEvent: event,
|
|
column: this.props.column
|
|
});
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event) {
|
|
if (event.key === 'Enter' && event.currentTarget === this.el && DomHandler.hasClass(event.currentTarget, 'p-sortable-column')) {
|
|
this.onClick(event);
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDragStart",
|
|
value: function onDragStart(event) {
|
|
this.props.onColumnDragStart({
|
|
originalEvent: event,
|
|
column: this.props.column
|
|
});
|
|
}
|
|
}, {
|
|
key: "onDragOver",
|
|
value: function onDragOver(event) {
|
|
this.props.onColumnDragOver({
|
|
originalEvent: event,
|
|
column: this.props.column
|
|
});
|
|
}
|
|
}, {
|
|
key: "onDragLeave",
|
|
value: function onDragLeave(event) {
|
|
this.props.onColumnDragLeave({
|
|
originalEvent: event,
|
|
column: this.props.column
|
|
});
|
|
}
|
|
}, {
|
|
key: "onDrop",
|
|
value: function onDrop(event) {
|
|
this.props.onColumnDrop({
|
|
originalEvent: event,
|
|
column: this.props.column
|
|
});
|
|
}
|
|
}, {
|
|
key: "onResizerMouseDown",
|
|
value: function onResizerMouseDown(event) {
|
|
this.props.onColumnResizeStart({
|
|
originalEvent: event,
|
|
column: this.props.column
|
|
});
|
|
}
|
|
}, {
|
|
key: "onResizerClick",
|
|
value: function onResizerClick(event) {
|
|
if (this.props.onColumnResizerClick) {
|
|
this.props.onColumnResizerClick({
|
|
originalEvent: event,
|
|
element: event.currentTarget.parentElement,
|
|
column: this.props.column
|
|
});
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onResizerDoubleClick",
|
|
value: function onResizerDoubleClick(event) {
|
|
if (this.props.onColumnResizerDoubleClick) {
|
|
this.props.onColumnResizerDoubleClick({
|
|
originalEvent: event,
|
|
element: event.currentTarget.parentElement,
|
|
column: this.props.column
|
|
});
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (this.getColumnProp('frozen')) {
|
|
this.updateStickyPosition();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (this.getColumnProp('frozen')) {
|
|
this.updateStickyPosition();
|
|
}
|
|
|
|
this.updateSortableDisabled(prevProps.column);
|
|
}
|
|
}, {
|
|
key: "renderResizer",
|
|
value: function renderResizer() {
|
|
if (this.props.resizableColumns && !this.getColumnProp('frozen')) {
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: "p-column-resizer",
|
|
onMouseDown: this.onResizerMouseDown,
|
|
onClick: this.onResizerClick,
|
|
onDoubleClick: this.onResizerDoubleClick
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderTitle",
|
|
value: function renderTitle() {
|
|
var title = ObjectUtils.getJSXElement(this.getColumnProp('header'), {
|
|
props: this.props.tableProps
|
|
});
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: "p-column-title"
|
|
}, title);
|
|
}
|
|
}, {
|
|
key: "renderSortIcon",
|
|
value: function renderSortIcon(_ref2) {
|
|
var sorted = _ref2.sorted,
|
|
sortOrder = _ref2.sortOrder;
|
|
|
|
if (this.getColumnProp('sortable')) {
|
|
var sortIcon = sorted ? sortOrder < 0 ? 'pi-sort-amount-down' : 'pi-sort-amount-up-alt' : 'pi-sort-alt';
|
|
var className = classNames('p-sortable-column-icon pi pi-fw', sortIcon);
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: className
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderBadge",
|
|
value: function renderBadge(_ref3) {
|
|
var metaIndex = _ref3.metaIndex;
|
|
|
|
if (metaIndex !== -1 && this.isBadgeVisible()) {
|
|
var value = this.props.groupRowsBy && this.props.groupRowsBy === this.props.groupRowSortField ? metaIndex : metaIndex + 1;
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: "p-sortable-column-badge"
|
|
}, value);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderCheckbox",
|
|
value: function renderCheckbox() {
|
|
if (this.props.showSelectAll && this.getColumnProp('selectionMode') === 'multiple' && this.props.filterDisplay !== 'row') {
|
|
var allRowsSelected = this.props.allRowsSelected(this.props.value);
|
|
return /*#__PURE__*/React.createElement(HeaderCheckbox, {
|
|
checked: allRowsSelected,
|
|
onChange: this.props.onColumnCheckboxChange,
|
|
disabled: this.props.empty
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderFilter",
|
|
value: function renderFilter() {
|
|
if (this.props.filterDisplay === 'menu' && this.getColumnProp('filter')) {
|
|
return /*#__PURE__*/React.createElement(ColumnFilter, {
|
|
display: "menu",
|
|
column: this.props.column,
|
|
filters: this.props.filters,
|
|
onFilterChange: this.props.onFilterChange,
|
|
onFilterApply: this.props.onFilterApply,
|
|
filtersStore: this.props.filtersStore
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderHeader",
|
|
value: function renderHeader(sortMeta) {
|
|
var title = this.renderTitle();
|
|
var sortIcon = this.renderSortIcon(sortMeta);
|
|
var badge = this.renderBadge(sortMeta);
|
|
var checkbox = this.renderCheckbox();
|
|
var filter = this.renderFilter();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-column-header-content"
|
|
}, title, sortIcon, badge, checkbox, filter);
|
|
}
|
|
}, {
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
var _this3 = this;
|
|
|
|
var isSortableDisabled = this.isSortableDisabled();
|
|
var sortMeta = this.getSortMeta();
|
|
var style = this.getStyle();
|
|
var align = this.getColumnProp('alignHeader') || this.getColumnProp('align');
|
|
var className = classNames(this.getColumnProp('headerClassName'), this.getColumnProp('className'), _defineProperty({
|
|
'p-sortable-column': this.getColumnProp('sortable'),
|
|
'p-resizable-column': this.props.resizableColumns,
|
|
'p-highlight': sortMeta.sorted,
|
|
'p-frozen-column': this.getColumnProp('frozen'),
|
|
'p-selection-column': this.getColumnProp('selectionMode'),
|
|
'p-sortable-disabled': this.getColumnProp('sortable') && isSortableDisabled,
|
|
'p-reorderable-column': this.props.reorderableColumns && this.getColumnProp('reorderable')
|
|
}, "p-align-".concat(align), !!align));
|
|
var tabIndex = this.getColumnProp('sortable') && !isSortableDisabled ? this.props.tabIndex : null;
|
|
var colSpan = this.getColumnProp('colSpan');
|
|
var rowSpan = this.getColumnProp('rowSpan');
|
|
var ariaSort = this.getAriaSort(sortMeta);
|
|
var resizer = this.renderResizer();
|
|
var header = this.renderHeader(sortMeta);
|
|
return /*#__PURE__*/React.createElement("th", {
|
|
ref: function ref(el) {
|
|
return _this3.el = el;
|
|
},
|
|
style: style,
|
|
className: className,
|
|
tabIndex: tabIndex,
|
|
role: "columnheader",
|
|
onClick: this.onClick,
|
|
onKeyDown: this.onKeyDown,
|
|
onMouseDown: this.onMouseDown,
|
|
onDragStart: this.onDragStart,
|
|
onDragOver: this.onDragOver,
|
|
onDragLeave: this.onDragLeave,
|
|
onDrop: this.onDrop,
|
|
colSpan: colSpan,
|
|
rowSpan: rowSpan,
|
|
"aria-sort": ariaSort
|
|
}, resizer, header);
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
return this.renderElement();
|
|
}
|
|
}]);
|
|
|
|
return HeaderCell;
|
|
}(Component);
|
|
|
|
function ownKeys$t(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$t(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$t(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$t(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$1r(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1r(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1r() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var TableHeader = /*#__PURE__*/function (_Component) {
|
|
_inherits(TableHeader, _Component);
|
|
|
|
var _super = _createSuper$1r(TableHeader);
|
|
|
|
function TableHeader(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, TableHeader);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
sortableDisabledFields: [],
|
|
allSortableDisabled: false,
|
|
styleObject: {}
|
|
};
|
|
_this.onSortableChange = _this.onSortableChange.bind(_assertThisInitialized(_this));
|
|
_this.onCheckboxChange = _this.onCheckboxChange.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(TableHeader, [{
|
|
key: "isSingleSort",
|
|
value: function isSingleSort() {
|
|
return this.props.sortMode === 'single';
|
|
}
|
|
}, {
|
|
key: "isMultipleSort",
|
|
value: function isMultipleSort() {
|
|
return this.props.sortMode === 'multiple';
|
|
}
|
|
}, {
|
|
key: "isAllSortableDisabled",
|
|
value: function isAllSortableDisabled() {
|
|
return this.isSingleSort() && this.state.allSortableDisabled;
|
|
}
|
|
}, {
|
|
key: "isColumnSorted",
|
|
value: function isColumnSorted(column) {
|
|
return this.props.sortField !== null ? column.props.field === this.props.sortField || column.props.sortField === this.props.sortField : false;
|
|
}
|
|
}, {
|
|
key: "updateSortableDisabled",
|
|
value: function updateSortableDisabled() {
|
|
var _this2 = this;
|
|
|
|
if (this.isSingleSort() || this.isMultipleSort() && this.props.onSortChange) {
|
|
var sortableDisabledFields = [];
|
|
var allSortableDisabled = false;
|
|
this.props.columns.forEach(function (column) {
|
|
if (column.props.sortableDisabled) {
|
|
sortableDisabledFields.push(column.props.sortField || column.props.field);
|
|
|
|
if (!allSortableDisabled && _this2.isColumnSorted(column)) {
|
|
allSortableDisabled = true;
|
|
}
|
|
}
|
|
});
|
|
this.setState({
|
|
sortableDisabledFields: sortableDisabledFields,
|
|
allSortableDisabled: allSortableDisabled
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onSortableChange",
|
|
value: function onSortableChange() {
|
|
this.updateSortableDisabled();
|
|
}
|
|
}, {
|
|
key: "onCheckboxChange",
|
|
value: function onCheckboxChange(e) {
|
|
this.props.onColumnCheckboxChange(e, this.props.value);
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.updateSortableDisabled();
|
|
}
|
|
}, {
|
|
key: "renderGroupHeaderCells",
|
|
value: function renderGroupHeaderCells(row) {
|
|
var columns = React.Children.toArray(row.props.children);
|
|
return this.renderHeaderCells(columns);
|
|
}
|
|
}, {
|
|
key: "renderHeaderCells",
|
|
value: function renderHeaderCells(columns) {
|
|
var _this3 = this;
|
|
|
|
return React.Children.map(columns, function (col, i) {
|
|
var isVisible = col ? !col.props.hidden : true;
|
|
var key = col ? col.props.columnKey || col.props.field || i : i;
|
|
return isVisible && /*#__PURE__*/React.createElement(HeaderCell, {
|
|
key: key,
|
|
value: _this3.props.value,
|
|
tableProps: _this3.props.tableProps,
|
|
column: col,
|
|
tabIndex: _this3.props.tabIndex,
|
|
empty: _this3.props.empty,
|
|
resizableColumns: _this3.props.resizableColumns,
|
|
groupRowsBy: _this3.props.groupRowsBy,
|
|
groupRowSortField: _this3.props.groupRowSortField,
|
|
sortMode: _this3.props.sortMode,
|
|
sortField: _this3.props.sortField,
|
|
sortOrder: _this3.props.sortOrder,
|
|
multiSortMeta: _this3.props.multiSortMeta,
|
|
allSortableDisabled: _this3.isAllSortableDisabled(),
|
|
onSortableChange: _this3.onSortableChange,
|
|
sortableDisabledFields: _this3.state.sortableDisabledFields,
|
|
filterDisplay: _this3.props.filterDisplay,
|
|
filters: _this3.props.filters,
|
|
filtersStore: _this3.props.filtersStore,
|
|
onFilterChange: _this3.props.onFilterChange,
|
|
onFilterApply: _this3.props.onFilterApply,
|
|
onColumnMouseDown: _this3.props.onColumnMouseDown,
|
|
onColumnDragStart: _this3.props.onColumnDragStart,
|
|
onColumnDragOver: _this3.props.onColumnDragOver,
|
|
onColumnDragLeave: _this3.props.onColumnDragLeave,
|
|
onColumnDrop: _this3.props.onColumnDrop,
|
|
onColumnResizeStart: _this3.props.onColumnResizeStart,
|
|
onColumnResizerClick: _this3.props.onColumnResizerClick,
|
|
onColumnResizerDoubleClick: _this3.props.onColumnResizerDoubleClick,
|
|
showSelectAll: _this3.props.showSelectAll,
|
|
allRowsSelected: _this3.props.allRowsSelected,
|
|
onColumnCheckboxChange: _this3.onCheckboxChange,
|
|
reorderableColumns: _this3.props.reorderableColumns,
|
|
onSortChange: _this3.props.onSortChange
|
|
});
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderCheckbox",
|
|
value: function renderCheckbox(selectionMode) {
|
|
if (this.props.showSelectAll && selectionMode === 'multiple') {
|
|
var allRowsSelected = this.props.allRowsSelected(this.props.value);
|
|
return /*#__PURE__*/React.createElement(HeaderCheckbox, {
|
|
checked: allRowsSelected,
|
|
onChange: this.onCheckboxChange,
|
|
disabled: this.props.empty
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderFilter",
|
|
value: function renderFilter(column, filter) {
|
|
if (filter) {
|
|
return /*#__PURE__*/React.createElement(ColumnFilter, {
|
|
display: "row",
|
|
column: column,
|
|
filters: this.props.filters,
|
|
filtersStore: this.props.filtersStore,
|
|
onFilterChange: this.props.onFilterChange,
|
|
onFilterApply: this.props.onFilterApply
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderFilterCells",
|
|
value: function renderFilterCells() {
|
|
var _this4 = this;
|
|
|
|
return React.Children.map(this.props.columns, function (col, i) {
|
|
var isVisible = !col.props.hidden;
|
|
|
|
if (isVisible) {
|
|
var _col$props = col.props,
|
|
filterHeaderStyle = _col$props.filterHeaderStyle,
|
|
style = _col$props.style,
|
|
filterHeaderClassName = _col$props.filterHeaderClassName,
|
|
className = _col$props.className,
|
|
frozen = _col$props.frozen,
|
|
columnKey = _col$props.columnKey,
|
|
field = _col$props.field,
|
|
selectionMode = _col$props.selectionMode,
|
|
filter = _col$props.filter;
|
|
|
|
var colStyle = _objectSpread$t(_objectSpread$t({}, filterHeaderStyle || {}), style || {});
|
|
|
|
var colClassName = classNames('p-filter-column', filterHeaderClassName, className, {
|
|
'p-frozen-column': frozen
|
|
});
|
|
var colKey = columnKey || field || i;
|
|
|
|
var checkbox = _this4.renderCheckbox(selectionMode);
|
|
|
|
var filterRow = _this4.renderFilter(col, filter);
|
|
|
|
return /*#__PURE__*/React.createElement("th", {
|
|
key: colKey,
|
|
style: colStyle,
|
|
className: colClassName
|
|
}, checkbox, filterRow);
|
|
}
|
|
|
|
return null;
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
var _this5 = this;
|
|
|
|
if (this.props.headerColumnGroup) {
|
|
var rows = React.Children.toArray(this.props.headerColumnGroup.props.children);
|
|
return rows.map(function (row, i) {
|
|
return /*#__PURE__*/React.createElement("tr", {
|
|
key: i,
|
|
role: "row"
|
|
}, _this5.renderGroupHeaderCells(row));
|
|
});
|
|
} else {
|
|
var headerRow = /*#__PURE__*/React.createElement("tr", {
|
|
role: "row"
|
|
}, this.renderHeaderCells(this.props.columns));
|
|
var filterRow = this.props.filterDisplay === 'row' && /*#__PURE__*/React.createElement("tr", {
|
|
role: "row"
|
|
}, this.renderFilterCells());
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, headerRow, filterRow);
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var content = this.renderContent();
|
|
return /*#__PURE__*/React.createElement("thead", {
|
|
className: "p-datatable-thead"
|
|
}, content);
|
|
}
|
|
}]);
|
|
|
|
return TableHeader;
|
|
}(Component);
|
|
|
|
function ownKeys$s(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$s(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$s(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$s(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$1q(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1q(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1q() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var DataTable = /*#__PURE__*/function (_Component) {
|
|
_inherits(DataTable, _Component);
|
|
|
|
var _super = _createSuper$1q(DataTable);
|
|
|
|
function DataTable(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, DataTable);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
d_rows: props.rows,
|
|
columnOrder: [],
|
|
groupRowsSortMeta: null,
|
|
editingMeta: {},
|
|
attributeSelector: null
|
|
};
|
|
|
|
if (!_this.props.onPage) {
|
|
_this.state.first = props.first;
|
|
_this.state.rows = props.rows;
|
|
}
|
|
|
|
if (!_this.props.onSort) {
|
|
_this.state.sortField = props.sortField;
|
|
_this.state.sortOrder = props.sortOrder;
|
|
_this.state.multiSortMeta = props.multiSortMeta;
|
|
}
|
|
|
|
_this.state.d_filters = _this.cloneFilters(props.filters);
|
|
|
|
if (!_this.props.onFilter) {
|
|
_this.state.filters = props.filters;
|
|
} // header
|
|
|
|
|
|
_this.onSortChange = _this.onSortChange.bind(_assertThisInitialized(_this));
|
|
_this.onFilterChange = _this.onFilterChange.bind(_assertThisInitialized(_this));
|
|
_this.onFilterApply = _this.onFilterApply.bind(_assertThisInitialized(_this));
|
|
_this.onColumnHeaderMouseDown = _this.onColumnHeaderMouseDown.bind(_assertThisInitialized(_this));
|
|
_this.onColumnHeaderDragStart = _this.onColumnHeaderDragStart.bind(_assertThisInitialized(_this));
|
|
_this.onColumnHeaderDragOver = _this.onColumnHeaderDragOver.bind(_assertThisInitialized(_this));
|
|
_this.onColumnHeaderDragLeave = _this.onColumnHeaderDragLeave.bind(_assertThisInitialized(_this));
|
|
_this.onColumnHeaderDrop = _this.onColumnHeaderDrop.bind(_assertThisInitialized(_this));
|
|
_this.onColumnResizeStart = _this.onColumnResizeStart.bind(_assertThisInitialized(_this));
|
|
_this.onColumnHeaderCheckboxChange = _this.onColumnHeaderCheckboxChange.bind(_assertThisInitialized(_this));
|
|
_this.allRowsSelected = _this.allRowsSelected.bind(_assertThisInitialized(_this)); // body
|
|
|
|
_this.onEditingMetaChange = _this.onEditingMetaChange.bind(_assertThisInitialized(_this)); //paginator
|
|
|
|
_this.onPageChange = _this.onPageChange.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(DataTable, [{
|
|
key: "isCustomStateStorage",
|
|
value: function isCustomStateStorage() {
|
|
return this.props.stateStorage === 'custom';
|
|
}
|
|
}, {
|
|
key: "isStateful",
|
|
value: function isStateful() {
|
|
return this.props.stateKey != null || this.isCustomStateStorage();
|
|
}
|
|
}, {
|
|
key: "isVirtualScrollerDisabled",
|
|
value: function isVirtualScrollerDisabled() {
|
|
return ObjectUtils.isEmpty(this.props.virtualScrollerOptions) || !this.props.scrollable;
|
|
}
|
|
}, {
|
|
key: "isEquals",
|
|
value: function isEquals(data1, data2) {
|
|
return this.props.compareSelectionBy === 'equals' ? data1 === data2 : ObjectUtils.equals(data1, data2, this.props.dataKey);
|
|
}
|
|
}, {
|
|
key: "hasFilter",
|
|
value: function hasFilter() {
|
|
return ObjectUtils.isNotEmpty(this.getFilters()) || this.props.globalFilter;
|
|
}
|
|
}, {
|
|
key: "getFirst",
|
|
value: function getFirst() {
|
|
return this.props.onPage ? this.props.first : this.state.first;
|
|
}
|
|
}, {
|
|
key: "getRows",
|
|
value: function getRows() {
|
|
return this.props.onPage ? this.props.rows : this.state.rows;
|
|
}
|
|
}, {
|
|
key: "getSortField",
|
|
value: function getSortField() {
|
|
return this.props.onSort ? this.props.sortField : this.state.sortField;
|
|
}
|
|
}, {
|
|
key: "getSortOrder",
|
|
value: function getSortOrder() {
|
|
return this.props.onSort ? this.props.sortOrder : this.state.sortOrder;
|
|
}
|
|
}, {
|
|
key: "getMultiSortMeta",
|
|
value: function getMultiSortMeta() {
|
|
return (this.props.onSort ? this.props.multiSortMeta : this.state.multiSortMeta) || [];
|
|
}
|
|
}, {
|
|
key: "getFilters",
|
|
value: function getFilters() {
|
|
return this.props.onFilter ? this.props.filters : this.state.filters;
|
|
}
|
|
}, {
|
|
key: "getColumnProp",
|
|
value: function getColumnProp(col, prop) {
|
|
return col.props[prop];
|
|
}
|
|
}, {
|
|
key: "getColumns",
|
|
value: function getColumns(ignoreReorderable) {
|
|
var _this2 = this;
|
|
|
|
var columns = React.Children.toArray(this.props.children);
|
|
|
|
if (!columns) {
|
|
return null;
|
|
}
|
|
|
|
if (!ignoreReorderable && this.props.reorderableColumns && this.state.columnOrder) {
|
|
var orderedColumns = this.state.columnOrder.reduce(function (arr, columnKey) {
|
|
var column = _this2.findColumnByKey(columns, columnKey);
|
|
|
|
column && arr.push(column);
|
|
return arr;
|
|
}, []);
|
|
return [].concat(_toConsumableArray(orderedColumns), _toConsumableArray(columns.filter(function (col) {
|
|
return orderedColumns.indexOf(col) < 0;
|
|
})));
|
|
}
|
|
|
|
return columns;
|
|
}
|
|
}, {
|
|
key: "getStorage",
|
|
value: function getStorage() {
|
|
switch (this.props.stateStorage) {
|
|
case 'local':
|
|
return window.localStorage;
|
|
|
|
case 'session':
|
|
return window.sessionStorage;
|
|
|
|
case 'custom':
|
|
return null;
|
|
|
|
default:
|
|
throw new Error(this.props.stateStorage + ' is not a valid value for the state storage, supported values are "local", "session" and "custom".');
|
|
}
|
|
}
|
|
}, {
|
|
key: "saveState",
|
|
value: function saveState() {
|
|
var state = {};
|
|
|
|
if (this.props.paginator) {
|
|
state.first = this.getFirst();
|
|
state.rows = this.getRows();
|
|
}
|
|
|
|
var sortField = this.getSortField();
|
|
|
|
if (sortField) {
|
|
state.sortField = sortField;
|
|
state.sortOrder = this.getSortOrder();
|
|
}
|
|
|
|
var multiSortMeta = this.getMultiSortMeta();
|
|
|
|
if (multiSortMeta) {
|
|
state.multiSortMeta = multiSortMeta;
|
|
}
|
|
|
|
if (this.hasFilter()) {
|
|
state.filters = this.getFilters();
|
|
}
|
|
|
|
if (this.props.resizableColumns) {
|
|
this.saveColumnWidths(state);
|
|
}
|
|
|
|
if (this.props.reorderableColumns) {
|
|
state.columnOrder = this.state.columnOrder;
|
|
}
|
|
|
|
if (this.props.expandedRows) {
|
|
state.expandedRows = this.props.expandedRows;
|
|
}
|
|
|
|
if (this.props.selection && this.props.onSelectionChange) {
|
|
state.selection = this.props.selection;
|
|
}
|
|
|
|
if (this.isCustomStateStorage()) {
|
|
if (this.props.customSaveState) {
|
|
this.props.customSaveState(state);
|
|
}
|
|
} else {
|
|
var storage = this.getStorage();
|
|
|
|
if (ObjectUtils.isNotEmpty(state)) {
|
|
storage.setItem(this.props.stateKey, JSON.stringify(state));
|
|
}
|
|
}
|
|
|
|
if (this.props.onStateSave) {
|
|
this.props.onStateSave(state);
|
|
}
|
|
}
|
|
}, {
|
|
key: "clearState",
|
|
value: function clearState() {
|
|
var storage = this.getStorage();
|
|
|
|
if (storage && this.props.stateKey) {
|
|
storage.removeItem(this.props.stateKey);
|
|
}
|
|
}
|
|
}, {
|
|
key: "restoreState",
|
|
value: function restoreState(state) {
|
|
var restoredState = {};
|
|
|
|
if (this.isCustomStateStorage()) {
|
|
if (this.props.customRestoreState) {
|
|
restoredState = this.props.customRestoreState();
|
|
}
|
|
} else {
|
|
var storage = this.getStorage();
|
|
var stateString = storage.getItem(this.props.stateKey);
|
|
var dateFormat = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z/;
|
|
|
|
var reviver = function reviver(key, value) {
|
|
return typeof value === "string" && dateFormat.test(value) ? new Date(value) : value;
|
|
};
|
|
|
|
if (stateString) {
|
|
restoredState = JSON.parse(stateString, reviver);
|
|
}
|
|
}
|
|
|
|
this._restoreState(restoredState, state);
|
|
}
|
|
}, {
|
|
key: "restoreTableState",
|
|
value: function restoreTableState(restoredState) {
|
|
var state = this._restoreState(restoredState);
|
|
|
|
if (ObjectUtils.isNotEmpty(state)) {
|
|
this.setState(state);
|
|
}
|
|
}
|
|
}, {
|
|
key: "_restoreState",
|
|
value: function _restoreState(restoredState) {
|
|
var _this3 = this;
|
|
|
|
var state = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
|
|
if (ObjectUtils.isNotEmpty(restoredState)) {
|
|
if (this.props.paginator) {
|
|
if (this.props.onPage) {
|
|
var getOnPageParams = function getOnPageParams(first, rows) {
|
|
var totalRecords = _this3.getTotalRecords(_this3.processedData());
|
|
|
|
var pageCount = Math.ceil(totalRecords / rows) || 1;
|
|
var page = Math.floor(first / rows);
|
|
return {
|
|
first: first,
|
|
rows: rows,
|
|
page: page,
|
|
pageCount: pageCount
|
|
};
|
|
};
|
|
|
|
this.props.onPage(this.createEvent(getOnPageParams(restoredState.first, restoredState.rows)));
|
|
} else {
|
|
state.first = restoredState.first;
|
|
state.rows = restoredState.rows;
|
|
}
|
|
}
|
|
|
|
if (restoredState.sortField) {
|
|
if (this.props.onSort) {
|
|
this.props.onSort(this.createEvent({
|
|
sortField: restoredState.sortField,
|
|
sortOrder: restoredState.sortOrder
|
|
}));
|
|
} else {
|
|
state.sortField = restoredState.sortField;
|
|
state.sortOrder = restoredState.sortOrder;
|
|
}
|
|
}
|
|
|
|
if (restoredState.multiSortMeta) {
|
|
if (this.props.onSort) {
|
|
this.props.onSort(this.createEvent({
|
|
multiSortMeta: restoredState.multiSortMeta
|
|
}));
|
|
} else {
|
|
state.multiSortMeta = restoredState.multiSortMeta;
|
|
}
|
|
}
|
|
|
|
if (restoredState.filters) {
|
|
state.d_filters = this.cloneFilters(restoredState.filters);
|
|
|
|
if (this.props.onFilter) {
|
|
this.props.onFilter(this.createEvent({
|
|
filters: restoredState.filters
|
|
}));
|
|
} else {
|
|
state.filters = this.cloneFilters(restoredState.filters);
|
|
}
|
|
}
|
|
|
|
if (this.props.resizableColumns) {
|
|
this.columnWidthsState = restoredState.columnWidths;
|
|
this.tableWidthState = restoredState.tableWidth;
|
|
}
|
|
|
|
if (this.props.reorderableColumns) {
|
|
state.columnOrder = restoredState.columnOrder;
|
|
}
|
|
|
|
if (restoredState.expandedRows && this.props.onRowToggle) {
|
|
this.props.onRowToggle({
|
|
data: restoredState.expandedRows
|
|
});
|
|
}
|
|
|
|
if (restoredState.selection && this.props.onSelectionChange) {
|
|
this.props.onSelectionChange({
|
|
value: restoredState.selection
|
|
});
|
|
}
|
|
|
|
if (this.props.onStateRestore) {
|
|
this.props.onStateRestore(restoredState);
|
|
}
|
|
}
|
|
|
|
return state;
|
|
}
|
|
}, {
|
|
key: "saveColumnWidths",
|
|
value: function saveColumnWidths(state) {
|
|
var widths = [];
|
|
var headers = DomHandler.find(this.el, '.p-datatable-thead > tr > th');
|
|
headers.forEach(function (header) {
|
|
return widths.push(DomHandler.getOuterWidth(header));
|
|
});
|
|
state.columnWidths = widths.join(',');
|
|
|
|
if (this.props.columnResizeMode === 'expand') {
|
|
state.tableWidth = DomHandler.getOuterWidth(this.table) + 'px';
|
|
}
|
|
}
|
|
}, {
|
|
key: "restoreColumnWidths",
|
|
value: function restoreColumnWidths() {
|
|
var _this4 = this;
|
|
|
|
if (this.columnWidthsState) {
|
|
var widths = this.columnWidthsState.split(',');
|
|
|
|
if (this.props.columnResizeMode === 'expand' && this.tableWidthState) {
|
|
this.table.style.width = this.tableWidthState;
|
|
this.table.style.minWidth = this.tableWidthState;
|
|
this.el.style.width = this.tableWidthState;
|
|
}
|
|
|
|
if (ObjectUtils.isNotEmpty(widths)) {
|
|
this.createStyleElement();
|
|
var innerHTML = '';
|
|
widths.forEach(function (width, index) {
|
|
var style = _this4.props.scrollable ? "flex: 1 1 ".concat(width, "px !important") : "width: ".concat(width, "px !important");
|
|
innerHTML += "\n .p-datatable[".concat(_this4.state.attributeSelector, "] .p-datatable-thead > tr > th:nth-child(").concat(index + 1, "),\n .p-datatable[").concat(_this4.state.attributeSelector, "] .p-datatable-tbody > tr > td:nth-child(").concat(index + 1, "),\n .p-datatable[").concat(_this4.state.attributeSelector, "] .p-datatable-tfoot > tr > td:nth-child(").concat(index + 1, ") {\n ").concat(style, "\n }\n ");
|
|
});
|
|
this.styleElement.innerHTML = innerHTML;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "findParentHeader",
|
|
value: function findParentHeader(element) {
|
|
if (element.nodeName === 'TH') {
|
|
return element;
|
|
} else {
|
|
var parent = element.parentElement;
|
|
|
|
while (parent.nodeName !== 'TH') {
|
|
parent = parent.parentElement;
|
|
if (!parent) break;
|
|
}
|
|
|
|
return parent;
|
|
}
|
|
}
|
|
}, {
|
|
key: "getGroupRowSortField",
|
|
value: function getGroupRowSortField() {
|
|
return this.props.sortMode === 'single' ? this.props.sortField : this.state.groupRowsSortMeta ? this.state.groupRowsSortMeta.field : null;
|
|
}
|
|
}, {
|
|
key: "getSelectableData",
|
|
value: function getSelectableData(val) {
|
|
var _this5 = this;
|
|
|
|
if (this.props.showSelectionElement || this.props.isDataSelectable) {
|
|
return val.filter(function (data, index) {
|
|
var isSelectable = true;
|
|
if (_this5.props.showSelectionElement) isSelectable = _this5.props.showSelectionElement({
|
|
rowIndex: index,
|
|
props: _this5.props
|
|
});
|
|
if (_this5.props.isDataSelectable && isSelectable) isSelectable = _this5.props.isDataSelectable({
|
|
data: data,
|
|
index: index
|
|
});
|
|
return isSelectable;
|
|
});
|
|
}
|
|
|
|
return val;
|
|
}
|
|
}, {
|
|
key: "allRowsSelected",
|
|
value: function allRowsSelected(processedData) {
|
|
var _this6 = this;
|
|
|
|
if (this.props.onSelectAllChange) {
|
|
return this.props.selectAll;
|
|
} else {
|
|
var data = this.props.selectionPageOnly ? this.dataToRender(processedData) : processedData;
|
|
var val = this.props.frozenValue ? [].concat(_toConsumableArray(this.props.frozenValue), _toConsumableArray(data)) : data;
|
|
var selectableVal = this.getSelectableData(val);
|
|
return selectableVal && this.props.selection && selectableVal.every(function (sv) {
|
|
return _this6.props.selection.some(function (s) {
|
|
return _this6.isEquals(s, sv);
|
|
});
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "getSelectionModeInColumn",
|
|
value: function getSelectionModeInColumn(columns) {
|
|
if (columns) {
|
|
var col = columns.find(function (c) {
|
|
return !!c.props.selectionMode;
|
|
});
|
|
return col ? col.props.selectionMode : null;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "findColumnByKey",
|
|
value: function findColumnByKey(columns, key) {
|
|
return ObjectUtils.isNotEmpty(columns) ? columns.find(function (col) {
|
|
return col.props.columnKey === key || col.props.field === key;
|
|
}) : null;
|
|
}
|
|
}, {
|
|
key: "getTotalRecords",
|
|
value: function getTotalRecords(data) {
|
|
return this.props.lazy ? this.props.totalRecords : data ? data.length : 0;
|
|
}
|
|
}, {
|
|
key: "onEditingMetaChange",
|
|
value: function onEditingMetaChange(e) {
|
|
var rowData = e.rowData,
|
|
field = e.field,
|
|
rowIndex = e.rowIndex,
|
|
editing = e.editing;
|
|
|
|
var editingMeta = _objectSpread$s({}, this.state.editingMeta);
|
|
|
|
var meta = editingMeta[rowIndex];
|
|
|
|
if (editing) {
|
|
!meta && (meta = editingMeta[rowIndex] = {
|
|
data: _objectSpread$s({}, rowData),
|
|
fields: []
|
|
});
|
|
meta['fields'].push(field);
|
|
} else if (meta) {
|
|
var fields = meta['fields'].filter(function (f) {
|
|
return f !== field;
|
|
});
|
|
!fields.length ? delete editingMeta[rowIndex] : meta['fields'] = fields;
|
|
}
|
|
|
|
this.setState({
|
|
editingMeta: editingMeta
|
|
});
|
|
}
|
|
}, {
|
|
key: "clearEditingMetaData",
|
|
value: function clearEditingMetaData() {
|
|
if (this.props.editMode && ObjectUtils.isNotEmpty(this.state.editingMeta)) {
|
|
this.setState({
|
|
editingMeta: {}
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onColumnResizeStart",
|
|
value: function onColumnResizeStart(e) {
|
|
var event = e.originalEvent,
|
|
column = e.column;
|
|
var containerLeft = DomHandler.getOffset(this.el).left;
|
|
this.resizeColumn = column;
|
|
this.resizeColumnElement = event.currentTarget.parentElement;
|
|
this.columnResizing = true;
|
|
this.lastResizeHelperX = event.pageX - containerLeft + this.el.scrollLeft;
|
|
this.bindColumnResizeEvents();
|
|
}
|
|
}, {
|
|
key: "onColumnResize",
|
|
value: function onColumnResize(event) {
|
|
var containerLeft = DomHandler.getOffset(this.el).left;
|
|
DomHandler.addClass(this.el, 'p-unselectable-text');
|
|
this.resizeHelper.style.height = this.el.offsetHeight + 'px';
|
|
this.resizeHelper.style.top = 0 + 'px';
|
|
this.resizeHelper.style.left = event.pageX - containerLeft + this.el.scrollLeft + 'px';
|
|
this.resizeHelper.style.display = 'block';
|
|
}
|
|
}, {
|
|
key: "onColumnResizeEnd",
|
|
value: function onColumnResizeEnd() {
|
|
var delta = this.resizeHelper.offsetLeft - this.lastResizeHelperX;
|
|
var columnWidth = this.resizeColumnElement.offsetWidth;
|
|
var newColumnWidth = columnWidth + delta;
|
|
var minWidth = this.resizeColumnElement.style.minWidth || 15;
|
|
|
|
if (columnWidth + delta > parseInt(minWidth, 10)) {
|
|
if (this.props.columnResizeMode === 'fit') {
|
|
var nextColumn = this.resizeColumnElement.nextElementSibling;
|
|
var nextColumnWidth = nextColumn.offsetWidth - delta;
|
|
|
|
if (newColumnWidth > 15 && nextColumnWidth > 15) {
|
|
this.resizeTableCells(newColumnWidth, nextColumnWidth);
|
|
}
|
|
} else if (this.props.columnResizeMode === 'expand') {
|
|
var tableWidth = this.table.offsetWidth + delta + 'px';
|
|
this.table.style.width = tableWidth;
|
|
this.table.style.minWidth = tableWidth;
|
|
this.resizeTableCells(newColumnWidth);
|
|
}
|
|
|
|
if (this.props.onColumnResizeEnd) {
|
|
this.props.onColumnResizeEnd({
|
|
element: this.resizeColumnElement,
|
|
column: this.resizeColumn,
|
|
delta: delta
|
|
});
|
|
}
|
|
|
|
if (this.isStateful()) {
|
|
this.saveState();
|
|
}
|
|
}
|
|
|
|
this.resizeHelper.style.display = 'none';
|
|
this.resizeColumn = null;
|
|
this.resizeColumnElement = null;
|
|
DomHandler.removeClass(this.el, 'p-unselectable-text');
|
|
this.unbindColumnResizeEvents();
|
|
}
|
|
}, {
|
|
key: "resizeTableCells",
|
|
value: function resizeTableCells(newColumnWidth, nextColumnWidth) {
|
|
var _this7 = this;
|
|
|
|
var widths = [];
|
|
var colIndex = DomHandler.index(this.resizeColumnElement);
|
|
var headers = DomHandler.find(this.table, '.p-datatable-thead > tr > th');
|
|
headers.forEach(function (header) {
|
|
return widths.push(DomHandler.getOuterWidth(header));
|
|
});
|
|
this.destroyStyleElement();
|
|
this.createStyleElement();
|
|
var innerHTML = '';
|
|
widths.forEach(function (width, index) {
|
|
var colWidth = index === colIndex ? newColumnWidth : nextColumnWidth && index === colIndex + 1 ? nextColumnWidth : width;
|
|
var style = _this7.props.scrollable ? "flex: 1 1 ".concat(colWidth, "px !important") : "width: ".concat(colWidth, "px !important");
|
|
innerHTML += "\n .p-datatable[".concat(_this7.state.attributeSelector, "] .p-datatable-thead > tr > th:nth-child(").concat(index + 1, "),\n .p-datatable[").concat(_this7.state.attributeSelector, "] .p-datatable-tbody > tr > td:nth-child(").concat(index + 1, "),\n .p-datatable[").concat(_this7.state.attributeSelector, "] .p-datatable-tfoot > tr > td:nth-child(").concat(index + 1, ") {\n ").concat(style, "\n }\n ");
|
|
});
|
|
this.styleElement.innerHTML = innerHTML;
|
|
}
|
|
}, {
|
|
key: "bindColumnResizeEvents",
|
|
value: function bindColumnResizeEvents() {
|
|
var _this8 = this;
|
|
|
|
if (!this.documentColumnResizeListener) {
|
|
this.documentColumnResizeListener = document.addEventListener('mousemove', function (event) {
|
|
if (_this8.columnResizing) {
|
|
_this8.onColumnResize(event);
|
|
}
|
|
});
|
|
}
|
|
|
|
if (!this.documentColumnResizeEndListener) {
|
|
this.documentColumnResizeEndListener = document.addEventListener('mouseup', function () {
|
|
if (_this8.columnResizing) {
|
|
_this8.columnResizing = false;
|
|
|
|
_this8.onColumnResizeEnd();
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindColumnResizeEvents",
|
|
value: function unbindColumnResizeEvents() {
|
|
if (this.documentColumnResizeListener) {
|
|
document.removeEventListener('document', this.documentColumnResizeListener);
|
|
this.documentColumnResizeListener = null;
|
|
}
|
|
|
|
if (this.documentColumnResizeEndListener) {
|
|
document.removeEventListener('document', this.documentColumnResizeEndListener);
|
|
this.documentColumnResizeEndListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "onColumnHeaderMouseDown",
|
|
value: function onColumnHeaderMouseDown(e) {
|
|
DomHandler.clearSelection();
|
|
var event = e.originalEvent,
|
|
column = e.column;
|
|
|
|
if (this.props.reorderableColumns && this.getColumnProp(column, 'reorderable') !== false) {
|
|
if (event.target.nodeName === 'INPUT' || event.target.nodeName === 'TEXTAREA' || DomHandler.hasClass(event.target, 'p-column-resizer')) event.currentTarget.draggable = false;else event.currentTarget.draggable = true;
|
|
}
|
|
}
|
|
}, {
|
|
key: "onColumnHeaderCheckboxChange",
|
|
value: function onColumnHeaderCheckboxChange(e, processedData) {
|
|
var _this9 = this;
|
|
|
|
if (this.props.onSelectAllChange) {
|
|
this.props.onSelectAllChange(e);
|
|
} else {
|
|
var originalEvent = e.originalEvent,
|
|
checked = e.checked;
|
|
var data = this.props.selectionPageOnly ? this.dataToRender(processedData) : processedData;
|
|
var selection = this.props.selectionPageOnly && this.props.selection ? this.props.selection.filter(function (s) {
|
|
return !data.some(function (d) {
|
|
return _this9.isEquals(s, d);
|
|
});
|
|
}) : [];
|
|
|
|
if (checked) {
|
|
selection = this.props.frozenValue ? [].concat(_toConsumableArray(selection), _toConsumableArray(this.props.frozenValue), _toConsumableArray(data)) : [].concat(_toConsumableArray(selection), _toConsumableArray(data));
|
|
selection = this.getSelectableData(selection);
|
|
this.props.onAllRowsSelect && this.props.onAllRowsSelect({
|
|
originalEvent: originalEvent,
|
|
data: selection,
|
|
type: 'all'
|
|
});
|
|
} else {
|
|
this.props.onAllRowsUnselect && this.props.onAllRowsUnselect({
|
|
originalEvent: originalEvent,
|
|
data: selection,
|
|
type: 'all'
|
|
});
|
|
}
|
|
|
|
if (this.props.onSelectionChange) {
|
|
this.props.onSelectionChange({
|
|
originalEvent: originalEvent,
|
|
value: selection,
|
|
type: 'all'
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onColumnHeaderDragStart",
|
|
value: function onColumnHeaderDragStart(e) {
|
|
var event = e.originalEvent,
|
|
column = e.column;
|
|
|
|
if (this.columnResizing) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
this.colReorderIconWidth = DomHandler.getHiddenElementOuterWidth(this.reorderIndicatorUp);
|
|
this.colReorderIconHeight = DomHandler.getHiddenElementOuterHeight(this.reorderIndicatorUp);
|
|
this.draggedColumn = column;
|
|
this.draggedColumnElement = this.findParentHeader(event.currentTarget);
|
|
event.dataTransfer.setData('text', 'b'); // Firefox requires this to make dragging possible
|
|
}
|
|
}, {
|
|
key: "onColumnHeaderDragOver",
|
|
value: function onColumnHeaderDragOver(e) {
|
|
var event = e.originalEvent;
|
|
var dropHeader = this.findParentHeader(event.currentTarget);
|
|
|
|
if (this.props.reorderableColumns && this.draggedColumnElement && dropHeader) {
|
|
event.preventDefault();
|
|
|
|
if (this.draggedColumnElement !== dropHeader) {
|
|
var containerOffset = DomHandler.getOffset(this.el);
|
|
var dropHeaderOffset = DomHandler.getOffset(dropHeader);
|
|
var targetLeft = dropHeaderOffset.left - containerOffset.left;
|
|
var columnCenter = dropHeaderOffset.left + dropHeader.offsetWidth / 2;
|
|
this.reorderIndicatorUp.style.top = dropHeaderOffset.top - containerOffset.top - (this.colReorderIconHeight - 1) + 'px';
|
|
this.reorderIndicatorDown.style.top = dropHeaderOffset.top - containerOffset.top + dropHeader.offsetHeight + 'px';
|
|
|
|
if (event.pageX > columnCenter) {
|
|
this.reorderIndicatorUp.style.left = targetLeft + dropHeader.offsetWidth - Math.ceil(this.colReorderIconWidth / 2) + 'px';
|
|
this.reorderIndicatorDown.style.left = targetLeft + dropHeader.offsetWidth - Math.ceil(this.colReorderIconWidth / 2) + 'px';
|
|
this.dropPosition = 1;
|
|
} else {
|
|
this.reorderIndicatorUp.style.left = targetLeft - Math.ceil(this.colReorderIconWidth / 2) + 'px';
|
|
this.reorderIndicatorDown.style.left = targetLeft - Math.ceil(this.colReorderIconWidth / 2) + 'px';
|
|
this.dropPosition = -1;
|
|
}
|
|
|
|
this.reorderIndicatorUp.style.display = 'block';
|
|
this.reorderIndicatorDown.style.display = 'block';
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onColumnHeaderDragLeave",
|
|
value: function onColumnHeaderDragLeave(e) {
|
|
var event = e.originalEvent;
|
|
|
|
if (this.props.reorderableColumns && this.draggedColumnElement) {
|
|
event.preventDefault();
|
|
this.reorderIndicatorUp.style.display = 'none';
|
|
this.reorderIndicatorDown.style.display = 'none';
|
|
}
|
|
}
|
|
}, {
|
|
key: "onColumnHeaderDrop",
|
|
value: function onColumnHeaderDrop(e) {
|
|
var _this10 = this;
|
|
|
|
var event = e.originalEvent,
|
|
column = e.column;
|
|
event.preventDefault();
|
|
|
|
if (this.draggedColumnElement) {
|
|
var dragIndex = DomHandler.index(this.draggedColumnElement);
|
|
var dropIndex = DomHandler.index(this.findParentHeader(event.currentTarget));
|
|
var allowDrop = dragIndex !== dropIndex;
|
|
|
|
if (allowDrop && (dropIndex - dragIndex === 1 && this.dropPosition === -1 || dragIndex - dropIndex === 1 && this.dropPosition === 1)) {
|
|
allowDrop = false;
|
|
}
|
|
|
|
if (allowDrop) {
|
|
var columns = this.getColumns();
|
|
|
|
var isSameColumn = function isSameColumn(col1, col2) {
|
|
return col1.props.columnKey || col2.props.columnKey ? ObjectUtils.equals(col1.props, col2.props, 'columnKey') : ObjectUtils.equals(col1.props, col2.props, 'field');
|
|
};
|
|
|
|
var dragColIndex = columns.findIndex(function (child) {
|
|
return isSameColumn(child, _this10.draggedColumn);
|
|
});
|
|
var dropColIndex = columns.findIndex(function (child) {
|
|
return isSameColumn(child, column);
|
|
});
|
|
|
|
if (dropColIndex < dragColIndex && this.dropPosition === 1) {
|
|
dropColIndex++;
|
|
}
|
|
|
|
if (dropColIndex > dragColIndex && this.dropPosition === -1) {
|
|
dropColIndex--;
|
|
}
|
|
|
|
ObjectUtils.reorderArray(columns, dragColIndex, dropColIndex);
|
|
var columnOrder = columns.reduce(function (orders, col) {
|
|
orders.push(col.props.columnKey || col.props.field);
|
|
return orders;
|
|
}, []);
|
|
this.setState({
|
|
columnOrder: columnOrder
|
|
});
|
|
|
|
if (this.props.onColReorder) {
|
|
this.props.onColReorder({
|
|
originalEvent: event,
|
|
dragIndex: dragColIndex,
|
|
dropIndex: dropColIndex,
|
|
columns: columns
|
|
});
|
|
}
|
|
}
|
|
|
|
this.reorderIndicatorUp.style.display = 'none';
|
|
this.reorderIndicatorDown.style.display = 'none';
|
|
this.draggedColumnElement.draggable = false;
|
|
this.draggedColumnElement = null;
|
|
this.draggedColumn = null;
|
|
this.dropPosition = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "createStyleElement",
|
|
value: function createStyleElement() {
|
|
this.styleElement = DomHandler.createInlineStyle(PrimeReact.nonce);
|
|
}
|
|
}, {
|
|
key: "createResponsiveStyle",
|
|
value: function createResponsiveStyle() {
|
|
if (!this.responsiveStyleElement) {
|
|
this.responsiveStyleElement = DomHandler.createInlineStyle(PrimeReact.nonce);
|
|
var innerHTML = "\n@media screen and (max-width: ".concat(this.props.breakpoint, ") {\n .p-datatable[").concat(this.state.attributeSelector, "] .p-datatable-thead > tr > th,\n .p-datatable[").concat(this.state.attributeSelector, "] .p-datatable-tfoot > tr > td {\n display: none !important;\n }\n\n .p-datatable[").concat(this.state.attributeSelector, "] .p-datatable-tbody > tr > td {\n display: flex;\n width: 100% !important;\n align-items: center;\n justify-content: space-between;\n }\n\n .p-datatable[").concat(this.state.attributeSelector, "] .p-datatable-tbody > tr > td:not(:last-child) {\n border: 0 none;\n }\n\n .p-datatable[").concat(this.state.attributeSelector, "].p-datatable-gridlines .p-datatable-tbody > tr > td:last-child {\n border-top: 0;\n border-right: 0;\n border-left: 0;\n }\n\n .p-datatable[").concat(this.state.attributeSelector, "] .p-datatable-tbody > tr > td > .p-column-title {\n display: block;\n }\n}\n");
|
|
this.responsiveStyleElement.innerHTML = innerHTML;
|
|
}
|
|
}
|
|
}, {
|
|
key: "destroyResponsiveStyle",
|
|
value: function destroyResponsiveStyle() {
|
|
this.responsiveStyleElement = DomHandler.removeInlineStyle(this.responsiveStyleElement);
|
|
}
|
|
}, {
|
|
key: "destroyStyleElement",
|
|
value: function destroyStyleElement() {
|
|
this.styleElement = DomHandler.removeInlineStyle(this.styleElement);
|
|
}
|
|
}, {
|
|
key: "onPageChange",
|
|
value: function onPageChange(e) {
|
|
this.clearEditingMetaData();
|
|
if (this.props.onPage) this.props.onPage(this.createEvent(e));else this.setState({
|
|
first: e.first,
|
|
rows: e.rows
|
|
});
|
|
|
|
if (this.props.onValueChange) {
|
|
this.props.onValueChange(this.processedData());
|
|
}
|
|
}
|
|
}, {
|
|
key: "onSortChange",
|
|
value: function onSortChange(e) {
|
|
this.clearEditingMetaData();
|
|
var event = e.originalEvent,
|
|
column = e.column,
|
|
sortableDisabledFields = e.sortableDisabledFields;
|
|
var sortField = column.props.sortField || column.props.field;
|
|
var sortOrder = this.props.defaultSortOrder;
|
|
var multiSortMeta;
|
|
var eventMeta;
|
|
this.columnSortable = column.props.sortable;
|
|
this.columnSortFunction = column.props.sortFunction;
|
|
this.columnField = column.props.sortField;
|
|
|
|
if (this.props.sortMode === 'multiple') {
|
|
var metaKey = event.metaKey || event.ctrlKey;
|
|
multiSortMeta = _toConsumableArray(this.getMultiSortMeta());
|
|
var sortMeta = multiSortMeta.find(function (sortMeta) {
|
|
return sortMeta.field === sortField;
|
|
});
|
|
sortOrder = sortMeta ? this.getCalculatedSortOrder(sortMeta.order) : sortOrder;
|
|
var newMetaData = {
|
|
field: sortField,
|
|
order: sortOrder
|
|
};
|
|
|
|
if (sortOrder) {
|
|
multiSortMeta = metaKey ? multiSortMeta : multiSortMeta.filter(function (meta) {
|
|
return sortableDisabledFields.some(function (field) {
|
|
return field === meta.field;
|
|
});
|
|
});
|
|
this.addSortMeta(newMetaData, multiSortMeta);
|
|
} else if (this.props.removableSort) {
|
|
this.removeSortMeta(newMetaData, multiSortMeta);
|
|
}
|
|
|
|
eventMeta = {
|
|
multiSortMeta: multiSortMeta
|
|
};
|
|
} else {
|
|
sortOrder = this.getSortField() === sortField ? this.getCalculatedSortOrder(this.getSortOrder()) : sortOrder;
|
|
|
|
if (this.props.removableSort) {
|
|
sortField = sortOrder ? sortField : null;
|
|
}
|
|
|
|
eventMeta = {
|
|
sortField: sortField,
|
|
sortOrder: sortOrder
|
|
};
|
|
}
|
|
|
|
if (this.props.onSort) {
|
|
this.props.onSort(this.createEvent(eventMeta));
|
|
} else {
|
|
eventMeta.first = 0;
|
|
this.setState(eventMeta);
|
|
}
|
|
|
|
if (this.props.onValueChange) {
|
|
this.props.onValueChange(this.processedData({
|
|
sortField: sortField,
|
|
sortOrder: sortOrder,
|
|
multiSortMeta: multiSortMeta
|
|
}));
|
|
}
|
|
}
|
|
}, {
|
|
key: "getCalculatedSortOrder",
|
|
value: function getCalculatedSortOrder(currentOrder) {
|
|
return this.props.removableSort ? this.props.defaultSortOrder === currentOrder ? currentOrder * -1 : 0 : currentOrder * -1;
|
|
}
|
|
}, {
|
|
key: "compareValuesOnSort",
|
|
value: function compareValuesOnSort(value1, value2) {
|
|
var result = null;
|
|
if (value1 == null && value2 != null) result = -1;else if (value1 != null && value2 == null) result = 1;else if (value1 == null && value2 == null) result = 0;else if (typeof value1 === 'string' && typeof value2 === 'string') result = value1.localeCompare(value2, undefined, {
|
|
numeric: true
|
|
});else result = value1 < value2 ? -1 : value1 > value2 ? 1 : 0;
|
|
return result;
|
|
}
|
|
}, {
|
|
key: "addSortMeta",
|
|
value: function addSortMeta(meta, multiSortMeta) {
|
|
var index = multiSortMeta.findIndex(function (sortMeta) {
|
|
return sortMeta.field === meta.field;
|
|
});
|
|
if (index >= 0) multiSortMeta[index] = meta;else multiSortMeta.push(meta);
|
|
}
|
|
}, {
|
|
key: "removeSortMeta",
|
|
value: function removeSortMeta(meta, multiSortMeta) {
|
|
var index = multiSortMeta.findIndex(function (sortMeta) {
|
|
return sortMeta.field === meta.field;
|
|
});
|
|
|
|
if (index >= 0) {
|
|
multiSortMeta.splice(index, 1);
|
|
}
|
|
|
|
multiSortMeta = multiSortMeta.length > 0 ? multiSortMeta : null;
|
|
}
|
|
}, {
|
|
key: "sortSingle",
|
|
value: function sortSingle(data, field, order) {
|
|
var _this11 = this;
|
|
|
|
if (this.props.groupRowsBy && this.props.groupRowsBy === this.props.sortField) {
|
|
var multiSortMeta = [{
|
|
field: this.props.sortField,
|
|
order: this.props.sortOrder || this.props.defaultSortOrder
|
|
}];
|
|
this.props.sortField !== field && multiSortMeta.push({
|
|
field: field,
|
|
order: order
|
|
});
|
|
return this.sortMultiple(data, multiSortMeta);
|
|
}
|
|
|
|
var value = _toConsumableArray(data);
|
|
|
|
if (this.columnSortable && this.columnSortFunction) {
|
|
value = this.columnSortFunction({
|
|
field: field,
|
|
order: order
|
|
});
|
|
} else {
|
|
value.sort(function (data1, data2) {
|
|
var value1 = ObjectUtils.resolveFieldData(data1, field);
|
|
var value2 = ObjectUtils.resolveFieldData(data2, field);
|
|
|
|
var result = _this11.compareValuesOnSort(value1, value2);
|
|
|
|
return order * result;
|
|
});
|
|
}
|
|
|
|
return value;
|
|
}
|
|
}, {
|
|
key: "sortMultiple",
|
|
value: function sortMultiple(data) {
|
|
var _this12 = this;
|
|
|
|
var multiSortMeta = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
|
|
|
|
if (this.props.groupRowsBy && (this.groupRowsSortMeta || multiSortMeta.length && this.props.groupRowsBy === multiSortMeta[0].field)) {
|
|
var firstSortMeta = multiSortMeta[0];
|
|
!this.groupRowsSortMeta && (this.groupRowsSortMeta = firstSortMeta);
|
|
|
|
if (firstSortMeta.field !== this.groupRowsSortMeta.field) {
|
|
multiSortMeta = [this.groupRowsSortMeta].concat(_toConsumableArray(multiSortMeta));
|
|
}
|
|
}
|
|
|
|
var value = _toConsumableArray(data);
|
|
|
|
if (this.columnSortable && this.columnSortFunction) {
|
|
var meta = multiSortMeta.find(function (meta) {
|
|
return meta.field === _this12.columnField;
|
|
});
|
|
var field = this.columnField;
|
|
var order = meta ? meta.order : this.defaultSortOrder;
|
|
value = this.columnSortFunction({
|
|
field: field,
|
|
order: order
|
|
});
|
|
} else {
|
|
value.sort(function (data1, data2) {
|
|
return _this12.multisortField(data1, data2, multiSortMeta, 0);
|
|
});
|
|
}
|
|
|
|
return value;
|
|
}
|
|
}, {
|
|
key: "multisortField",
|
|
value: function multisortField(data1, data2, multiSortMeta, index) {
|
|
var value1 = ObjectUtils.resolveFieldData(data1, multiSortMeta[index].field);
|
|
var value2 = ObjectUtils.resolveFieldData(data2, multiSortMeta[index].field);
|
|
|
|
if (value1 === value2) {
|
|
return multiSortMeta.length - 1 > index ? this.multisortField(data1, data2, multiSortMeta, index + 1) : 0;
|
|
}
|
|
|
|
var result = this.compareValuesOnSort(value1, value2);
|
|
return multiSortMeta[index].order * result;
|
|
}
|
|
}, {
|
|
key: "onFilterChange",
|
|
value: function onFilterChange(filters) {
|
|
this.clearEditingMetaData();
|
|
this.setState({
|
|
d_filters: filters
|
|
});
|
|
}
|
|
}, {
|
|
key: "onFilterApply",
|
|
value: function onFilterApply() {
|
|
var _this13 = this;
|
|
|
|
clearTimeout(this.filterTimeout);
|
|
this.filterTimeout = setTimeout(function () {
|
|
var filters = _this13.cloneFilters(_this13.state.d_filters);
|
|
|
|
if (_this13.props.onFilter) {
|
|
_this13.props.onFilter(_this13.createEvent({
|
|
filters: filters
|
|
}));
|
|
} else {
|
|
_this13.setState({
|
|
first: 0,
|
|
filters: filters
|
|
});
|
|
}
|
|
|
|
if (_this13.props.onValueChange) {
|
|
_this13.props.onValueChange(_this13.processedData({
|
|
filters: filters
|
|
}));
|
|
}
|
|
}, this.props.filterDelay);
|
|
}
|
|
}, {
|
|
key: "filterLocal",
|
|
value: function filterLocal(data, filters) {
|
|
if (!data) return;
|
|
filters = filters || {};
|
|
var columns = this.getColumns();
|
|
var filteredValue = [];
|
|
var isGlobalFilter = filters['global'] || this.props.globalFilter;
|
|
var globalFilterFieldsArray;
|
|
|
|
if (isGlobalFilter) {
|
|
globalFilterFieldsArray = this.props.globalFilterFields || columns.filter(function (col) {
|
|
return !col.props.excludeGlobalFilter;
|
|
}).map(function (col) {
|
|
return col.props.filterField || col.props.field;
|
|
});
|
|
}
|
|
|
|
for (var i = 0; i < data.length; i++) {
|
|
var localMatch = true;
|
|
var globalMatch = false;
|
|
var localFiltered = false;
|
|
|
|
for (var prop in filters) {
|
|
if (Object.prototype.hasOwnProperty.call(filters, prop) && prop !== 'global') {
|
|
localFiltered = true;
|
|
var filterField = prop;
|
|
var filterMeta = filters[filterField];
|
|
|
|
if (filterMeta.operator) {
|
|
for (var j = 0; j < filterMeta.constraints.length; j++) {
|
|
var filterConstraint = filterMeta.constraints[j];
|
|
localMatch = this.executeLocalFilter(filterField, data[i], filterConstraint, j);
|
|
|
|
if (filterMeta.operator === FilterOperator.OR && localMatch || filterMeta.operator === FilterOperator.AND && !localMatch) {
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
localMatch = this.executeLocalFilter(filterField, data[i], filterMeta, 0);
|
|
}
|
|
|
|
if (!localMatch) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isGlobalFilter && !globalMatch && globalFilterFieldsArray) {
|
|
for (var _j = 0; _j < globalFilterFieldsArray.length; _j++) {
|
|
var globalFilterField = globalFilterFieldsArray[_j];
|
|
var matchMode = filters['global'] ? filters['global'].matchMode : FilterMatchMode.CONTAINS;
|
|
var value = filters['global'] ? filters['global'].value : this.props.globalFilter;
|
|
globalMatch = FilterService.filters[matchMode](ObjectUtils.resolveFieldData(data[i], globalFilterField), value, this.props.filterLocale);
|
|
|
|
if (globalMatch) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
var matches = void 0;
|
|
|
|
if (isGlobalFilter) {
|
|
matches = localFiltered ? localFiltered && localMatch && globalMatch : globalMatch;
|
|
} else {
|
|
matches = localFiltered && localMatch;
|
|
}
|
|
|
|
if (matches) {
|
|
filteredValue.push(data[i]);
|
|
}
|
|
}
|
|
|
|
if (filteredValue.length === this.props.value.length) {
|
|
filteredValue = data;
|
|
}
|
|
|
|
return filteredValue;
|
|
}
|
|
}, {
|
|
key: "executeLocalFilter",
|
|
value: function executeLocalFilter(field, rowData, filterMeta, index) {
|
|
var filterValue = filterMeta.value;
|
|
var filterMatchMode = filterMeta.matchMode === 'custom' ? "custom_".concat(field) : filterMeta.matchMode || FilterMatchMode.STARTS_WITH;
|
|
var dataFieldValue = ObjectUtils.resolveFieldData(rowData, field);
|
|
var filterConstraint = FilterService.filters[filterMatchMode];
|
|
return filterConstraint(dataFieldValue, filterValue, this.props.filterLocale, index);
|
|
}
|
|
}, {
|
|
key: "cloneFilters",
|
|
value: function cloneFilters(filters) {
|
|
var _this14 = this;
|
|
|
|
filters = filters || this.props.filters;
|
|
var cloned = {};
|
|
|
|
if (filters) {
|
|
Object.entries(filters).forEach(function (_ref) {
|
|
var _ref2 = _slicedToArray(_ref, 2),
|
|
prop = _ref2[0],
|
|
value = _ref2[1];
|
|
|
|
cloned[prop] = value.operator ? {
|
|
operator: value.operator,
|
|
constraints: value.constraints.map(function (constraint) {
|
|
return _objectSpread$s({}, constraint);
|
|
})
|
|
} : _objectSpread$s({}, value);
|
|
});
|
|
} else {
|
|
var columns = this.getColumns();
|
|
cloned = columns.reduce(function (_filters, col) {
|
|
var field = col.props.filterField || col.props.field;
|
|
var filterFunction = col.props.filterFunction;
|
|
var dataType = col.props.dataType;
|
|
var matchMode = col.props.filterMatchMode || (PrimeReact.filterMatchModeOptions[dataType] ? PrimeReact.filterMatchModeOptions[dataType][0] : FilterMatchMode.STARTS_WITH);
|
|
var constraint = {
|
|
value: null,
|
|
matchMode: matchMode
|
|
};
|
|
|
|
if (filterFunction) {
|
|
FilterService.register("custom_".concat(field), function () {
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
return filterFunction.apply(void 0, args.concat([{
|
|
column: col
|
|
}]));
|
|
});
|
|
}
|
|
|
|
_filters[field] = _this14.props.filterDisplay === 'menu' ? {
|
|
operator: FilterOperator.AND,
|
|
constraints: [constraint]
|
|
} : constraint;
|
|
return _filters;
|
|
}, {});
|
|
}
|
|
|
|
return cloned;
|
|
}
|
|
}, {
|
|
key: "filter",
|
|
value: function filter(value, field, matchMode) {
|
|
var index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
|
|
|
|
var filters = _objectSpread$s({}, this.state.d_filters);
|
|
|
|
var meta = filters[field];
|
|
var constraint = meta && meta.operator ? meta.constraints[index] : meta;
|
|
constraint = meta ? {
|
|
value: value,
|
|
matchMode: matchMode || constraint.matchMode
|
|
} : {
|
|
value: value,
|
|
matchMode: matchMode
|
|
};
|
|
this.props.filterDisplay === 'menu' && meta && meta.operator ? filters[field].constraints[index] = constraint : filters[field] = constraint;
|
|
this.setState({
|
|
d_filters: filters
|
|
}, this.onFilterApply);
|
|
}
|
|
}, {
|
|
key: "reset",
|
|
value: function reset() {
|
|
var state = {
|
|
d_rows: this.props.rows,
|
|
d_filters: this.cloneFilters(this.props.filters),
|
|
groupRowsSortMeta: null,
|
|
editingMeta: {}
|
|
};
|
|
|
|
if (!this.props.onPage) {
|
|
state.first = this.props.first;
|
|
state.rows = this.props.rows;
|
|
}
|
|
|
|
if (!this.props.onSort) {
|
|
state.sortField = this.props.sortField;
|
|
state.sortOrder = this.props.sortOrder;
|
|
state.multiSortMeta = this.props.multiSortMeta;
|
|
}
|
|
|
|
if (!this.props.onFilter) {
|
|
state.filters = this.props.filters;
|
|
}
|
|
|
|
this.resetColumnOrder();
|
|
this.setState(state);
|
|
}
|
|
}, {
|
|
key: "resetColumnOrder",
|
|
value: function resetColumnOrder() {
|
|
var columns = this.getColumns(true);
|
|
var columnOrder = [];
|
|
|
|
if (columns) {
|
|
columnOrder = columns.reduce(function (orders, col) {
|
|
orders.push(col.props.columnKey || col.props.field);
|
|
return orders;
|
|
}, []);
|
|
}
|
|
|
|
this.setState({
|
|
columnOrder: columnOrder
|
|
});
|
|
}
|
|
}, {
|
|
key: "exportCSV",
|
|
value: function exportCSV(options) {
|
|
var _this15 = this;
|
|
|
|
var data;
|
|
var csv = "\uFEFF";
|
|
var columns = this.getColumns();
|
|
|
|
if (options && options.selectionOnly) {
|
|
data = this.props.selection || [];
|
|
} else {
|
|
data = [].concat(_toConsumableArray(this.props.frozenValue || []), _toConsumableArray(this.processedData() || []));
|
|
} //headers
|
|
|
|
|
|
columns.forEach(function (column, i) {
|
|
var _column$props = column.props,
|
|
field = _column$props.field,
|
|
header = _column$props.header,
|
|
exportable = _column$props.exportable;
|
|
|
|
if (exportable && field) {
|
|
csv += '"' + (header || field) + '"';
|
|
|
|
if (i < columns.length - 1) {
|
|
csv += _this15.props.csvSeparator;
|
|
}
|
|
}
|
|
}); //body
|
|
|
|
data.forEach(function (record) {
|
|
csv += '\n';
|
|
columns.forEach(function (column, i) {
|
|
var _column$props2 = column.props,
|
|
columnField = _column$props2.field,
|
|
exportField = _column$props2.exportField,
|
|
exportable = _column$props2.exportable;
|
|
var field = exportField || columnField;
|
|
|
|
if (exportable && field) {
|
|
var cellData = ObjectUtils.resolveFieldData(record, field);
|
|
|
|
if (cellData != null) {
|
|
cellData = _this15.props.exportFunction ? _this15.props.exportFunction({
|
|
data: cellData,
|
|
field: field,
|
|
rowData: record,
|
|
column: column
|
|
}) : String(cellData).replace(/"/g, '""');
|
|
} else cellData = '';
|
|
|
|
csv += '"' + cellData + '"';
|
|
|
|
if (i < columns.length - 1) {
|
|
csv += _this15.props.csvSeparator;
|
|
}
|
|
}
|
|
});
|
|
});
|
|
DomHandler.exportCSV(csv, this.props.exportFilename);
|
|
}
|
|
}, {
|
|
key: "closeEditingCell",
|
|
value: function closeEditingCell() {
|
|
if (this.props.editMode !== "row") {
|
|
document.body.click();
|
|
}
|
|
}
|
|
}, {
|
|
key: "createEvent",
|
|
value: function createEvent(event) {
|
|
return _objectSpread$s({
|
|
first: this.getFirst(),
|
|
rows: this.getRows(),
|
|
sortField: this.getSortField(),
|
|
sortOrder: this.getSortOrder(),
|
|
multiSortMeta: this.getMultiSortMeta(),
|
|
filters: this.getFilters()
|
|
}, event);
|
|
}
|
|
}, {
|
|
key: "processedData",
|
|
value: function processedData(localState) {
|
|
var data = this.props.value || [];
|
|
|
|
if (!this.props.lazy) {
|
|
if (data && data.length) {
|
|
var filters = localState && localState.filters || this.getFilters();
|
|
var sortField = localState && localState.sortField || this.getSortField();
|
|
var sortOrder = localState && localState.sortOrder || this.getSortOrder();
|
|
var multiSortMeta = localState && localState.multiSortMeta || this.getMultiSortMeta();
|
|
|
|
if (ObjectUtils.isNotEmpty(filters) || this.props.globalFilter) {
|
|
data = this.filterLocal(data, filters);
|
|
}
|
|
|
|
if (sortField || ObjectUtils.isNotEmpty(multiSortMeta)) {
|
|
if (this.props.sortMode === 'single') data = this.sortSingle(data, sortField, sortOrder);else if (this.props.sortMode === 'multiple') data = this.sortMultiple(data, multiSortMeta);
|
|
}
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
}, {
|
|
key: "dataToRender",
|
|
value: function dataToRender(data) {
|
|
if (data && this.props.paginator) {
|
|
var first = this.props.lazy ? 0 : this.getFirst();
|
|
return data.slice(first, first + this.getRows());
|
|
}
|
|
|
|
return data;
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
var _this16 = this;
|
|
|
|
this.setState({
|
|
attributeSelector: UniqueComponentId()
|
|
}, function () {
|
|
_this16.el.setAttribute(_this16.state.attributeSelector, '');
|
|
});
|
|
|
|
if (this.props.responsiveLayout === 'stack' && !this.props.scrollable) {
|
|
this.createResponsiveStyle();
|
|
}
|
|
|
|
if (this.isStateful()) {
|
|
this.setState(this.restoreState(this.state));
|
|
|
|
if (this.props.resizableColumns) {
|
|
this.restoreColumnWidths();
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps, prevState) {
|
|
if (this.isStateful()) {
|
|
this.saveState();
|
|
}
|
|
|
|
if (prevProps.responsiveLayout !== this.props.responsiveLayout) {
|
|
this.destroyResponsiveStyle();
|
|
|
|
if (this.props.responsiveLayout === 'stack' && !this.props.scrollable) {
|
|
this.createResponsiveStyle();
|
|
}
|
|
}
|
|
|
|
if (prevProps.filters !== this.props.filters) {
|
|
this.setState({
|
|
filters: this.cloneFilters(this.props.filters),
|
|
d_filters: this.cloneFilters(this.props.filters)
|
|
});
|
|
}
|
|
|
|
if (prevProps.globalFilter !== this.props.globalFilter) {
|
|
this.filter(this.props.globalFilter, 'global', 'contains');
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.unbindColumnResizeEvents();
|
|
this.destroyStyleElement();
|
|
this.destroyResponsiveStyle();
|
|
}
|
|
}, {
|
|
key: "renderLoader",
|
|
value: function renderLoader() {
|
|
if (this.props.loading) {
|
|
var iconClassName = classNames('p-datatable-loading-icon pi-spin', this.props.loadingIcon);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-datatable-loading-overlay p-component-overlay"
|
|
}, /*#__PURE__*/React.createElement("i", {
|
|
className: iconClassName
|
|
}));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderHeader",
|
|
value: function renderHeader() {
|
|
if (this.props.header) {
|
|
var content = ObjectUtils.getJSXElement(this.props.header, {
|
|
props: this.props
|
|
});
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-datatable-header"
|
|
}, content);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderTableHeader",
|
|
value: function renderTableHeader(options, empty) {
|
|
var sortField = this.getSortField();
|
|
var sortOrder = this.getSortOrder();
|
|
|
|
var multiSortMeta = _toConsumableArray(this.getMultiSortMeta());
|
|
|
|
var groupRowSortField = this.getGroupRowSortField();
|
|
var filters = this.state.d_filters;
|
|
var filtersStore = this.getFilters();
|
|
var processedData = options.items,
|
|
columns = options.columns;
|
|
return /*#__PURE__*/React.createElement(TableHeader, {
|
|
value: processedData,
|
|
tableProps: this.props,
|
|
columns: columns,
|
|
tabIndex: this.props.tabIndex,
|
|
empty: empty,
|
|
headerColumnGroup: this.props.headerColumnGroup,
|
|
resizableColumns: this.props.resizableColumns,
|
|
onColumnResizeStart: this.onColumnResizeStart,
|
|
onColumnResizerClick: this.props.onColumnResizerClick,
|
|
onColumnResizerDoubleClick: this.props.onColumnResizerDoubleClick,
|
|
sortMode: this.props.sortMode,
|
|
sortField: sortField,
|
|
sortOrder: sortOrder,
|
|
multiSortMeta: multiSortMeta,
|
|
groupRowsBy: this.props.groupRowsBy,
|
|
groupRowSortField: groupRowSortField,
|
|
onSortChange: this.onSortChange,
|
|
filterDisplay: this.props.filterDisplay,
|
|
filters: filters,
|
|
filtersStore: filtersStore,
|
|
onFilterChange: this.onFilterChange,
|
|
onFilterApply: this.onFilterApply,
|
|
showSelectAll: this.props.showSelectAll,
|
|
allRowsSelected: this.allRowsSelected,
|
|
onColumnCheckboxChange: this.onColumnHeaderCheckboxChange,
|
|
onColumnMouseDown: this.onColumnHeaderMouseDown,
|
|
onColumnDragStart: this.onColumnHeaderDragStart,
|
|
onColumnDragOver: this.onColumnHeaderDragOver,
|
|
onColumnDragLeave: this.onColumnHeaderDragLeave,
|
|
onColumnDrop: this.onColumnHeaderDrop,
|
|
rowGroupMode: this.props.rowGroupMode,
|
|
reorderableColumns: this.props.reorderableColumns
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderTableBody",
|
|
value: function renderTableBody(options, selectionModeInColumn, empty, isVirtualScrollerDisabled) {
|
|
var tableSelector = this.state.attributeSelector;
|
|
var first = this.getFirst();
|
|
var editingMeta = this.state.editingMeta;
|
|
var rows = options.rows,
|
|
columns = options.columns,
|
|
contentRef = options.contentRef,
|
|
className = options.className;
|
|
var frozenBody = this.props.frozenValue && /*#__PURE__*/React.createElement(TableBody, {
|
|
value: this.props.frozenValue,
|
|
className: "p-datatable-frozen-tbody",
|
|
frozenRow: true,
|
|
tableProps: this.props,
|
|
tableSelector: tableSelector,
|
|
columns: columns,
|
|
selectionModeInColumn: selectionModeInColumn,
|
|
first: first,
|
|
editingMeta: editingMeta,
|
|
onEditingMetaChange: this.onEditingMetaChange,
|
|
tabIndex: this.props.tabIndex,
|
|
onRowClick: this.props.onRowClick,
|
|
onRowDoubleClick: this.props.onRowDoubleClick,
|
|
onCellClick: this.props.onCellClick,
|
|
selection: this.props.selection,
|
|
onSelectionChange: this.props.onSelectionChange,
|
|
lazy: this.props.lazy,
|
|
paginator: this.props.paginator,
|
|
onCellSelect: this.props.onCellSelect,
|
|
onCellUnselect: this.props.onCellUnselect,
|
|
onRowSelect: this.props.onRowSelect,
|
|
onRowUnselect: this.props.onRowUnselect,
|
|
dragSelection: this.props.dragSelection,
|
|
onContextMenu: this.props.onContextMenu,
|
|
onContextMenuSelectionChange: this.props.onContextMenuSelectionChange,
|
|
metaKeySelection: this.props.metaKeySelection,
|
|
selectionMode: this.props.selectionMode,
|
|
cellSelection: this.props.cellSelection,
|
|
contextMenuSelection: this.props.contextMenuSelection,
|
|
dataKey: this.props.dataKey,
|
|
expandedRows: this.props.expandedRows,
|
|
onRowCollapse: this.props.onRowCollapse,
|
|
onRowExpand: this.props.onRowExpand,
|
|
onRowToggle: this.props.onRowToggle,
|
|
editMode: this.props.editMode,
|
|
editingRows: this.props.editingRows,
|
|
onRowReorder: this.props.onRowReorder,
|
|
scrollable: this.props.scrollable,
|
|
rowGroupMode: this.props.rowGroupMode,
|
|
groupRowsBy: this.props.groupRowsBy,
|
|
expandableRowGroups: this.props.expandableRowGroups,
|
|
loading: this.props.loading,
|
|
emptyMessage: this.props.emptyMessage,
|
|
rowGroupHeaderTemplate: this.props.rowGroupHeaderTemplate,
|
|
rowExpansionTemplate: this.props.rowExpansionTemplate,
|
|
rowGroupFooterTemplate: this.props.rowGroupFooterTemplate,
|
|
onRowEditChange: this.props.onRowEditChange,
|
|
compareSelectionBy: this.props.compareSelectionBy,
|
|
selectOnEdit: this.props.selectOnEdit,
|
|
onRowEditInit: this.props.onRowEditInit,
|
|
rowEditValidator: this.props.rowEditValidator,
|
|
onRowEditSave: this.props.onRowEditSave,
|
|
onRowEditComplete: this.props.onRowEditComplete,
|
|
onRowEditCancel: this.props.onRowEditCancel,
|
|
cellClassName: this.props.cellClassName,
|
|
responsiveLayout: this.props.responsiveLayout,
|
|
selectionAutoFocus: this.props.selectionAutoFocus,
|
|
isDataSelectable: this.props.isDataSelectable,
|
|
showSelectionElement: this.props.showSelectionElement,
|
|
showRowReorderElement: this.props.showRowReorderElement,
|
|
expandedRowIcon: this.props.expandedRowIcon,
|
|
collapsedRowIcon: this.props.collapsedRowIcon,
|
|
rowClassName: this.props.rowClassName,
|
|
isVirtualScrollerDisabled: true
|
|
});
|
|
var body = /*#__PURE__*/React.createElement(TableBody, {
|
|
value: this.dataToRender(rows),
|
|
className: className,
|
|
empty: empty,
|
|
frozenRow: false,
|
|
tableProps: this.props,
|
|
tableSelector: tableSelector,
|
|
columns: columns,
|
|
selectionModeInColumn: selectionModeInColumn,
|
|
first: first,
|
|
editingMeta: editingMeta,
|
|
onEditingMetaChange: this.onEditingMetaChange,
|
|
tabIndex: this.props.tabIndex,
|
|
onRowClick: this.props.onRowClick,
|
|
onRowDoubleClick: this.props.onRowDoubleClick,
|
|
onCellClick: this.props.onCellClick,
|
|
selection: this.props.selection,
|
|
onSelectionChange: this.props.onSelectionChange,
|
|
lazy: this.props.lazy,
|
|
paginator: this.props.paginator,
|
|
onCellSelect: this.props.onCellSelect,
|
|
onCellUnselect: this.props.onCellUnselect,
|
|
onRowSelect: this.props.onRowSelect,
|
|
onRowUnselect: this.props.onRowUnselect,
|
|
dragSelection: this.props.dragSelection,
|
|
onContextMenu: this.props.onContextMenu,
|
|
onContextMenuSelectionChange: this.props.onContextMenuSelectionChange,
|
|
metaKeySelection: this.props.metaKeySelection,
|
|
selectionMode: this.props.selectionMode,
|
|
cellSelection: this.props.cellSelection,
|
|
contextMenuSelection: this.props.contextMenuSelection,
|
|
dataKey: this.props.dataKey,
|
|
expandedRows: this.props.expandedRows,
|
|
onRowCollapse: this.props.onRowCollapse,
|
|
onRowExpand: this.props.onRowExpand,
|
|
onRowToggle: this.props.onRowToggle,
|
|
editMode: this.props.editMode,
|
|
editingRows: this.props.editingRows,
|
|
onRowReorder: this.props.onRowReorder,
|
|
scrollable: this.props.scrollable,
|
|
rowGroupMode: this.props.rowGroupMode,
|
|
groupRowsBy: this.props.groupRowsBy,
|
|
expandableRowGroups: this.props.expandableRowGroups,
|
|
loading: this.props.loading,
|
|
emptyMessage: this.props.emptyMessage,
|
|
rowGroupHeaderTemplate: this.props.rowGroupHeaderTemplate,
|
|
rowExpansionTemplate: this.props.rowExpansionTemplate,
|
|
rowGroupFooterTemplate: this.props.rowGroupFooterTemplate,
|
|
onRowEditChange: this.props.onRowEditChange,
|
|
compareSelectionBy: this.props.compareSelectionBy,
|
|
selectOnEdit: this.props.selectOnEdit,
|
|
onRowEditInit: this.props.onRowEditInit,
|
|
rowEditValidator: this.props.rowEditValidator,
|
|
onRowEditSave: this.props.onRowEditSave,
|
|
onRowEditComplete: this.props.onRowEditComplete,
|
|
onRowEditCancel: this.props.onRowEditCancel,
|
|
cellClassName: this.props.cellClassName,
|
|
responsiveLayout: this.props.responsiveLayout,
|
|
selectionAutoFocus: this.props.selectionAutoFocus,
|
|
isDataSelectable: this.props.isDataSelectable,
|
|
showSelectionElement: this.props.showSelectionElement,
|
|
showRowReorderElement: this.props.showRowReorderElement,
|
|
expandedRowIcon: this.props.expandedRowIcon,
|
|
collapsedRowIcon: this.props.collapsedRowIcon,
|
|
rowClassName: this.props.rowClassName,
|
|
virtualScrollerContentRef: contentRef,
|
|
virtualScrollerOptions: options,
|
|
isVirtualScrollerDisabled: isVirtualScrollerDisabled
|
|
});
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, frozenBody, body);
|
|
}
|
|
}, {
|
|
key: "renderTableFooter",
|
|
value: function renderTableFooter(options) {
|
|
var columns = options.columns;
|
|
return /*#__PURE__*/React.createElement(TableFooter, {
|
|
tableProps: this.props,
|
|
columns: columns,
|
|
footerColumnGroup: this.props.footerColumnGroup
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent(processedData, columns, selectionModeInColumn, empty) {
|
|
var _this17 = this;
|
|
|
|
if (!columns) return;
|
|
var isVirtualScrollerDisabled = this.isVirtualScrollerDisabled();
|
|
var virtualScrollerOptions = this.props.virtualScrollerOptions || {};
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-datatable-wrapper",
|
|
style: {
|
|
maxHeight: isVirtualScrollerDisabled ? this.props.scrollHeight : null
|
|
}
|
|
}, /*#__PURE__*/React.createElement(VirtualScroller, _extends({}, virtualScrollerOptions, {
|
|
items: processedData,
|
|
columns: columns,
|
|
scrollHeight: this.props.scrollHeight,
|
|
disabled: isVirtualScrollerDisabled,
|
|
loaderDisabled: true,
|
|
showSpacer: false,
|
|
contentTemplate: function contentTemplate(options) {
|
|
var ref = function ref(el) {
|
|
_this17.table = el;
|
|
options.spacerRef && options.spacerRef(el);
|
|
};
|
|
|
|
var tableClassName = classNames('p-datatable-table', _this17.props.tableClassName);
|
|
|
|
var tableHeader = _this17.renderTableHeader(options, empty);
|
|
|
|
var tableBody = _this17.renderTableBody(options, selectionModeInColumn, empty, isVirtualScrollerDisabled);
|
|
|
|
var tableFooter = _this17.renderTableFooter(options);
|
|
|
|
return /*#__PURE__*/React.createElement("table", {
|
|
ref: ref,
|
|
style: _this17.props.tableStyle,
|
|
className: tableClassName,
|
|
role: "table"
|
|
}, tableHeader, tableBody, tableFooter);
|
|
}
|
|
})));
|
|
}
|
|
}, {
|
|
key: "renderFooter",
|
|
value: function renderFooter() {
|
|
if (this.props.footer) {
|
|
var content = ObjectUtils.getJSXElement(this.props.footer, {
|
|
props: this.props
|
|
});
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-datatable-footer"
|
|
}, content);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderPaginator",
|
|
value: function renderPaginator(position, totalRecords) {
|
|
var className = classNames('p-paginator-' + position, this.props.paginatorClassName);
|
|
return /*#__PURE__*/React.createElement(Paginator, {
|
|
first: this.getFirst(),
|
|
rows: this.getRows(),
|
|
pageLinkSize: this.props.pageLinkSize,
|
|
className: className,
|
|
onPageChange: this.onPageChange,
|
|
template: this.props.paginatorTemplate,
|
|
totalRecords: totalRecords,
|
|
rowsPerPageOptions: this.props.rowsPerPageOptions,
|
|
currentPageReportTemplate: this.props.currentPageReportTemplate,
|
|
leftContent: this.props.paginatorLeft,
|
|
rightContent: this.props.paginatorRight,
|
|
alwaysShow: this.props.alwaysShowPaginator,
|
|
dropdownAppendTo: this.props.paginatorDropdownAppendTo
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderPaginatorTop",
|
|
value: function renderPaginatorTop(totalRecords) {
|
|
if (this.props.paginator && this.props.paginatorPosition !== 'bottom') {
|
|
return this.renderPaginator('top', totalRecords);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderPaginatorBottom",
|
|
value: function renderPaginatorBottom(totalRecords) {
|
|
if (this.props.paginator && this.props.paginatorPosition !== 'top') {
|
|
return this.renderPaginator('bottom', totalRecords);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderResizeHelper",
|
|
value: function renderResizeHelper() {
|
|
var _this18 = this;
|
|
|
|
if (this.props.resizableColumns) {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this18.resizeHelper = el;
|
|
},
|
|
className: "p-column-resizer-helper",
|
|
style: {
|
|
display: 'none'
|
|
}
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderReorderIndicators",
|
|
value: function renderReorderIndicators() {
|
|
var _this19 = this;
|
|
|
|
if (this.props.reorderableColumns) {
|
|
var style = {
|
|
position: 'absolute',
|
|
display: 'none'
|
|
};
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("span", {
|
|
ref: function ref(el) {
|
|
return _this19.reorderIndicatorUp = el;
|
|
},
|
|
className: "pi pi-arrow-down p-datatable-reorder-indicator-up",
|
|
style: style
|
|
}), /*#__PURE__*/React.createElement("span", {
|
|
ref: function ref(el) {
|
|
return _this19.reorderIndicatorDown = el;
|
|
},
|
|
className: "pi pi-arrow-up p-datatable-reorder-indicator-down",
|
|
style: style
|
|
}));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this20 = this;
|
|
|
|
var processedData = this.processedData();
|
|
var columns = this.getColumns();
|
|
var totalRecords = this.getTotalRecords(processedData);
|
|
var empty = ObjectUtils.isEmpty(processedData);
|
|
var selectionModeInColumn = this.getSelectionModeInColumn(columns);
|
|
var selectable = this.props.selectionMode || selectionModeInColumn;
|
|
var className = classNames('p-datatable p-component', {
|
|
'p-datatable-hoverable-rows': this.props.rowHover,
|
|
'p-datatable-selectable': selectable && !this.props.cellSelection,
|
|
'p-datatable-selectable-cell': selectable && this.props.cellSelection,
|
|
'p-datatable-auto-layout': this.props.autoLayout,
|
|
'p-datatable-resizable': this.props.resizableColumns,
|
|
'p-datatable-resizable-fit': this.props.resizableColumns && this.props.columnResizeMode === 'fit',
|
|
'p-datatable-scrollable': this.props.scrollable,
|
|
'p-datatable-scrollable-vertical': this.props.scrollable && this.props.scrollDirection === 'vertical',
|
|
'p-datatable-scrollable-horizontal': this.props.scrollable && this.props.scrollDirection === 'horizontal',
|
|
'p-datatable-scrollable-both': this.props.scrollable && this.props.scrollDirection === 'both',
|
|
'p-datatable-flex-scrollable': this.props.scrollable && this.props.scrollHeight === 'flex',
|
|
'p-datatable-responsive-stack': this.props.responsiveLayout === 'stack',
|
|
'p-datatable-responsive-scroll': this.props.responsiveLayout === 'scroll',
|
|
'p-datatable-striped': this.props.stripedRows,
|
|
'p-datatable-gridlines': this.props.showGridlines,
|
|
'p-datatable-grouped-header': this.props.headerColumnGroup != null,
|
|
'p-datatable-grouped-footer': this.props.footerColumnGroup != null,
|
|
'p-datatable-sm': this.props.size === 'small',
|
|
'p-datatable-lg': this.props.size === 'large'
|
|
}, this.props.className);
|
|
var loader = this.renderLoader();
|
|
var header = this.renderHeader();
|
|
var paginatorTop = this.renderPaginatorTop(totalRecords);
|
|
var content = this.renderContent(processedData, columns, selectionModeInColumn, empty);
|
|
var paginatorBottom = this.renderPaginatorBottom(totalRecords);
|
|
var footer = this.renderFooter();
|
|
var resizeHelper = this.renderResizeHelper();
|
|
var reorderIndicators = this.renderReorderIndicators();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this20.el = el;
|
|
},
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style,
|
|
"data-scrollselectors": ".p-datatable-wrapper"
|
|
}, loader, header, paginatorTop, content, paginatorBottom, footer, resizeHelper, reorderIndicators);
|
|
}
|
|
}], [{
|
|
key: "getDerivedStateFromProps",
|
|
value: function getDerivedStateFromProps(nextProps, prevState) {
|
|
if (nextProps.rows !== prevState.d_rows && !nextProps.onPage) {
|
|
return {
|
|
rows: nextProps.rows,
|
|
d_rows: nextProps.rows
|
|
};
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}]);
|
|
|
|
return DataTable;
|
|
}(Component);
|
|
|
|
_defineProperty(DataTable, "defaultProps", {
|
|
id: null,
|
|
value: null,
|
|
header: null,
|
|
footer: null,
|
|
style: null,
|
|
className: null,
|
|
tableStyle: null,
|
|
tableClassName: null,
|
|
paginator: false,
|
|
paginatorPosition: 'bottom',
|
|
alwaysShowPaginator: true,
|
|
paginatorClassName: null,
|
|
paginatorTemplate: 'FirstPageLink PrevPageLink PageLinks NextPageLink LastPageLink RowsPerPageDropdown',
|
|
paginatorLeft: null,
|
|
paginatorRight: null,
|
|
paginatorDropdownAppendTo: null,
|
|
pageLinkSize: 5,
|
|
rowsPerPageOptions: null,
|
|
currentPageReportTemplate: '({currentPage} of {totalPages})',
|
|
first: 0,
|
|
rows: null,
|
|
totalRecords: null,
|
|
lazy: false,
|
|
sortField: null,
|
|
sortOrder: null,
|
|
multiSortMeta: null,
|
|
sortMode: 'single',
|
|
defaultSortOrder: 1,
|
|
removableSort: false,
|
|
emptyMessage: null,
|
|
selectionMode: null,
|
|
dragSelection: false,
|
|
cellSelection: false,
|
|
selection: null,
|
|
onSelectionChange: null,
|
|
contextMenuSelection: null,
|
|
onContextMenuSelectionChange: null,
|
|
compareSelectionBy: 'deepEquals',
|
|
dataKey: null,
|
|
metaKeySelection: true,
|
|
selectOnEdit: true,
|
|
selectionPageOnly: false,
|
|
selectionAutoFocus: true,
|
|
showSelectAll: true,
|
|
selectAll: false,
|
|
onSelectAllChange: null,
|
|
headerColumnGroup: null,
|
|
footerColumnGroup: null,
|
|
rowExpansionTemplate: null,
|
|
expandedRows: null,
|
|
onRowToggle: null,
|
|
resizableColumns: false,
|
|
columnResizeMode: 'fit',
|
|
reorderableColumns: false,
|
|
filters: null,
|
|
globalFilter: null,
|
|
filterDelay: 300,
|
|
filterLocale: undefined,
|
|
scrollable: false,
|
|
scrollHeight: null,
|
|
scrollDirection: 'vertical',
|
|
virtualScrollerOptions: null,
|
|
frozenWidth: null,
|
|
frozenValue: null,
|
|
csvSeparator: ',',
|
|
exportFilename: 'download',
|
|
rowGroupMode: null,
|
|
autoLayout: false,
|
|
rowClassName: null,
|
|
cellClassName: null,
|
|
rowGroupHeaderTemplate: null,
|
|
rowGroupFooterTemplate: null,
|
|
loading: false,
|
|
loadingIcon: 'pi pi-spinner',
|
|
tabIndex: 0,
|
|
stateKey: null,
|
|
stateStorage: 'session',
|
|
groupRowsBy: null,
|
|
editMode: 'cell',
|
|
editingRows: null,
|
|
expandableRowGroups: false,
|
|
rowHover: false,
|
|
showGridlines: false,
|
|
stripedRows: false,
|
|
size: 'normal',
|
|
responsiveLayout: 'stack',
|
|
breakpoint: '960px',
|
|
filterDisplay: 'menu',
|
|
expandedRowIcon: 'pi pi-chevron-down',
|
|
collapsedRowIcon: 'pi pi-chevron-right',
|
|
onRowEditComplete: null,
|
|
globalFilterFields: null,
|
|
showSelectionElement: null,
|
|
showRowReorderElement: null,
|
|
isDataSelectable: null,
|
|
onColumnResizeEnd: null,
|
|
onColumnResizerClick: null,
|
|
onColumnResizerDoubleClick: null,
|
|
onSort: null,
|
|
onPage: null,
|
|
onFilter: null,
|
|
onAllRowsSelect: null,
|
|
onAllRowsUnselect: null,
|
|
onRowClick: null,
|
|
onRowDoubleClick: null,
|
|
onRowSelect: null,
|
|
onRowUnselect: null,
|
|
onRowExpand: null,
|
|
onRowCollapse: null,
|
|
onContextMenu: null,
|
|
onColReorder: null,
|
|
onCellClick: null,
|
|
onCellSelect: null,
|
|
onCellUnselect: null,
|
|
onRowReorder: null,
|
|
onValueChange: null,
|
|
rowEditValidator: null,
|
|
onRowEditInit: null,
|
|
onRowEditSave: null,
|
|
onRowEditCancel: null,
|
|
onRowEditChange: null,
|
|
exportFunction: null,
|
|
customSaveState: null,
|
|
customRestoreState: null,
|
|
onStateSave: null,
|
|
onStateRestore: null
|
|
});
|
|
|
|
function _createSuper$1p(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1p(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1p() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var DataViewLayoutOptions = /*#__PURE__*/function (_Component) {
|
|
_inherits(DataViewLayoutOptions, _Component);
|
|
|
|
var _super = _createSuper$1p(DataViewLayoutOptions);
|
|
|
|
function DataViewLayoutOptions(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, DataViewLayoutOptions);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.changeLayout = _this.changeLayout.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(DataViewLayoutOptions, [{
|
|
key: "changeLayout",
|
|
value: function changeLayout(event, layoutMode) {
|
|
this.props.onChange({
|
|
originalEvent: event,
|
|
value: layoutMode
|
|
});
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this2 = this;
|
|
|
|
var className = classNames('p-dataview-layout-options p-selectbutton p-buttonset', this.props.className);
|
|
var buttonListClass = classNames('p-button p-button-icon-only', {
|
|
'p-highlight': this.props.layout === 'list'
|
|
});
|
|
var buttonGridClass = classNames('p-button p-button-icon-only', {
|
|
'p-highlight': this.props.layout === 'grid'
|
|
});
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
style: this.props.style,
|
|
className: className
|
|
}, /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: buttonListClass,
|
|
onClick: function onClick(event) {
|
|
return _this2.changeLayout(event, 'list');
|
|
}
|
|
}, /*#__PURE__*/React.createElement("i", {
|
|
className: "pi pi-bars"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null)), /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: buttonGridClass,
|
|
onClick: function onClick(event) {
|
|
return _this2.changeLayout(event, 'grid');
|
|
}
|
|
}, /*#__PURE__*/React.createElement("i", {
|
|
className: "pi pi-th-large"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null)));
|
|
}
|
|
}]);
|
|
|
|
return DataViewLayoutOptions;
|
|
}(Component);
|
|
|
|
_defineProperty(DataViewLayoutOptions, "defaultProps", {
|
|
id: null,
|
|
style: null,
|
|
className: null,
|
|
layout: null,
|
|
onChange: null
|
|
});
|
|
|
|
var DataViewItem = /*#__PURE__*/function (_Component2) {
|
|
_inherits(DataViewItem, _Component2);
|
|
|
|
var _super2 = _createSuper$1p(DataViewItem);
|
|
|
|
function DataViewItem() {
|
|
_classCallCheck(this, DataViewItem);
|
|
|
|
return _super2.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(DataViewItem, [{
|
|
key: "render",
|
|
value: function render() {
|
|
return this.props.template(this.props.item, this.props.layout);
|
|
}
|
|
}]);
|
|
|
|
return DataViewItem;
|
|
}(Component);
|
|
|
|
_defineProperty(DataViewItem, "defaultProps", {
|
|
template: null,
|
|
item: null,
|
|
layout: null
|
|
});
|
|
|
|
var DataView = /*#__PURE__*/function (_Component3) {
|
|
_inherits(DataView, _Component3);
|
|
|
|
var _super3 = _createSuper$1p(DataView);
|
|
|
|
function DataView(props) {
|
|
var _this3;
|
|
|
|
_classCallCheck(this, DataView);
|
|
|
|
_this3 = _super3.call(this, props);
|
|
|
|
if (!_this3.props.onPage) {
|
|
_this3.state = {
|
|
first: _this3.props.first,
|
|
rows: _this3.props.rows
|
|
};
|
|
}
|
|
|
|
_this3.sortChange = false;
|
|
_this3.onPageChange = _this3.onPageChange.bind(_assertThisInitialized(_this3));
|
|
return _this3;
|
|
}
|
|
|
|
_createClass(DataView, [{
|
|
key: "getItemRenderKey",
|
|
value: function getItemRenderKey(value) {
|
|
return this.props.dataKey ? ObjectUtils.resolveFieldData(value, this.props.dataKey) : null;
|
|
}
|
|
}, {
|
|
key: "getTotalRecords",
|
|
value: function getTotalRecords() {
|
|
if (this.props.totalRecords) return this.props.totalRecords;else return this.props.value ? this.props.value.length : 0;
|
|
}
|
|
}, {
|
|
key: "createPaginator",
|
|
value: function createPaginator(position) {
|
|
var className = classNames('p-paginator-' + position, this.props.paginatorClassName);
|
|
var first = this.props.onPage ? this.props.first : this.state.first;
|
|
var rows = this.props.onPage ? this.props.rows : this.state.rows;
|
|
var totalRecords = this.getTotalRecords();
|
|
return /*#__PURE__*/React.createElement(Paginator, {
|
|
first: first,
|
|
rows: rows,
|
|
pageLinkSize: this.props.pageLinkSize,
|
|
className: className,
|
|
onPageChange: this.onPageChange,
|
|
template: this.props.paginatorTemplate,
|
|
totalRecords: totalRecords,
|
|
rowsPerPageOptions: this.props.rowsPerPageOptions,
|
|
currentPageReportTemplate: this.props.currentPageReportTemplate,
|
|
leftContent: this.props.paginatorLeft,
|
|
rightContent: this.props.paginatorRight,
|
|
alwaysShow: this.props.alwaysShowPaginator,
|
|
dropdownAppendTo: this.props.paginatorDropdownAppendTo
|
|
});
|
|
}
|
|
}, {
|
|
key: "onPageChange",
|
|
value: function onPageChange(event) {
|
|
if (this.props.onPage) {
|
|
this.props.onPage(event);
|
|
} else {
|
|
this.setState({
|
|
first: event.first,
|
|
rows: event.rows
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "isEmpty",
|
|
value: function isEmpty() {
|
|
return !this.props.value || this.props.value.length === 0;
|
|
}
|
|
}, {
|
|
key: "sort",
|
|
value: function sort() {
|
|
var _this4 = this;
|
|
|
|
if (this.props.value) {
|
|
var value = _toConsumableArray(this.props.value);
|
|
|
|
value.sort(function (data1, data2) {
|
|
var value1 = ObjectUtils.resolveFieldData(data1, _this4.props.sortField);
|
|
var value2 = ObjectUtils.resolveFieldData(data2, _this4.props.sortField);
|
|
var result = null;
|
|
if (value1 == null && value2 != null) result = -1;else if (value1 != null && value2 == null) result = 1;else if (value1 == null && value2 == null) result = 0;else if (typeof value1 === 'string' && typeof value2 === 'string') result = value1.localeCompare(value2, undefined, {
|
|
numeric: true
|
|
});else result = value1 < value2 ? -1 : value1 > value2 ? 1 : 0;
|
|
return _this4.props.sortOrder * result;
|
|
});
|
|
return value;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderLoader",
|
|
value: function renderLoader() {
|
|
if (this.props.loading) {
|
|
var iconClassName = classNames('p-dataview-loading-icon pi-spin', this.props.loadingIcon);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-dataview-loading-overlay p-component-overlay"
|
|
}, /*#__PURE__*/React.createElement("i", {
|
|
className: iconClassName
|
|
}));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderTopPaginator",
|
|
value: function renderTopPaginator() {
|
|
if (this.props.paginator && (this.props.paginatorPosition !== 'bottom' || this.props.paginatorPosition === 'both')) {
|
|
return this.createPaginator('top');
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderBottomPaginator",
|
|
value: function renderBottomPaginator() {
|
|
if (this.props.paginator && (this.props.paginatorPosition !== 'top' || this.props.paginatorPosition === 'both')) {
|
|
return this.createPaginator('bottom');
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderEmptyMessage",
|
|
value: function renderEmptyMessage() {
|
|
if (!this.props.loading) {
|
|
var content = this.props.emptyMessage || localeOption('emptyMessage');
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-col-12 col-12 p-dataview-emptymessage"
|
|
}, content);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderHeader",
|
|
value: function renderHeader() {
|
|
if (this.props.header) {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-dataview-header"
|
|
}, this.props.header);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderFooter",
|
|
value: function renderFooter() {
|
|
if (this.props.footer) {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-dataview-footer"
|
|
}, " ", this.props.footer);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderItems",
|
|
value: function renderItems(value) {
|
|
var _this5 = this;
|
|
|
|
if (value && value.length) {
|
|
if (this.props.paginator) {
|
|
var rows = this.props.onPage ? this.props.rows : this.state.rows;
|
|
var first = this.props.lazy ? 0 : this.props.onPage ? this.props.first : this.state.first;
|
|
var totalRecords = this.getTotalRecords();
|
|
var last = Math.min(rows + first, totalRecords);
|
|
var items = [];
|
|
|
|
for (var i = first; i < last; i++) {
|
|
var val = value[i];
|
|
val && items.push( /*#__PURE__*/React.createElement(DataViewItem, {
|
|
key: this.getItemRenderKey(value) || i,
|
|
template: this.props.itemTemplate,
|
|
layout: this.props.layout,
|
|
item: val
|
|
}));
|
|
}
|
|
|
|
return items;
|
|
} else {
|
|
return value.map(function (item, index) {
|
|
return /*#__PURE__*/React.createElement(DataViewItem, {
|
|
key: _this5.getItemRenderKey(item) || index,
|
|
template: _this5.props.itemTemplate,
|
|
layout: _this5.props.layout,
|
|
item: item
|
|
});
|
|
});
|
|
}
|
|
} else {
|
|
return this.renderEmptyMessage();
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent(value) {
|
|
var items = this.renderItems(value);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-dataview-content"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-grid p-nogutter grid grid-nogutter"
|
|
}, items));
|
|
}
|
|
}, {
|
|
key: "processData",
|
|
value: function processData() {
|
|
var data = this.props.value;
|
|
|
|
if (data && data.length) {
|
|
if (this.props.sortField) {
|
|
data = this.sort();
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var value = this.processData();
|
|
var className = classNames('p-dataview p-component', {
|
|
'p-dataview-list': this.props.layout === 'list',
|
|
'p-dataview-grid': this.props.layout === 'grid',
|
|
'p-dataview-loading': this.props.loading
|
|
}, this.props.className);
|
|
var loader = this.renderLoader();
|
|
var topPaginator = this.renderTopPaginator();
|
|
var bottomPaginator = this.renderBottomPaginator();
|
|
var header = this.renderHeader();
|
|
var footer = this.renderFooter();
|
|
var content = this.renderContent(value);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
style: this.props.style,
|
|
className: className
|
|
}, loader, header, topPaginator, content, bottomPaginator, footer);
|
|
}
|
|
}]);
|
|
|
|
return DataView;
|
|
}(Component);
|
|
|
|
_defineProperty(DataView, "defaultProps", {
|
|
id: null,
|
|
header: null,
|
|
footer: null,
|
|
value: null,
|
|
layout: 'list',
|
|
dataKey: null,
|
|
rows: null,
|
|
first: 0,
|
|
totalRecords: null,
|
|
paginator: false,
|
|
paginatorPosition: 'bottom',
|
|
alwaysShowPaginator: true,
|
|
paginatorClassName: null,
|
|
paginatorTemplate: 'FirstPageLink PrevPageLink PageLinks NextPageLink LastPageLink RowsPerPageDropdown',
|
|
paginatorLeft: null,
|
|
paginatorRight: null,
|
|
paginatorDropdownAppendTo: null,
|
|
pageLinkSize: 5,
|
|
rowsPerPageOptions: null,
|
|
currentPageReportTemplate: '({currentPage} of {totalPages})',
|
|
emptyMessage: null,
|
|
sortField: null,
|
|
sortOrder: null,
|
|
style: null,
|
|
className: null,
|
|
lazy: false,
|
|
loading: false,
|
|
loadingIcon: 'pi pi-spinner',
|
|
itemTemplate: null,
|
|
onPage: null
|
|
});
|
|
|
|
function _createSuper$1o(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1o(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1o() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var DeferredContent = /*#__PURE__*/function (_Component) {
|
|
_inherits(DeferredContent, _Component);
|
|
|
|
var _super = _createSuper$1o(DeferredContent);
|
|
|
|
function DeferredContent(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, DeferredContent);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
loaded: false
|
|
};
|
|
return _this;
|
|
}
|
|
|
|
_createClass(DeferredContent, [{
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (!this.state.loaded) {
|
|
if (this.shouldLoad()) this.load();else this.bindScrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindScrollListener",
|
|
value: function bindScrollListener() {
|
|
var _this2 = this;
|
|
|
|
this.documentScrollListener = function () {
|
|
if (_this2.shouldLoad()) {
|
|
_this2.load();
|
|
|
|
_this2.unbindScrollListener();
|
|
}
|
|
};
|
|
|
|
window.addEventListener('scroll', this.documentScrollListener);
|
|
}
|
|
}, {
|
|
key: "unbindScrollListener",
|
|
value: function unbindScrollListener() {
|
|
if (this.documentScrollListener) {
|
|
window.removeEventListener('scroll', this.documentScrollListener);
|
|
this.documentScrollListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "shouldLoad",
|
|
value: function shouldLoad() {
|
|
if (this.state.loaded) {
|
|
return false;
|
|
} else {
|
|
var rect = this.container.getBoundingClientRect();
|
|
var docElement = document.documentElement;
|
|
var winHeight = docElement.clientHeight;
|
|
return winHeight >= rect.top;
|
|
}
|
|
}
|
|
}, {
|
|
key: "load",
|
|
value: function load(event) {
|
|
this.setState({
|
|
loaded: true
|
|
});
|
|
|
|
if (this.props.onLoad) {
|
|
this.props.onLoad(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.unbindScrollListener();
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this3 = this;
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this3.container = el;
|
|
}
|
|
}, this.state.loaded ? this.props.children : null);
|
|
}
|
|
}]);
|
|
|
|
return DeferredContent;
|
|
}(Component);
|
|
|
|
_defineProperty(DeferredContent, "defaultProps", {
|
|
onload: null
|
|
});
|
|
|
|
function _createSuper$1n(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1n(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1n() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Divider = /*#__PURE__*/function (_Component) {
|
|
_inherits(Divider, _Component);
|
|
|
|
var _super = _createSuper$1n(Divider);
|
|
|
|
function Divider() {
|
|
_classCallCheck(this, Divider);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(Divider, [{
|
|
key: "isHorizontal",
|
|
get: function get() {
|
|
return this.props.layout === 'horizontal';
|
|
}
|
|
}, {
|
|
key: "isVertical",
|
|
get: function get() {
|
|
return this.props.layout === 'vertical';
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var dividerClassName = classNames("p-divider p-component p-divider-".concat(this.props.layout, " p-divider-").concat(this.props.type), {
|
|
'p-divider-left': this.isHorizontal && (!this.props.align || this.props.align === 'left'),
|
|
'p-divider-right': this.isHorizontal && this.props.align === 'right',
|
|
'p-divider-center': this.isHorizontal && this.props.align === 'center' || this.isVertical && (!this.props.align || this.props.align === 'center'),
|
|
'p-divider-top': this.isVertical && this.props.align === 'top',
|
|
'p-divider-bottom': this.isVertical && this.props.align === 'bottom'
|
|
}, this.props.className);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: dividerClassName,
|
|
style: this.props.style,
|
|
role: "separator"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-divider-content"
|
|
}, this.props.children));
|
|
}
|
|
}]);
|
|
|
|
return Divider;
|
|
}(Component);
|
|
|
|
_defineProperty(Divider, "defaultProps", {
|
|
align: null,
|
|
layout: 'horizontal',
|
|
type: 'solid',
|
|
style: null,
|
|
className: null
|
|
});
|
|
|
|
function ownKeys$r(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$r(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$r(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$r(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$1m(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1m(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1m() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Editor = /*#__PURE__*/function (_Component) {
|
|
_inherits(Editor, _Component);
|
|
|
|
var _super = _createSuper$1m(Editor);
|
|
|
|
function Editor() {
|
|
_classCallCheck(this, Editor);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(Editor, [{
|
|
key: "getQuill",
|
|
value: function getQuill() {
|
|
return this.quill;
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
var _this = this;
|
|
|
|
import('quill').then(function (module) {
|
|
if (module && module["default"] && DomHandler.isExist(_this.editorElement)) {
|
|
_this.quill = new module["default"](_this.editorElement, {
|
|
modules: _objectSpread$r({
|
|
toolbar: _this.props.showHeader ? _this.toolbarElement : false
|
|
}, _this.props.modules),
|
|
placeholder: _this.props.placeholder,
|
|
readOnly: _this.props.readOnly,
|
|
theme: _this.props.theme,
|
|
formats: _this.props.formats
|
|
});
|
|
|
|
if (_this.props.value) {
|
|
_this.quill.setContents(_this.quill.clipboard.convert(_this.props.value));
|
|
}
|
|
|
|
_this.quill.on('text-change', function (delta, source) {
|
|
var html = _this.editorElement.children[0].innerHTML;
|
|
|
|
var text = _this.quill.getText();
|
|
|
|
if (html === '<p><br></p>') {
|
|
html = null;
|
|
}
|
|
|
|
if (_this.props.onTextChange) {
|
|
_this.props.onTextChange({
|
|
htmlValue: html,
|
|
textValue: text,
|
|
delta: delta,
|
|
source: source
|
|
});
|
|
}
|
|
});
|
|
|
|
_this.quill.on('selection-change', function (range, oldRange, source) {
|
|
if (_this.props.onSelectionChange) {
|
|
_this.props.onSelectionChange({
|
|
range: range,
|
|
oldRange: oldRange,
|
|
source: source
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}).then(function () {
|
|
if (_this.quill && _this.quill.getModule('toolbar')) {
|
|
_this.props.onLoad && _this.props.onLoad(_this.quill);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (this.props.value !== prevProps.value && this.quill && !this.quill.hasFocus()) {
|
|
if (this.props.value) this.quill.setContents(this.quill.clipboard.convert(this.props.value));else this.quill.setText('');
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this2 = this;
|
|
|
|
var containerClass = classNames('p-component p-editor-container', this.props.className);
|
|
var toolbarHeader = null;
|
|
|
|
if (this.props.showHeader === false) {
|
|
toolbarHeader = '';
|
|
this.toolbarElement = undefined;
|
|
} else if (this.props.headerTemplate) {
|
|
toolbarHeader = /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this2.toolbarElement = el;
|
|
},
|
|
className: "p-editor-toolbar"
|
|
}, this.props.headerTemplate);
|
|
} else {
|
|
toolbarHeader = /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this2.toolbarElement = el;
|
|
},
|
|
className: "p-editor-toolbar"
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "ql-formats"
|
|
}, /*#__PURE__*/React.createElement("select", {
|
|
className: "ql-header",
|
|
defaultValue: "0"
|
|
}, /*#__PURE__*/React.createElement("option", {
|
|
value: "1"
|
|
}, "Heading"), /*#__PURE__*/React.createElement("option", {
|
|
value: "2"
|
|
}, "Subheading"), /*#__PURE__*/React.createElement("option", {
|
|
value: "0"
|
|
}, "Normal")), /*#__PURE__*/React.createElement("select", {
|
|
className: "ql-font"
|
|
}, /*#__PURE__*/React.createElement("option", null), /*#__PURE__*/React.createElement("option", {
|
|
value: "serif"
|
|
}), /*#__PURE__*/React.createElement("option", {
|
|
value: "monospace"
|
|
}))), /*#__PURE__*/React.createElement("span", {
|
|
className: "ql-formats"
|
|
}, /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "ql-bold",
|
|
"aria-label": "Bold"
|
|
}), /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "ql-italic",
|
|
"aria-label": "Italic"
|
|
}), /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "ql-underline",
|
|
"aria-label": "Underline"
|
|
})), /*#__PURE__*/React.createElement("span", {
|
|
className: "ql-formats"
|
|
}, /*#__PURE__*/React.createElement("select", {
|
|
className: "ql-color"
|
|
}), /*#__PURE__*/React.createElement("select", {
|
|
className: "ql-background"
|
|
})), /*#__PURE__*/React.createElement("span", {
|
|
className: "ql-formats"
|
|
}, /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "ql-list",
|
|
value: "ordered",
|
|
"aria-label": "Ordered List"
|
|
}), /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "ql-list",
|
|
value: "bullet",
|
|
"aria-label": "Unordered List"
|
|
}), /*#__PURE__*/React.createElement("select", {
|
|
className: "ql-align"
|
|
}, /*#__PURE__*/React.createElement("option", {
|
|
defaultValue: true
|
|
}), /*#__PURE__*/React.createElement("option", {
|
|
value: "center"
|
|
}), /*#__PURE__*/React.createElement("option", {
|
|
value: "right"
|
|
}), /*#__PURE__*/React.createElement("option", {
|
|
value: "justify"
|
|
}))), /*#__PURE__*/React.createElement("span", {
|
|
className: "ql-formats"
|
|
}, /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "ql-link",
|
|
"aria-label": "Insert Link"
|
|
}), /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "ql-image",
|
|
"aria-label": "Insert Image"
|
|
}), /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "ql-code-block",
|
|
"aria-label": "Insert Code Block"
|
|
})), /*#__PURE__*/React.createElement("span", {
|
|
className: "ql-formats"
|
|
}, /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "ql-clean",
|
|
"aria-label": "Remove Styles"
|
|
})));
|
|
}
|
|
|
|
var content = /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this2.editorElement = el;
|
|
},
|
|
className: "p-editor-content",
|
|
style: this.props.style
|
|
});
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
className: containerClass
|
|
}, toolbarHeader, content);
|
|
}
|
|
}]);
|
|
|
|
return Editor;
|
|
}(Component);
|
|
|
|
_defineProperty(Editor, "defaultProps", {
|
|
id: null,
|
|
value: null,
|
|
style: null,
|
|
className: null,
|
|
placeholder: null,
|
|
readOnly: false,
|
|
modules: null,
|
|
formats: null,
|
|
theme: 'snow',
|
|
showHeader: true,
|
|
headerTemplate: null,
|
|
onTextChange: null,
|
|
onSelectionChange: null,
|
|
onLoad: null
|
|
});
|
|
|
|
function ownKeys$q(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$q(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$q(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$q(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$1l(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1l(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1l() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Fieldset = /*#__PURE__*/function (_Component) {
|
|
_inherits(Fieldset, _Component);
|
|
|
|
var _super = _createSuper$1l(Fieldset);
|
|
|
|
function Fieldset(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Fieldset);
|
|
|
|
_this = _super.call(this, props);
|
|
var state = {
|
|
id: props.id
|
|
};
|
|
|
|
if (!_this.props.onToggle) {
|
|
state = _objectSpread$q(_objectSpread$q({}, state), {}, {
|
|
collapsed: props.collapsed
|
|
});
|
|
}
|
|
|
|
_this.state = state;
|
|
_this.toggle = _this.toggle.bind(_assertThisInitialized(_this));
|
|
_this.contentRef = /*#__PURE__*/React.createRef();
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Fieldset, [{
|
|
key: "toggle",
|
|
value: function toggle(event) {
|
|
if (this.props.toggleable) {
|
|
var collapsed = this.props.onToggle ? this.props.collapsed : this.state.collapsed;
|
|
if (collapsed) this.expand(event);else this.collapse(event);
|
|
|
|
if (this.props.onToggle) {
|
|
this.props.onToggle({
|
|
originalEvent: event,
|
|
value: !collapsed
|
|
});
|
|
}
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "expand",
|
|
value: function expand(event) {
|
|
if (!this.props.onToggle) {
|
|
this.setState({
|
|
collapsed: false
|
|
});
|
|
}
|
|
|
|
if (this.props.onExpand) {
|
|
this.props.onExpand(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "collapse",
|
|
value: function collapse(event) {
|
|
if (!this.props.onToggle) {
|
|
this.setState({
|
|
collapsed: true
|
|
});
|
|
}
|
|
|
|
if (this.props.onCollapse) {
|
|
this.props.onCollapse(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "isCollapsed",
|
|
value: function isCollapsed() {
|
|
return this.props.toggleable ? this.props.onToggle ? this.props.collapsed : this.state.collapsed : false;
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (!this.state.id) {
|
|
this.setState({
|
|
id: UniqueComponentId()
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent(collapsed) {
|
|
var id = this.state.id + '_content';
|
|
return /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.contentRef,
|
|
classNames: "p-toggleable-content",
|
|
timeout: {
|
|
enter: 1000,
|
|
exit: 450
|
|
},
|
|
"in": !collapsed,
|
|
unmountOnExit: true,
|
|
options: this.props.transitionOptions
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.contentRef,
|
|
id: id,
|
|
className: "p-toggleable-content",
|
|
"aria-hidden": collapsed,
|
|
role: "region",
|
|
"aria-labelledby": this.state.id + '_header'
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-fieldset-content"
|
|
}, this.props.children)));
|
|
}
|
|
}, {
|
|
key: "renderToggleIcon",
|
|
value: function renderToggleIcon(collapsed) {
|
|
if (this.props.toggleable) {
|
|
var className = classNames('p-fieldset-toggler pi', {
|
|
'pi-plus': collapsed,
|
|
'pi-minus': !collapsed
|
|
});
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: className
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderLegendContent",
|
|
value: function renderLegendContent(collapsed) {
|
|
if (this.props.toggleable) {
|
|
var toggleIcon = this.renderToggleIcon(collapsed);
|
|
var ariaControls = this.state.id + '_content';
|
|
return /*#__PURE__*/React.createElement("a", {
|
|
href: '#' + ariaControls,
|
|
"aria-controls": ariaControls,
|
|
id: this.state.id + '_header',
|
|
"aria-expanded": !collapsed,
|
|
tabIndex: this.props.toggleable ? null : -1
|
|
}, toggleIcon, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-fieldset-legend-text"
|
|
}, this.props.legend), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: "p-fieldset-legend-text",
|
|
id: this.state.id + '_header'
|
|
}, this.props.legend);
|
|
}
|
|
}, {
|
|
key: "renderLegend",
|
|
value: function renderLegend(collapsed) {
|
|
var legendContent = this.renderLegendContent(collapsed);
|
|
|
|
if (this.props.legend != null || this.props.toggleable) {
|
|
return /*#__PURE__*/React.createElement("legend", {
|
|
className: "p-fieldset-legend p-unselectable-text",
|
|
onClick: this.toggle
|
|
}, legendContent);
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-fieldset p-component', this.props.className, {
|
|
'p-fieldset-toggleable': this.props.toggleable
|
|
});
|
|
var collapsed = this.isCollapsed();
|
|
var legend = this.renderLegend(collapsed);
|
|
var content = this.renderContent(collapsed);
|
|
return /*#__PURE__*/React.createElement("fieldset", {
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style,
|
|
onClick: this.props.onClick
|
|
}, legend, content);
|
|
}
|
|
}]);
|
|
|
|
return Fieldset;
|
|
}(Component);
|
|
|
|
_defineProperty(Fieldset, "defaultProps", {
|
|
id: null,
|
|
legend: null,
|
|
className: null,
|
|
style: null,
|
|
toggleable: null,
|
|
collapsed: null,
|
|
transitionOptions: null,
|
|
onExpand: null,
|
|
onCollapse: null,
|
|
onToggle: null,
|
|
onClick: null
|
|
});
|
|
|
|
function _createSuper$1k(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1k(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1k() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
var UIMessageComponent = /*#__PURE__*/function (_Component) {
|
|
_inherits(UIMessageComponent, _Component);
|
|
|
|
var _super = _createSuper$1k(UIMessageComponent);
|
|
|
|
function UIMessageComponent(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, UIMessageComponent);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onClose = _this.onClose.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(UIMessageComponent, [{
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
var _this2 = this;
|
|
|
|
if (!this.props.message.sticky) {
|
|
this.timeout = setTimeout(function () {
|
|
_this2.onClose(null);
|
|
}, this.props.message.life || 3000);
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.timeout) {
|
|
clearTimeout(this.timeout);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onClose",
|
|
value: function onClose(event) {
|
|
if (this.timeout) {
|
|
clearTimeout(this.timeout);
|
|
}
|
|
|
|
if (this.props.onClose) {
|
|
this.props.onClose(this.props.message);
|
|
}
|
|
|
|
if (event) {
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onClick",
|
|
value: function onClick() {
|
|
if (this.props.onClick) {
|
|
this.props.onClick(this.props.message);
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderCloseIcon",
|
|
value: function renderCloseIcon() {
|
|
if (this.props.message.closable !== false) {
|
|
return /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "p-message-close p-link",
|
|
onClick: this.onClose
|
|
}, /*#__PURE__*/React.createElement("i", {
|
|
className: "p-message-close-icon pi pi-times"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderMessage",
|
|
value: function renderMessage() {
|
|
if (this.props.message) {
|
|
var _this$props$message = this.props.message,
|
|
severity = _this$props$message.severity,
|
|
content = _this$props$message.content,
|
|
summary = _this$props$message.summary,
|
|
detail = _this$props$message.detail;
|
|
var icon = classNames('p-message-icon pi ', {
|
|
'pi-info-circle': severity === 'info',
|
|
'pi-check': severity === 'success',
|
|
'pi-exclamation-triangle': severity === 'warn',
|
|
'pi-times-circle': severity === 'error'
|
|
});
|
|
return content || /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("span", {
|
|
className: icon
|
|
}), /*#__PURE__*/React.createElement("span", {
|
|
className: "p-message-summary"
|
|
}, summary), /*#__PURE__*/React.createElement("span", {
|
|
className: "p-message-detail"
|
|
}, detail));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var severity = this.props.message.severity;
|
|
var className = 'p-message p-component p-message-' + severity;
|
|
var closeIcon = this.renderCloseIcon();
|
|
var message = this.renderMessage();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: this.props.forwardRef,
|
|
className: className,
|
|
onClick: this.onClick
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-message-wrapper"
|
|
}, message, closeIcon));
|
|
}
|
|
}]);
|
|
|
|
return UIMessageComponent;
|
|
}(Component);
|
|
|
|
_defineProperty(UIMessageComponent, "defaultProps", {
|
|
message: null,
|
|
onClose: null,
|
|
onClick: null
|
|
});
|
|
|
|
var UIMessage = /*#__PURE__*/React.forwardRef(function (props, ref) {
|
|
return /*#__PURE__*/React.createElement(UIMessageComponent, _extends({
|
|
forwardRef: ref
|
|
}, props));
|
|
});
|
|
|
|
function _createSuper$1j(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1j(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1j() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var messageIdx$1 = 0;
|
|
var Messages = /*#__PURE__*/function (_Component) {
|
|
_inherits(Messages, _Component);
|
|
|
|
var _super = _createSuper$1j(Messages);
|
|
|
|
function Messages(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Messages);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
messages: []
|
|
};
|
|
_this.onClose = _this.onClose.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Messages, [{
|
|
key: "show",
|
|
value: function show(value) {
|
|
if (value) {
|
|
var newMessages = [];
|
|
|
|
if (Array.isArray(value)) {
|
|
for (var i = 0; i < value.length; i++) {
|
|
value[i].id = messageIdx$1++;
|
|
newMessages = [].concat(_toConsumableArray(this.state.messages), _toConsumableArray(value));
|
|
}
|
|
} else {
|
|
value.id = messageIdx$1++;
|
|
newMessages = this.state.messages ? [].concat(_toConsumableArray(this.state.messages), [value]) : [value];
|
|
}
|
|
|
|
this.setState({
|
|
messages: newMessages
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "clear",
|
|
value: function clear() {
|
|
this.setState({
|
|
messages: []
|
|
});
|
|
}
|
|
}, {
|
|
key: "replace",
|
|
value: function replace(value) {
|
|
var _this2 = this;
|
|
|
|
this.setState({
|
|
messages: []
|
|
}, function () {
|
|
return _this2.show(value);
|
|
});
|
|
}
|
|
}, {
|
|
key: "onClose",
|
|
value: function onClose(message) {
|
|
var newMessages = this.state.messages.filter(function (msg) {
|
|
return msg.id !== message.id;
|
|
});
|
|
this.setState({
|
|
messages: newMessages
|
|
});
|
|
|
|
if (this.props.onRemove) {
|
|
this.props.onRemove(message);
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this3 = this;
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
className: this.props.className,
|
|
style: this.props.style
|
|
}, /*#__PURE__*/React.createElement(TransitionGroup, null, this.state.messages.map(function (message) {
|
|
var messageRef = /*#__PURE__*/React.createRef();
|
|
return /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: messageRef,
|
|
key: message.id,
|
|
classNames: "p-message",
|
|
unmountOnExit: true,
|
|
timeout: {
|
|
enter: 300,
|
|
exit: 300
|
|
},
|
|
options: _this3.props.transitionOptions
|
|
}, /*#__PURE__*/React.createElement(UIMessage, {
|
|
ref: messageRef,
|
|
message: message,
|
|
onClick: _this3.props.onClick,
|
|
onClose: _this3.onClose
|
|
}));
|
|
})));
|
|
}
|
|
}]);
|
|
|
|
return Messages;
|
|
}(Component);
|
|
|
|
_defineProperty(Messages, "defaultProps", {
|
|
id: null,
|
|
className: null,
|
|
style: null,
|
|
transitionOptions: null,
|
|
onRemove: null,
|
|
onClick: null
|
|
});
|
|
|
|
function _createSuper$1i(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1i(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1i() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var ProgressBar = /*#__PURE__*/function (_Component) {
|
|
_inherits(ProgressBar, _Component);
|
|
|
|
var _super = _createSuper$1i(ProgressBar);
|
|
|
|
function ProgressBar() {
|
|
_classCallCheck(this, ProgressBar);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(ProgressBar, [{
|
|
key: "renderLabel",
|
|
value: function renderLabel() {
|
|
if (this.props.showValue && this.props.value != null) {
|
|
var label = this.props.displayValueTemplate ? this.props.displayValueTemplate(this.props.value) : this.props.value + this.props.unit;
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-progressbar-label"
|
|
}, label);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderDeterminate",
|
|
value: function renderDeterminate() {
|
|
var className = classNames('p-progressbar p-component p-progressbar-determinate', this.props.className);
|
|
var label = this.renderLabel();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
role: "progressbar",
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style,
|
|
"aria-valuemin": "0",
|
|
"aria-valuenow": this.props.value,
|
|
"aria-valuemax": "100",
|
|
"aria-label": this.props.value
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-progressbar-value p-progressbar-value-animate",
|
|
style: {
|
|
width: this.props.value + '%',
|
|
display: 'block',
|
|
backgroundColor: this.props.color
|
|
}
|
|
}), label);
|
|
}
|
|
}, {
|
|
key: "renderIndeterminate",
|
|
value: function renderIndeterminate() {
|
|
var className = classNames('p-progressbar p-component p-progressbar-indeterminate', this.props.className);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
role: "progressbar",
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-progressbar-indeterminate-container"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-progressbar-value p-progressbar-value-animate",
|
|
style: {
|
|
backgroundColor: this.props.color
|
|
}
|
|
})));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
if (this.props.mode === 'determinate') return this.renderDeterminate();else if (this.props.mode === 'indeterminate') return this.renderIndeterminate();else throw new Error(this.props.mode + " is not a valid mode for the ProgressBar. Valid values are 'determinate' and 'indeterminate'");
|
|
}
|
|
}]);
|
|
|
|
return ProgressBar;
|
|
}(Component);
|
|
|
|
_defineProperty(ProgressBar, "defaultProps", {
|
|
id: null,
|
|
value: null,
|
|
showValue: true,
|
|
unit: '%',
|
|
style: null,
|
|
className: null,
|
|
mode: 'determinate',
|
|
displayValueTemplate: null,
|
|
color: null
|
|
});
|
|
|
|
function _createForOfIteratorHelper$b(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$b(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$b(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$b(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$b(o, minLen); }
|
|
|
|
function _arrayLikeToArray$b(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 _createSuper$1h(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1h(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1h() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var FileUpload = /*#__PURE__*/function (_Component) {
|
|
_inherits(FileUpload, _Component);
|
|
|
|
var _super = _createSuper$1h(FileUpload);
|
|
|
|
function FileUpload(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, FileUpload);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
files: [],
|
|
msgs: [],
|
|
focused: false,
|
|
progress: 0
|
|
};
|
|
_this.choose = _this.choose.bind(_assertThisInitialized(_this));
|
|
_this.upload = _this.upload.bind(_assertThisInitialized(_this));
|
|
_this.clear = _this.clear.bind(_assertThisInitialized(_this));
|
|
_this.onFileSelect = _this.onFileSelect.bind(_assertThisInitialized(_this));
|
|
_this.onDragEnter = _this.onDragEnter.bind(_assertThisInitialized(_this));
|
|
_this.onDragOver = _this.onDragOver.bind(_assertThisInitialized(_this));
|
|
_this.onDragLeave = _this.onDragLeave.bind(_assertThisInitialized(_this));
|
|
_this.onDrop = _this.onDrop.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onFocus = _this.onFocus.bind(_assertThisInitialized(_this));
|
|
_this.onBlur = _this.onBlur.bind(_assertThisInitialized(_this));
|
|
_this.onSimpleUploaderClick = _this.onSimpleUploaderClick.bind(_assertThisInitialized(_this));
|
|
_this.duplicateIEEvent = false;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(FileUpload, [{
|
|
key: "hasFiles",
|
|
value: function hasFiles() {
|
|
return this.state.files && this.state.files.length > 0;
|
|
}
|
|
}, {
|
|
key: "isImage",
|
|
value: function isImage(file) {
|
|
return /^image\//.test(file.type);
|
|
}
|
|
}, {
|
|
key: "chooseDisabled",
|
|
value: function chooseDisabled() {
|
|
return this.props.disabled || this.props.fileLimit && this.props.fileLimit <= this.state.files.length + this.uploadedFileCount;
|
|
}
|
|
}, {
|
|
key: "uploadDisabled",
|
|
value: function uploadDisabled() {
|
|
return this.props.disabled || !this.hasFiles();
|
|
}
|
|
}, {
|
|
key: "cancelDisabled",
|
|
value: function cancelDisabled() {
|
|
return this.props.disabled || !this.hasFiles();
|
|
}
|
|
}, {
|
|
key: "chooseButtonLabel",
|
|
value: function chooseButtonLabel() {
|
|
return this.props.chooseLabel || this.props.chooseOptions.label || localeOption('choose');
|
|
}
|
|
}, {
|
|
key: "uploadButtonLabel",
|
|
value: function uploadButtonLabel() {
|
|
return this.props.uploadLabel || this.props.uploadOptions.label || localeOption('upload');
|
|
}
|
|
}, {
|
|
key: "cancelButtonLabel",
|
|
value: function cancelButtonLabel() {
|
|
return this.props.cancelLabel || this.props.cancelOptions.label || localeOption('cancel');
|
|
}
|
|
}, {
|
|
key: "remove",
|
|
value: function remove(event, index) {
|
|
this.clearInputElement();
|
|
|
|
var currentFiles = _toConsumableArray(this.state.files);
|
|
|
|
var removedFile = this.state.files[index];
|
|
currentFiles.splice(index, 1);
|
|
this.setState({
|
|
files: currentFiles
|
|
});
|
|
|
|
if (this.props.onRemove) {
|
|
this.props.onRemove({
|
|
originalEvent: event,
|
|
file: removedFile
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "clearInputElement",
|
|
value: function clearInputElement() {
|
|
if (this.fileInput) {
|
|
this.fileInput.value = '';
|
|
}
|
|
}
|
|
}, {
|
|
key: "clearIEInput",
|
|
value: function clearIEInput() {
|
|
if (this.fileInput) {
|
|
this.duplicateIEEvent = true; //IE11 fix to prevent onFileChange trigger again
|
|
|
|
this.fileInput.value = '';
|
|
}
|
|
}
|
|
}, {
|
|
key: "formatSize",
|
|
value: function formatSize(bytes) {
|
|
if (bytes === 0) {
|
|
return '0 B';
|
|
}
|
|
|
|
var k = 1000,
|
|
dm = 3,
|
|
sizes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'],
|
|
i = Math.floor(Math.log(bytes) / Math.log(k));
|
|
return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
|
|
}
|
|
}, {
|
|
key: "onFileSelect",
|
|
value: function onFileSelect(event) {
|
|
var _this2 = this;
|
|
|
|
if (event.type !== 'drop' && this.isIE11() && this.duplicateIEEvent) {
|
|
this.duplicateIEEvent = false;
|
|
return;
|
|
}
|
|
|
|
this.setState({
|
|
msgs: []
|
|
});
|
|
this.files = this.state.files ? _toConsumableArray(this.state.files) : [];
|
|
var files = event.dataTransfer ? event.dataTransfer.files : event.target.files;
|
|
|
|
for (var i = 0; i < files.length; i++) {
|
|
var file = files[i];
|
|
|
|
if (!this.isFileSelected(file)) {
|
|
if (this.validate(file)) {
|
|
if (this.isImage(file)) {
|
|
file.objectURL = window.URL.createObjectURL(file);
|
|
}
|
|
|
|
this.files.push(file);
|
|
}
|
|
}
|
|
}
|
|
|
|
this.setState({
|
|
files: this.files
|
|
}, function () {
|
|
if (_this2.hasFiles() && _this2.props.auto) {
|
|
_this2.upload();
|
|
}
|
|
});
|
|
|
|
if (this.props.onSelect) {
|
|
this.props.onSelect({
|
|
originalEvent: event,
|
|
files: files
|
|
});
|
|
}
|
|
|
|
if (event.type !== 'drop' && this.isIE11()) {
|
|
this.clearIEInput();
|
|
} else {
|
|
this.clearInputElement();
|
|
}
|
|
|
|
if (this.props.mode === 'basic' && this.files.length > 0) {
|
|
this.fileInput.style.display = 'none';
|
|
}
|
|
}
|
|
}, {
|
|
key: "isFileSelected",
|
|
value: function isFileSelected(file) {
|
|
var _iterator = _createForOfIteratorHelper$b(this.state.files),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var sFile = _step.value;
|
|
if (sFile.name + sFile.type + sFile.size === file.name + file.type + file.size) return true;
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "isIE11",
|
|
value: function isIE11() {
|
|
return !!window['MSInputMethodContext'] && !!document['documentMode'];
|
|
}
|
|
}, {
|
|
key: "validate",
|
|
value: function validate(file) {
|
|
if (this.props.maxFileSize && file.size > this.props.maxFileSize) {
|
|
var message = {
|
|
severity: 'error',
|
|
summary: this.props.invalidFileSizeMessageSummary.replace('{0}', file.name),
|
|
detail: this.props.invalidFileSizeMessageDetail.replace('{0}', this.formatSize(this.props.maxFileSize))
|
|
};
|
|
|
|
if (this.props.mode === 'advanced') {
|
|
this.messagesUI.show(message);
|
|
}
|
|
|
|
if (this.props.onValidationFail) {
|
|
this.props.onValidationFail(file);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}, {
|
|
key: "upload",
|
|
value: function upload() {
|
|
var _this3 = this;
|
|
|
|
if (this.props.customUpload) {
|
|
if (this.props.fileLimit) {
|
|
this.uploadedFileCount += this.state.files.length;
|
|
}
|
|
|
|
if (this.props.uploadHandler) {
|
|
this.props.uploadHandler({
|
|
files: this.state.files,
|
|
options: {
|
|
clear: this.clear,
|
|
props: this.props
|
|
}
|
|
});
|
|
}
|
|
} else {
|
|
this.setState({
|
|
msgs: []
|
|
});
|
|
var xhr = new XMLHttpRequest();
|
|
var formData = new FormData();
|
|
|
|
if (this.props.onBeforeUpload) {
|
|
this.props.onBeforeUpload({
|
|
'xhr': xhr,
|
|
'formData': formData
|
|
});
|
|
}
|
|
|
|
var _iterator2 = _createForOfIteratorHelper$b(this.state.files),
|
|
_step2;
|
|
|
|
try {
|
|
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
|
|
var file = _step2.value;
|
|
formData.append(this.props.name, file, file.name);
|
|
}
|
|
} catch (err) {
|
|
_iterator2.e(err);
|
|
} finally {
|
|
_iterator2.f();
|
|
}
|
|
|
|
xhr.upload.addEventListener('progress', function (event) {
|
|
if (event.lengthComputable) {
|
|
_this3.setState({
|
|
progress: Math.round(event.loaded * 100 / event.total)
|
|
}, function () {
|
|
if (_this3.props.onProgress) {
|
|
_this3.props.onProgress({
|
|
originalEvent: event,
|
|
progress: _this3.state.progress
|
|
});
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
xhr.onreadystatechange = function () {
|
|
if (xhr.readyState === 4) {
|
|
_this3.setState({
|
|
progress: 0
|
|
});
|
|
|
|
if (xhr.status >= 200 && xhr.status < 300) {
|
|
if (_this3.props.fileLimit) {
|
|
_this3.uploadedFileCount += _this3.state.files.length;
|
|
}
|
|
|
|
if (_this3.props.onUpload) {
|
|
_this3.props.onUpload({
|
|
xhr: xhr,
|
|
files: _this3.state.files
|
|
});
|
|
}
|
|
} else {
|
|
if (_this3.props.onError) {
|
|
_this3.props.onError({
|
|
xhr: xhr,
|
|
files: _this3.state.files
|
|
});
|
|
}
|
|
}
|
|
|
|
_this3.clear();
|
|
}
|
|
};
|
|
|
|
xhr.open('POST', this.props.url, true);
|
|
|
|
if (this.props.onBeforeSend) {
|
|
this.props.onBeforeSend({
|
|
'xhr': xhr,
|
|
'formData': formData
|
|
});
|
|
}
|
|
|
|
xhr.withCredentials = this.props.withCredentials;
|
|
xhr.send(formData);
|
|
}
|
|
}
|
|
}, {
|
|
key: "clear",
|
|
value: function clear() {
|
|
this.setState({
|
|
files: []
|
|
});
|
|
|
|
if (this.props.onClear) {
|
|
this.props.onClear();
|
|
}
|
|
|
|
this.clearInputElement();
|
|
}
|
|
}, {
|
|
key: "choose",
|
|
value: function choose() {
|
|
this.fileInput.click();
|
|
}
|
|
}, {
|
|
key: "onFocus",
|
|
value: function onFocus() {
|
|
this.setState({
|
|
focused: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "onBlur",
|
|
value: function onBlur() {
|
|
this.setState({
|
|
focused: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event) {
|
|
if (event.which === 13) {
|
|
// enter
|
|
this.choose();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDragEnter",
|
|
value: function onDragEnter(event) {
|
|
if (!this.props.disabled) {
|
|
event.dataTransfer.dropEffect = "copy";
|
|
event.stopPropagation();
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDragOver",
|
|
value: function onDragOver(event) {
|
|
if (!this.props.disabled) {
|
|
event.dataTransfer.dropEffect = "copy";
|
|
DomHandler.addClass(this.content, 'p-fileupload-highlight');
|
|
event.stopPropagation();
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDragLeave",
|
|
value: function onDragLeave(event) {
|
|
if (!this.props.disabled) {
|
|
event.dataTransfer.dropEffect = "copy";
|
|
DomHandler.removeClass(this.content, 'p-fileupload-highlight');
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDrop",
|
|
value: function onDrop(event) {
|
|
if (!this.props.disabled) {
|
|
DomHandler.removeClass(this.content, 'p-fileupload-highlight');
|
|
event.stopPropagation();
|
|
event.preventDefault();
|
|
var files = event.dataTransfer ? event.dataTransfer.files : event.target.files;
|
|
var allowDrop = this.props.multiple || files && files.length === 0;
|
|
|
|
if (allowDrop) {
|
|
this.onFileSelect(event);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onSimpleUploaderClick",
|
|
value: function onSimpleUploaderClick() {
|
|
if (this.hasFiles()) {
|
|
this.upload();
|
|
} else {
|
|
this.fileInput.click();
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderChooseButton",
|
|
value: function renderChooseButton() {
|
|
var _this4 = this;
|
|
|
|
var _this$props$chooseOpt = this.props.chooseOptions,
|
|
className = _this$props$chooseOpt.className,
|
|
style = _this$props$chooseOpt.style,
|
|
icon = _this$props$chooseOpt.icon,
|
|
iconOnly = _this$props$chooseOpt.iconOnly;
|
|
var chooseClassName = classNames('p-button p-fileupload-choose p-component', {
|
|
'p-disabled': this.props.disabled,
|
|
'p-focus': this.state.focused,
|
|
'p-button-icon-only': iconOnly
|
|
}, className);
|
|
var labelClassName = 'p-button-label p-clickable';
|
|
var label = iconOnly ? /*#__PURE__*/React.createElement("span", {
|
|
className: labelClassName,
|
|
dangerouslySetInnerHTML: {
|
|
__html: " "
|
|
}
|
|
}) : /*#__PURE__*/React.createElement("span", {
|
|
className: labelClassName
|
|
}, this.chooseButtonLabel());
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: chooseClassName,
|
|
style: style,
|
|
onClick: this.choose,
|
|
onKeyDown: this.onKeyDown,
|
|
onFocus: this.onFocus,
|
|
onBlur: this.onBlur,
|
|
tabIndex: 0
|
|
}, /*#__PURE__*/React.createElement("input", {
|
|
ref: function ref(el) {
|
|
return _this4.fileInput = el;
|
|
},
|
|
type: "file",
|
|
onChange: this.onFileSelect,
|
|
multiple: this.props.multiple,
|
|
accept: this.props.accept,
|
|
disabled: this.chooseDisabled()
|
|
}), IconUtils.getJSXIcon(icon || 'pi pi-fw pi-plus', {
|
|
className: 'p-button-icon p-button-icon-left p-clickable'
|
|
}, {
|
|
props: this.props
|
|
}), label, /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
}, {
|
|
key: "renderFile",
|
|
value: function renderFile(file, index) {
|
|
var _this5 = this;
|
|
|
|
var preview = this.isImage(file) ? /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement("img", {
|
|
alt: file.name,
|
|
role: "presentation",
|
|
src: file.objectURL,
|
|
width: this.props.previewWidth
|
|
})) : null;
|
|
var fileName = /*#__PURE__*/React.createElement("div", {
|
|
className: "p-fileupload-filename"
|
|
}, file.name);
|
|
var size = /*#__PURE__*/React.createElement("div", null, this.formatSize(file.size));
|
|
var removeButton = /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(Button, {
|
|
type: "button",
|
|
icon: "pi pi-times",
|
|
onClick: function onClick(e) {
|
|
return _this5.remove(e, index);
|
|
}
|
|
}));
|
|
var content = /*#__PURE__*/React.createElement(React.Fragment, null, preview, fileName, size, removeButton);
|
|
|
|
if (this.props.itemTemplate) {
|
|
var defaultContentOptions = {
|
|
onRemove: function onRemove(event) {
|
|
return _this5.remove(event, index);
|
|
},
|
|
previewElement: preview,
|
|
fileNameElement: fileName,
|
|
sizeElement: size,
|
|
removeElement: removeButton,
|
|
formatSize: this.formatSize(file.size),
|
|
files: this.state.files,
|
|
index: index,
|
|
element: content,
|
|
props: this.props
|
|
};
|
|
content = ObjectUtils.getJSXElement(this.props.itemTemplate, file, defaultContentOptions);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-fileupload-row",
|
|
key: file.name + file.type + file.size
|
|
}, content);
|
|
}
|
|
}, {
|
|
key: "renderFiles",
|
|
value: function renderFiles() {
|
|
var _this6 = this;
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-fileupload-files"
|
|
}, this.state.files.map(function (file, index) {
|
|
return _this6.renderFile(file, index);
|
|
}));
|
|
}
|
|
}, {
|
|
key: "renderEmptyContent",
|
|
value: function renderEmptyContent() {
|
|
if (this.props.emptyTemplate && !this.hasFiles()) {
|
|
return ObjectUtils.getJSXElement(this.props.emptyTemplate, this.props);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderProgressBarContent",
|
|
value: function renderProgressBarContent() {
|
|
if (this.props.progressBarTemplate) {
|
|
return ObjectUtils.getJSXElement(this.props.progressBarTemplate, this.props);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement(ProgressBar, {
|
|
value: this.state.progress,
|
|
showValue: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderAdvanced",
|
|
value: function renderAdvanced() {
|
|
var _this7 = this;
|
|
|
|
var className = classNames('p-fileupload p-fileupload-advanced p-component', this.props.className);
|
|
var headerClassName = classNames('p-fileupload-buttonbar', this.props.headerClassName);
|
|
var contentClassName = classNames('p-fileupload-content', this.props.contentClassName);
|
|
var uploadButton, cancelButton, filesList, progressBar;
|
|
var chooseButton = this.renderChooseButton();
|
|
var emptyContent = this.renderEmptyContent();
|
|
|
|
if (!this.props.auto) {
|
|
var uploadOptions = this.props.uploadOptions;
|
|
var cancelOptions = this.props.cancelOptions;
|
|
var uploadLabel = !uploadOptions.iconOnly ? this.uploadButtonLabel() : '';
|
|
var cancelLabel = !cancelOptions.iconOnly ? this.cancelButtonLabel() : '';
|
|
uploadButton = /*#__PURE__*/React.createElement(Button, {
|
|
type: "button",
|
|
label: uploadLabel,
|
|
icon: uploadOptions.icon || 'pi pi-upload',
|
|
onClick: this.upload,
|
|
disabled: this.uploadDisabled(),
|
|
style: uploadOptions.style,
|
|
className: uploadOptions.className
|
|
});
|
|
cancelButton = /*#__PURE__*/React.createElement(Button, {
|
|
type: "button",
|
|
label: cancelLabel,
|
|
icon: cancelOptions.icon || 'pi pi-times',
|
|
onClick: this.clear,
|
|
disabled: this.cancelDisabled(),
|
|
style: cancelOptions.style,
|
|
className: cancelOptions.className
|
|
});
|
|
}
|
|
|
|
if (this.hasFiles()) {
|
|
filesList = this.renderFiles();
|
|
progressBar = this.renderProgressBarContent();
|
|
}
|
|
|
|
var header = /*#__PURE__*/React.createElement("div", {
|
|
className: headerClassName,
|
|
style: this.props.headerStyle
|
|
}, chooseButton, uploadButton, cancelButton);
|
|
|
|
if (this.props.headerTemplate) {
|
|
var defaultContentOptions = {
|
|
className: headerClassName,
|
|
chooseButton: chooseButton,
|
|
uploadButton: uploadButton,
|
|
cancelButton: cancelButton,
|
|
element: header,
|
|
props: this.props
|
|
};
|
|
header = ObjectUtils.getJSXElement(this.props.headerTemplate, defaultContentOptions);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, header, /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
_this7.content = el;
|
|
},
|
|
className: contentClassName,
|
|
style: this.props.contentStyle,
|
|
onDragEnter: this.onDragEnter,
|
|
onDragOver: this.onDragOver,
|
|
onDragLeave: this.onDragLeave,
|
|
onDrop: this.onDrop
|
|
}, progressBar, /*#__PURE__*/React.createElement(Messages, {
|
|
ref: function ref(el) {
|
|
return _this7.messagesUI = el;
|
|
}
|
|
}), filesList, emptyContent));
|
|
}
|
|
}, {
|
|
key: "renderBasic",
|
|
value: function renderBasic() {
|
|
var _this8 = this;
|
|
|
|
var hasFiles = this.hasFiles();
|
|
var chooseOptions = this.props.chooseOptions;
|
|
var className = classNames('p-fileupload p-fileupload-basic p-component', this.props.className);
|
|
var buttonClassName = classNames('p-button p-component p-fileupload-choose', {
|
|
'p-fileupload-choose-selected': hasFiles,
|
|
'p-disabled': this.props.disabled,
|
|
'p-focus': this.state.focused
|
|
}, chooseOptions.className);
|
|
var chooseIcon = chooseOptions.icon || classNames({
|
|
'pi pi-plus': !chooseOptions.icon && (!hasFiles || this.props.auto),
|
|
'pi pi-upload': !chooseOptions.icon && hasFiles && !this.props.auto
|
|
});
|
|
var labelClassName = 'p-button-label p-clickable';
|
|
var chooseLabel = chooseOptions.iconOnly ? /*#__PURE__*/React.createElement("span", {
|
|
className: labelClassName,
|
|
dangerouslySetInnerHTML: {
|
|
__html: " "
|
|
}
|
|
}) : /*#__PURE__*/React.createElement("span", {
|
|
className: labelClassName
|
|
}, this.chooseButtonLabel());
|
|
var label = this.props.auto ? chooseLabel : /*#__PURE__*/React.createElement("span", {
|
|
className: labelClassName
|
|
}, hasFiles ? this.state.files[0].name : chooseLabel);
|
|
var icon = IconUtils.getJSXIcon(chooseIcon, {
|
|
className: 'p-button-icon p-button-icon-left'
|
|
}, {
|
|
props: this.props,
|
|
hasFiles: hasFiles
|
|
});
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: className,
|
|
style: this.props.style
|
|
}, /*#__PURE__*/React.createElement(Messages, {
|
|
ref: function ref(el) {
|
|
return _this8.messagesUI = el;
|
|
}
|
|
}), /*#__PURE__*/React.createElement("span", {
|
|
className: buttonClassName,
|
|
style: chooseOptions.style,
|
|
onMouseUp: this.onSimpleUploaderClick,
|
|
onKeyDown: this.onKeyDown,
|
|
onFocus: this.onFocus,
|
|
onBlur: this.onBlur,
|
|
tabIndex: 0
|
|
}, icon, label, !hasFiles && /*#__PURE__*/React.createElement("input", {
|
|
ref: function ref(el) {
|
|
return _this8.fileInput = el;
|
|
},
|
|
type: "file",
|
|
accept: this.props.accept,
|
|
multiple: this.props.multiple,
|
|
disabled: this.props.disabled,
|
|
onChange: this.onFileSelect
|
|
}), /*#__PURE__*/React.createElement(Ripple, null)));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
if (this.props.mode === 'advanced') return this.renderAdvanced();else if (this.props.mode === 'basic') return this.renderBasic();
|
|
}
|
|
}]);
|
|
|
|
return FileUpload;
|
|
}(Component);
|
|
|
|
_defineProperty(FileUpload, "defaultProps", {
|
|
id: null,
|
|
name: null,
|
|
url: null,
|
|
mode: 'advanced',
|
|
multiple: false,
|
|
accept: null,
|
|
disabled: false,
|
|
auto: false,
|
|
maxFileSize: null,
|
|
invalidFileSizeMessageSummary: '{0}: Invalid file size, ',
|
|
invalidFileSizeMessageDetail: 'maximum upload size is {0}.',
|
|
style: null,
|
|
className: null,
|
|
widthCredentials: false,
|
|
previewWidth: 50,
|
|
chooseLabel: null,
|
|
uploadLabel: null,
|
|
cancelLabel: null,
|
|
chooseOptions: {
|
|
label: null,
|
|
icon: null,
|
|
iconOnly: false,
|
|
className: null,
|
|
style: null
|
|
},
|
|
uploadOptions: {
|
|
label: null,
|
|
icon: null,
|
|
iconOnly: false,
|
|
className: null,
|
|
style: null
|
|
},
|
|
cancelOptions: {
|
|
label: null,
|
|
icon: null,
|
|
iconOnly: false,
|
|
className: null,
|
|
style: null
|
|
},
|
|
customUpload: false,
|
|
headerClassName: null,
|
|
headerStyle: null,
|
|
contentClassName: null,
|
|
contentStyle: null,
|
|
headerTemplate: null,
|
|
itemTemplate: null,
|
|
emptyTemplate: null,
|
|
progressBarTemplate: null,
|
|
onBeforeUpload: null,
|
|
onBeforeSend: null,
|
|
onUpload: null,
|
|
onError: null,
|
|
onClear: null,
|
|
onSelect: null,
|
|
onProgress: null,
|
|
onValidationFail: null,
|
|
uploadHandler: null,
|
|
onRemove: null
|
|
});
|
|
|
|
function _createSuper$1g(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1g(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1g() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var FullCalendar = /*#__PURE__*/function (_Component) {
|
|
_inherits(FullCalendar, _Component);
|
|
|
|
var _super = _createSuper$1g(FullCalendar);
|
|
|
|
function FullCalendar() {
|
|
_classCallCheck(this, FullCalendar);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(FullCalendar, [{
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
console.warn("FullCalendar component is deprecated. Use FullCalendar component of '@fullcalendar/react' package.");
|
|
this.config = {
|
|
theme: true
|
|
};
|
|
|
|
if (this.props.options) {
|
|
for (var prop in this.props.options) {
|
|
this.config[prop] = this.props.options[prop];
|
|
}
|
|
}
|
|
|
|
this.initialize();
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (!this.calendar) {
|
|
this.initialize();
|
|
} else {
|
|
if (!ObjectUtils.equals(prevProps.events, this.props.events)) {
|
|
this.calendar.removeAllEventSources();
|
|
this.calendar.addEventSource(this.props.events);
|
|
}
|
|
|
|
if (!ObjectUtils.equals(prevProps.options, this.props.options)) {
|
|
for (var prop in this.props.options) {
|
|
var optionValue = this.props.options[prop];
|
|
this.config[prop] = optionValue;
|
|
this.calendar.setOption(prop, optionValue);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "initialize",
|
|
value: function initialize() {
|
|
var _this = this;
|
|
|
|
import('@fullcalendar/core').then(function (module) {
|
|
if (module && module.Calendar) {
|
|
_this.calendar = new module.Calendar(_this.element, _this.config);
|
|
|
|
_this.calendar.render();
|
|
|
|
if (_this.props.events) {
|
|
_this.calendar.removeAllEventSources();
|
|
|
|
_this.calendar.addEventSource(_this.props.events);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.calendar) {
|
|
this.calendar.destroy();
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this2 = this;
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
ref: function ref(el) {
|
|
return _this2.element = el;
|
|
},
|
|
style: this.props.style,
|
|
className: this.props.className
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return FullCalendar;
|
|
}(Component);
|
|
|
|
_defineProperty(FullCalendar, "defaultProps", {
|
|
id: null,
|
|
events: [],
|
|
style: null,
|
|
className: null,
|
|
options: null
|
|
});
|
|
|
|
function _createSuper$1f(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1f(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1f() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
var GalleriaItemComponent = /*#__PURE__*/function (_Component) {
|
|
_inherits(GalleriaItemComponent, _Component);
|
|
|
|
var _super = _createSuper$1f(GalleriaItemComponent);
|
|
|
|
function GalleriaItemComponent(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, GalleriaItemComponent);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.navForward = _this.navForward.bind(_assertThisInitialized(_this));
|
|
_this.navBackward = _this.navBackward.bind(_assertThisInitialized(_this));
|
|
_this.next = _this.next.bind(_assertThisInitialized(_this));
|
|
_this.prev = _this.prev.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(GalleriaItemComponent, [{
|
|
key: "step",
|
|
value: function step(index) {
|
|
if (this.itemsContainer) {
|
|
this.itemsContainer.style.transform = this.isVertical() ? "translate3d(0, ".concat(index * 100, "%, 0)") : "translate3d(".concat(index * 100, "%, 0, 0)");
|
|
this.itemsContainer.style.transition = 'transform 500ms ease 0s';
|
|
}
|
|
}
|
|
}, {
|
|
key: "next",
|
|
value: function next() {
|
|
var nextItemIndex = this.props.activeItemIndex + 1;
|
|
this.props.onActiveItemChange({
|
|
index: this.props.circular && this.props.value.length - 1 === this.props.activeItemIndex ? 0 : nextItemIndex
|
|
});
|
|
}
|
|
}, {
|
|
key: "prev",
|
|
value: function prev() {
|
|
var prevItemIndex = this.props.activeItemIndex !== 0 ? this.props.activeItemIndex - 1 : 0;
|
|
this.props.onActiveItemChange({
|
|
index: this.props.circular && this.props.activeItemIndex === 0 ? this.props.value.length - 1 : prevItemIndex
|
|
});
|
|
}
|
|
}, {
|
|
key: "stopSlideShow",
|
|
value: function stopSlideShow() {
|
|
if (this.props.slideShowActive && this.props.stopSlideShow) {
|
|
this.props.stopSlideShow();
|
|
}
|
|
}
|
|
}, {
|
|
key: "navBackward",
|
|
value: function navBackward(e) {
|
|
this.stopSlideShow();
|
|
this.prev();
|
|
|
|
if (e && e.cancelable) {
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "navForward",
|
|
value: function navForward(e) {
|
|
this.stopSlideShow();
|
|
this.next();
|
|
|
|
if (e && e.cancelable) {
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onIndicatorClick",
|
|
value: function onIndicatorClick(index) {
|
|
this.stopSlideShow();
|
|
this.props.onActiveItemChange({
|
|
index: index
|
|
});
|
|
}
|
|
}, {
|
|
key: "onIndicatorMouseEnter",
|
|
value: function onIndicatorMouseEnter(index) {
|
|
if (this.props.changeItemOnIndicatorHover) {
|
|
this.stopSlideShow();
|
|
this.props.onActiveItemChange({
|
|
index: index
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onIndicatorKeyDown",
|
|
value: function onIndicatorKeyDown(event, index) {
|
|
if (event.which === 13) {
|
|
this.stopSlideShow();
|
|
this.props.onActiveItemChange({
|
|
index: index
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (this.props.autoPlay) {
|
|
this.props.startSlideShow();
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderBackwardNavigator",
|
|
value: function renderBackwardNavigator() {
|
|
if (this.props.showItemNavigators) {
|
|
var isDisabled = !this.props.circular && this.props.activeItemIndex === 0;
|
|
var buttonClassName = classNames('p-galleria-item-prev p-galleria-item-nav p-link', {
|
|
'p-disabled': isDisabled
|
|
});
|
|
return /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: buttonClassName,
|
|
onClick: this.navBackward,
|
|
disabled: isDisabled
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-galleria-item-prev-icon pi pi-chevron-left"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderForwardNavigator",
|
|
value: function renderForwardNavigator() {
|
|
if (this.props.showItemNavigators) {
|
|
var isDisabled = !this.props.circular && this.props.activeItemIndex === this.props.value.length - 1;
|
|
var buttonClassName = classNames('p-galleria-item-next p-galleria-item-nav p-link', {
|
|
'p-disabled': isDisabled
|
|
});
|
|
return /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: buttonClassName,
|
|
onClick: this.navForward,
|
|
disabled: isDisabled
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-galleria-item-next-icon pi pi-chevron-right"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderCaption",
|
|
value: function renderCaption() {
|
|
if (this.props.caption) {
|
|
var content = this.props.caption(this.props.value[this.props.activeItemIndex]);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-galleria-caption"
|
|
}, content);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderIndicator",
|
|
value: function renderIndicator(index) {
|
|
var _this2 = this;
|
|
|
|
var indicator = this.props.indicator && this.props.indicator(index);
|
|
var isActive = this.props.activeItemIndex === index;
|
|
var indicatorItemClassName = classNames('p-galleria-indicator', {
|
|
'p-highlight': isActive
|
|
});
|
|
|
|
if (!indicator) {
|
|
indicator = /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
tabIndex: -1,
|
|
className: "p-link"
|
|
}, /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
className: indicatorItemClassName,
|
|
key: 'p-galleria-indicator-' + index,
|
|
tabIndex: 0,
|
|
onClick: function onClick() {
|
|
return _this2.onIndicatorClick(index);
|
|
},
|
|
onMouseEnter: function onMouseEnter() {
|
|
return _this2.onIndicatorMouseEnter(index);
|
|
},
|
|
onKeyDown: function onKeyDown(e) {
|
|
return _this2.onIndicatorKeyDown(e, index);
|
|
}
|
|
}, indicator);
|
|
}
|
|
}, {
|
|
key: "renderIndicators",
|
|
value: function renderIndicators() {
|
|
if (this.props.showIndicators) {
|
|
var indicatorsContentClassName = classNames('p-galleria-indicators p-reset', this.props.indicatorsContentClassName);
|
|
var indicators = [];
|
|
|
|
for (var i = 0; i < this.props.value.length; i++) {
|
|
indicators.push(this.renderIndicator(i));
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
className: indicatorsContentClassName
|
|
}, indicators);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this3 = this;
|
|
|
|
var content = this.props.itemTemplate && this.props.itemTemplate(this.props.value[this.props.activeItemIndex]);
|
|
var backwardNavigator = this.renderBackwardNavigator();
|
|
var forwardNavigator = this.renderForwardNavigator();
|
|
var caption = this.renderCaption();
|
|
var indicators = this.renderIndicators();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this3.props.forwardRef(el);
|
|
},
|
|
className: "p-galleria-item-wrapper"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-galleria-item-container"
|
|
}, backwardNavigator, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-galleria-item"
|
|
}, content), forwardNavigator, caption), indicators);
|
|
}
|
|
}]);
|
|
|
|
return GalleriaItemComponent;
|
|
}(Component);
|
|
|
|
var GalleriaItem = /*#__PURE__*/React.forwardRef(function (props, ref) {
|
|
return /*#__PURE__*/React.createElement(GalleriaItemComponent, _extends({
|
|
forwardRef: ref
|
|
}, props));
|
|
});
|
|
|
|
function _createSuper$1e(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1e(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1e() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
var GalleriaThumbnailItem = /*#__PURE__*/function (_Component) {
|
|
_inherits(GalleriaThumbnailItem, _Component);
|
|
|
|
var _super = _createSuper$1e(GalleriaThumbnailItem);
|
|
|
|
function GalleriaThumbnailItem(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, GalleriaThumbnailItem);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onItemClick = _this.onItemClick.bind(_assertThisInitialized(_this));
|
|
_this.onItemKeyDown = _this.onItemKeyDown.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(GalleriaThumbnailItem, [{
|
|
key: "onItemClick",
|
|
value: function onItemClick(event) {
|
|
this.props.onItemClick({
|
|
originalEvent: event,
|
|
index: this.props.index
|
|
});
|
|
}
|
|
}, {
|
|
key: "onItemKeyDown",
|
|
value: function onItemKeyDown(event) {
|
|
if (event.which === 13) {
|
|
this.props.onItemClick({
|
|
originalEvent: event,
|
|
index: this.props.index
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var content = this.props.template && this.props.template(this.props.item);
|
|
var itemClassName = classNames(this.props.className, 'p-galleria-thumbnail-item', {
|
|
'p-galleria-thumbnail-item-current': this.props.current,
|
|
'p-galleria-thumbnail-item-active': this.props.active,
|
|
'p-galleria-thumbnail-item-start': this.props.start,
|
|
'p-galleria-thumbnail-item-end': this.props.end
|
|
});
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: itemClassName
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-galleria-thumbnail-item-content",
|
|
tabIndex: this.props.active ? 0 : null,
|
|
onClick: this.onItemClick,
|
|
onKeyDown: this.onItemKeyDown
|
|
}, content));
|
|
}
|
|
}]);
|
|
|
|
return GalleriaThumbnailItem;
|
|
}(Component);
|
|
|
|
_defineProperty(GalleriaThumbnailItem, "defaultProps", {
|
|
index: null,
|
|
template: null,
|
|
item: null,
|
|
current: false,
|
|
active: false,
|
|
start: false,
|
|
end: false,
|
|
className: null,
|
|
onItemClick: null
|
|
});
|
|
|
|
var GalleriaThumbnails = /*#__PURE__*/function (_Component2) {
|
|
_inherits(GalleriaThumbnails, _Component2);
|
|
|
|
var _super2 = _createSuper$1e(GalleriaThumbnails);
|
|
|
|
function GalleriaThumbnails(props) {
|
|
var _this2;
|
|
|
|
_classCallCheck(this, GalleriaThumbnails);
|
|
|
|
_this2 = _super2.call(this, props);
|
|
_this2.state = {
|
|
numVisible: props.numVisible,
|
|
totalShiftedItems: 0,
|
|
page: 0
|
|
};
|
|
_this2.navForward = _this2.navForward.bind(_assertThisInitialized(_this2));
|
|
_this2.navBackward = _this2.navBackward.bind(_assertThisInitialized(_this2));
|
|
_this2.onTransitionEnd = _this2.onTransitionEnd.bind(_assertThisInitialized(_this2));
|
|
_this2.onTouchStart = _this2.onTouchStart.bind(_assertThisInitialized(_this2));
|
|
_this2.onTouchMove = _this2.onTouchMove.bind(_assertThisInitialized(_this2));
|
|
_this2.onTouchEnd = _this2.onTouchEnd.bind(_assertThisInitialized(_this2));
|
|
_this2.onItemClick = _this2.onItemClick.bind(_assertThisInitialized(_this2));
|
|
_this2.attributeSelector = UniqueComponentId();
|
|
return _this2;
|
|
}
|
|
|
|
_createClass(GalleriaThumbnails, [{
|
|
key: "step",
|
|
value: function step(dir) {
|
|
var totalShiftedItems = this.state.totalShiftedItems + dir;
|
|
|
|
if (dir < 0 && -1 * totalShiftedItems + this.state.numVisible > this.props.value.length - 1) {
|
|
totalShiftedItems = this.state.numVisible - this.props.value.length;
|
|
} else if (dir > 0 && totalShiftedItems > 0) {
|
|
totalShiftedItems = 0;
|
|
}
|
|
|
|
if (this.props.circular) {
|
|
if (dir < 0 && this.props.value.length - 1 === this.props.activeItemIndex) {
|
|
totalShiftedItems = 0;
|
|
} else if (dir > 0 && this.props.activeItemIndex === 0) {
|
|
totalShiftedItems = this.state.numVisible - this.props.value.length;
|
|
}
|
|
}
|
|
|
|
if (this.itemsContainer) {
|
|
DomHandler.removeClass(this.itemsContainer, 'p-items-hidden');
|
|
this.itemsContainer.style.transform = this.props.isVertical ? "translate3d(0, ".concat(totalShiftedItems * (100 / this.state.numVisible), "%, 0)") : "translate3d(".concat(totalShiftedItems * (100 / this.state.numVisible), "%, 0, 0)");
|
|
this.itemsContainer.style.transition = 'transform 500ms ease 0s';
|
|
}
|
|
|
|
this.setState({
|
|
totalShiftedItems: totalShiftedItems
|
|
});
|
|
}
|
|
}, {
|
|
key: "stopSlideShow",
|
|
value: function stopSlideShow() {
|
|
if (this.props.slideShowActive && this.props.stopSlideShow) {
|
|
this.props.stopSlideShow();
|
|
}
|
|
}
|
|
}, {
|
|
key: "getMedianItemIndex",
|
|
value: function getMedianItemIndex() {
|
|
var index = Math.floor(this.state.numVisible / 2);
|
|
return this.state.numVisible % 2 ? index : index - 1;
|
|
}
|
|
}, {
|
|
key: "navBackward",
|
|
value: function navBackward(e) {
|
|
this.stopSlideShow();
|
|
var prevItemIndex = this.props.activeItemIndex !== 0 ? this.props.activeItemIndex - 1 : 0;
|
|
var diff = prevItemIndex + this.state.totalShiftedItems;
|
|
|
|
if (this.state.numVisible - diff - 1 > this.getMedianItemIndex() && (-1 * this.state.totalShiftedItems !== 0 || this.props.circular)) {
|
|
this.step(1);
|
|
}
|
|
|
|
this.props.onActiveItemChange({
|
|
index: this.props.circular && this.props.activeItemIndex === 0 ? this.props.value.length - 1 : prevItemIndex
|
|
});
|
|
|
|
if (e.cancelable) {
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "navForward",
|
|
value: function navForward(e) {
|
|
this.stopSlideShow();
|
|
var nextItemIndex = this.props.activeItemIndex + 1;
|
|
|
|
if (nextItemIndex + this.state.totalShiftedItems > this.getMedianItemIndex() && (-1 * this.state.totalShiftedItems < this.getTotalPageNumber() - 1 || this.props.circular)) {
|
|
this.step(-1);
|
|
}
|
|
|
|
this.props.onActiveItemChange({
|
|
index: this.props.circular && this.props.value.length - 1 === this.props.activeItemIndex ? 0 : nextItemIndex
|
|
});
|
|
|
|
if (e.cancelable) {
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onItemClick",
|
|
value: function onItemClick(event) {
|
|
this.stopSlideShow();
|
|
var selectedItemIndex = event.index;
|
|
|
|
if (selectedItemIndex !== this.props.activeItemIndex) {
|
|
var diff = selectedItemIndex + this.state.totalShiftedItems;
|
|
var dir = 0;
|
|
|
|
if (selectedItemIndex < this.props.activeItemIndex) {
|
|
dir = this.state.numVisible - diff - 1 - this.getMedianItemIndex();
|
|
|
|
if (dir > 0 && -1 * this.state.totalShiftedItems !== 0) {
|
|
this.step(dir);
|
|
}
|
|
} else {
|
|
dir = this.getMedianItemIndex() - diff;
|
|
|
|
if (dir < 0 && -1 * this.state.totalShiftedItems < this.getTotalPageNumber() - 1) {
|
|
this.step(dir);
|
|
}
|
|
}
|
|
|
|
this.props.onActiveItemChange({
|
|
index: selectedItemIndex
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onTransitionEnd",
|
|
value: function onTransitionEnd(e) {
|
|
if (this.itemsContainer && e.propertyName === 'transform') {
|
|
DomHandler.addClass(this.itemsContainer, 'p-items-hidden');
|
|
this.itemsContainer.style.transition = '';
|
|
}
|
|
}
|
|
}, {
|
|
key: "onTouchStart",
|
|
value: function onTouchStart(e) {
|
|
var touchobj = e.changedTouches[0];
|
|
this.startPos = {
|
|
x: touchobj.pageX,
|
|
y: touchobj.pageY
|
|
};
|
|
}
|
|
}, {
|
|
key: "onTouchMove",
|
|
value: function onTouchMove(e) {
|
|
if (e.cancelable) {
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onTouchEnd",
|
|
value: function onTouchEnd(e) {
|
|
var touchobj = e.changedTouches[0];
|
|
|
|
if (this.props.isVertical) {
|
|
this.changePageOnTouch(e, touchobj.pageY - this.startPos.y);
|
|
} else {
|
|
this.changePageOnTouch(e, touchobj.pageX - this.startPos.x);
|
|
}
|
|
}
|
|
}, {
|
|
key: "changePageOnTouch",
|
|
value: function changePageOnTouch(e, diff) {
|
|
if (diff < 0) {
|
|
// left
|
|
this.navForward(e);
|
|
} else {
|
|
// right
|
|
this.navBackward(e);
|
|
}
|
|
}
|
|
}, {
|
|
key: "getTotalPageNumber",
|
|
value: function getTotalPageNumber() {
|
|
return this.props.value.length > this.state.numVisible ? this.props.value.length - this.state.numVisible + 1 : 0;
|
|
}
|
|
}, {
|
|
key: "createStyle",
|
|
value: function createStyle() {
|
|
if (!this.thumbnailsStyle) {
|
|
this.thumbnailsStyle = DomHandler.createInlineStyle(PrimeReact.nonce);
|
|
}
|
|
|
|
var innerHTML = "\n .p-galleria-thumbnail-items[".concat(this.attributeSelector, "] .p-galleria-thumbnail-item {\n flex: 1 0 ").concat(100 / this.state.numVisible, "%\n }\n ");
|
|
|
|
if (this.props.responsiveOptions) {
|
|
this.responsiveOptions = _toConsumableArray(this.props.responsiveOptions);
|
|
this.responsiveOptions.sort(function (data1, data2) {
|
|
var value1 = data1.breakpoint;
|
|
var value2 = data2.breakpoint;
|
|
var result = null;
|
|
if (value1 == null && value2 != null) result = -1;else if (value1 != null && value2 == null) result = 1;else if (value1 == null && value2 == null) result = 0;else if (typeof value1 === 'string' && typeof value2 === 'string') result = value1.localeCompare(value2, undefined, {
|
|
numeric: true
|
|
});else result = value1 < value2 ? -1 : value1 > value2 ? 1 : 0;
|
|
return -1 * result;
|
|
});
|
|
|
|
for (var i = 0; i < this.responsiveOptions.length; i++) {
|
|
var res = this.responsiveOptions[i];
|
|
innerHTML += "\n @media screen and (max-width: ".concat(res.breakpoint, ") {\n .p-galleria-thumbnail-items[").concat(this.attributeSelector, "] .p-galleria-thumbnail-item {\n flex: 1 0 ").concat(100 / res.numVisible, "%\n }\n }\n ");
|
|
}
|
|
}
|
|
|
|
this.thumbnailsStyle.innerHTML = innerHTML;
|
|
}
|
|
}, {
|
|
key: "calculatePosition",
|
|
value: function calculatePosition() {
|
|
if (this.itemsContainer && this.responsiveOptions) {
|
|
var windowWidth = window.innerWidth;
|
|
var matchedResponsiveData = {
|
|
numVisible: this.props.numVisible
|
|
};
|
|
|
|
for (var i = 0; i < this.responsiveOptions.length; i++) {
|
|
var res = this.responsiveOptions[i];
|
|
|
|
if (parseInt(res.breakpoint, 10) >= windowWidth) {
|
|
matchedResponsiveData = res;
|
|
}
|
|
}
|
|
|
|
if (this.state.numVisible !== matchedResponsiveData.numVisible) {
|
|
this.setState({
|
|
numVisible: matchedResponsiveData.numVisible
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindDocumentListeners",
|
|
value: function bindDocumentListeners() {
|
|
var _this3 = this;
|
|
|
|
if (!this.documentResizeListener) {
|
|
this.documentResizeListener = function () {
|
|
_this3.calculatePosition();
|
|
};
|
|
|
|
window.addEventListener('resize', this.documentResizeListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentListeners",
|
|
value: function unbindDocumentListeners() {
|
|
if (this.documentResizeListener) {
|
|
window.removeEventListener('resize', this.documentResizeListener);
|
|
this.documentResizeListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (this.itemsContainer) {
|
|
this.itemsContainer.setAttribute(this.attributeSelector, '');
|
|
}
|
|
|
|
this.createStyle();
|
|
this.calculatePosition();
|
|
|
|
if (this.props.responsiveOptions) {
|
|
this.bindDocumentListeners();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps, prevState) {
|
|
var totalShiftedItems = this.state.totalShiftedItems;
|
|
|
|
if (prevState.numVisible !== this.state.numVisible || prevProps.activeItemIndex !== this.props.activeItemIndex) {
|
|
if (this.props.activeItemIndex <= this.getMedianItemIndex()) {
|
|
totalShiftedItems = 0;
|
|
} else if (this.props.value.length - this.state.numVisible + this.getMedianItemIndex() < this.props.activeItemIndex) {
|
|
totalShiftedItems = this.state.numVisible - this.props.value.length;
|
|
} else if (this.props.value.length - this.state.numVisible < this.props.activeItemIndex && this.state.numVisible % 2 === 0) {
|
|
totalShiftedItems = this.props.activeItemIndex * -1 + this.getMedianItemIndex() + 1;
|
|
} else {
|
|
totalShiftedItems = this.props.activeItemIndex * -1 + this.getMedianItemIndex();
|
|
}
|
|
|
|
if (totalShiftedItems !== this.state.totalShiftedItems) {
|
|
this.setState({
|
|
totalShiftedItems: totalShiftedItems
|
|
});
|
|
}
|
|
|
|
this.itemsContainer.style.transform = this.props.isVertical ? "translate3d(0, ".concat(totalShiftedItems * (100 / this.state.numVisible), "%, 0)") : "translate3d(".concat(totalShiftedItems * (100 / this.state.numVisible), "%, 0, 0)");
|
|
|
|
if (prevProps.activeItemIndex !== this.props.activeItemIndex) {
|
|
DomHandler.removeClass(this.itemsContainer, 'p-items-hidden');
|
|
this.itemsContainer.style.transition = 'transform 500ms ease 0s';
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.props.responsiveOptions) {
|
|
this.unbindDocumentListeners();
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderItems",
|
|
value: function renderItems() {
|
|
var _this4 = this;
|
|
|
|
return this.props.value.map(function (item, index) {
|
|
var firstIndex = _this4.state.totalShiftedItems * -1,
|
|
lastIndex = firstIndex + _this4.state.numVisible - 1,
|
|
isActive = firstIndex <= index && lastIndex >= index,
|
|
start = firstIndex === index,
|
|
end = lastIndex === index,
|
|
current = _this4.props.activeItemIndex === index;
|
|
return /*#__PURE__*/React.createElement(GalleriaThumbnailItem, {
|
|
key: index,
|
|
index: index,
|
|
template: _this4.props.itemTemplate,
|
|
item: item,
|
|
active: isActive,
|
|
start: start,
|
|
end: end,
|
|
onItemClick: _this4.onItemClick,
|
|
current: current
|
|
});
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderBackwardNavigator",
|
|
value: function renderBackwardNavigator() {
|
|
if (this.props.showThumbnailNavigators) {
|
|
var isDisabled = !this.props.circular && this.props.activeItemIndex === 0 || this.props.value.length <= this.state.numVisible;
|
|
var buttonClassName = classNames('p-galleria-thumbnail-prev p-link', {
|
|
'p-disabled': isDisabled
|
|
}),
|
|
iconClassName = classNames('p-galleria-thumbnail-prev-icon pi', {
|
|
'pi-chevron-left': !this.props.isVertical,
|
|
'pi-chevron-up': this.props.isVertical
|
|
});
|
|
return /*#__PURE__*/React.createElement("button", {
|
|
className: buttonClassName,
|
|
onClick: this.navBackward,
|
|
disabled: isDisabled
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderForwardNavigator",
|
|
value: function renderForwardNavigator() {
|
|
if (this.props.showThumbnailNavigators) {
|
|
var isDisabled = !this.props.circular && this.props.activeItemIndex === this.props.value.length - 1 || this.props.value.length <= this.state.numVisible;
|
|
var buttonClassName = classNames('p-galleria-thumbnail-next p-link', {
|
|
'p-disabled': isDisabled
|
|
}),
|
|
iconClassName = classNames('p-galleria-thumbnail-next-icon pi', {
|
|
'pi-chevron-right': !this.props.isVertical,
|
|
'pi-chevron-down': this.props.isVertical
|
|
});
|
|
return /*#__PURE__*/React.createElement("button", {
|
|
className: buttonClassName,
|
|
onClick: this.navForward,
|
|
disabled: isDisabled
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
var _this5 = this;
|
|
|
|
var items = this.renderItems();
|
|
var height = this.props.isVertical ? this.props.contentHeight : '';
|
|
var backwardNavigator = this.renderBackwardNavigator();
|
|
var forwardNavigator = this.renderForwardNavigator();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-galleria-thumbnail-container"
|
|
}, backwardNavigator, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-galleria-thumbnail-items-container",
|
|
style: {
|
|
'height': height
|
|
}
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this5.itemsContainer = el;
|
|
},
|
|
className: "p-galleria-thumbnail-items",
|
|
onTransitionEnd: this.onTransitionEnd,
|
|
onTouchStart: this.onTouchStart,
|
|
onTouchMove: this.onTouchMove,
|
|
onTouchEnd: this.onTouchEnd
|
|
}, items)), forwardNavigator);
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var content = this.renderContent();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-galleria-thumbnail-wrapper"
|
|
}, content);
|
|
}
|
|
}]);
|
|
|
|
return GalleriaThumbnails;
|
|
}(Component);
|
|
|
|
function ownKeys$p(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$p(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$p(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$p(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$1d(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1d(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1d() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Galleria = /*#__PURE__*/function (_Component) {
|
|
_inherits(Galleria, _Component);
|
|
|
|
var _super = _createSuper$1d(Galleria);
|
|
|
|
function Galleria(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Galleria);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
visible: false,
|
|
numVisible: props.numVisible,
|
|
slideShowActive: false
|
|
};
|
|
|
|
if (!_this.props.onItemChange) {
|
|
_this.state = _objectSpread$p(_objectSpread$p({}, _this.state), {}, {
|
|
activeIndex: props.activeIndex
|
|
});
|
|
}
|
|
|
|
_this.onActiveItemChange = _this.onActiveItemChange.bind(_assertThisInitialized(_this));
|
|
_this.show = _this.show.bind(_assertThisInitialized(_this));
|
|
_this.hide = _this.hide.bind(_assertThisInitialized(_this));
|
|
_this.startSlideShow = _this.startSlideShow.bind(_assertThisInitialized(_this));
|
|
_this.stopSlideShow = _this.stopSlideShow.bind(_assertThisInitialized(_this));
|
|
_this.onEnter = _this.onEnter.bind(_assertThisInitialized(_this));
|
|
_this.onEntering = _this.onEntering.bind(_assertThisInitialized(_this));
|
|
_this.onEntered = _this.onEntered.bind(_assertThisInitialized(_this));
|
|
_this.onExit = _this.onExit.bind(_assertThisInitialized(_this));
|
|
_this.onExited = _this.onExited.bind(_assertThisInitialized(_this));
|
|
_this.galleriaRef = /*#__PURE__*/React.createRef();
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Galleria, [{
|
|
key: "activeItemIndex",
|
|
get: function get() {
|
|
return this.props.onItemChange ? this.props.activeIndex : this.state.activeIndex;
|
|
}
|
|
}, {
|
|
key: "onActiveItemChange",
|
|
value: function onActiveItemChange(event) {
|
|
if (this.props.onItemChange) {
|
|
this.props.onItemChange(event);
|
|
} else {
|
|
this.setState({
|
|
activeIndex: event.index
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "show",
|
|
value: function show() {
|
|
this.setState({
|
|
visible: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "hide",
|
|
value: function hide() {
|
|
this.setState({
|
|
visible: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "onEnter",
|
|
value: function onEnter() {
|
|
DomHandler.addClass(document.body, 'p-overflow-hidden');
|
|
}
|
|
}, {
|
|
key: "onEntering",
|
|
value: function onEntering() {
|
|
ZIndexUtils.set('modal', this.mask, PrimeReact.autoZIndex, this.props.baseZIndex || PrimeReact.zIndex['modal']);
|
|
DomHandler.addMultipleClasses(this.mask, 'p-component-overlay p-component-overlay-enter');
|
|
}
|
|
}, {
|
|
key: "onEntered",
|
|
value: function onEntered() {
|
|
this.props.onShow && this.props.onShow();
|
|
}
|
|
}, {
|
|
key: "onExit",
|
|
value: function onExit() {
|
|
DomHandler.removeClass(document.body, 'p-overflow-hidden');
|
|
DomHandler.addClass(this.mask, 'p-component-overlay-leave');
|
|
}
|
|
}, {
|
|
key: "onExited",
|
|
value: function onExited() {
|
|
ZIndexUtils.clear(this.mask);
|
|
this.props.onHide && this.props.onHide();
|
|
}
|
|
}, {
|
|
key: "isAutoPlayActive",
|
|
value: function isAutoPlayActive() {
|
|
return this.state.slideShowActive;
|
|
}
|
|
}, {
|
|
key: "startSlideShow",
|
|
value: function startSlideShow() {
|
|
var _this2 = this;
|
|
|
|
this.interval = setInterval(function () {
|
|
var activeIndex = _this2.props.circular && _this2.props.value.length - 1 === _this2.activeItemIndex ? 0 : _this2.activeItemIndex + 1;
|
|
|
|
_this2.onActiveItemChange({
|
|
index: activeIndex
|
|
});
|
|
}, this.props.transitionInterval);
|
|
this.setState({
|
|
slideShowActive: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "stopSlideShow",
|
|
value: function stopSlideShow() {
|
|
if (this.interval) {
|
|
clearInterval(this.interval);
|
|
}
|
|
|
|
this.setState({
|
|
slideShowActive: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "getPositionClassName",
|
|
value: function getPositionClassName(preClassName, position) {
|
|
var positions = ['top', 'left', 'bottom', 'right'];
|
|
var pos = positions.find(function (item) {
|
|
return item === position;
|
|
});
|
|
return pos ? "".concat(preClassName, "-").concat(pos) : '';
|
|
}
|
|
}, {
|
|
key: "isVertical",
|
|
value: function isVertical() {
|
|
return this.props.thumbnailsPosition === 'left' || this.props.thumbnailsPosition === 'right';
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps, prevState) {
|
|
if (prevProps.value !== this.props.value) {
|
|
if (this.props.value && this.props.value.length < this.state.numVisible) {
|
|
this.setState({
|
|
numVisible: this.props.value.length
|
|
});
|
|
}
|
|
}
|
|
|
|
if (prevProps.numVisible !== this.props.numVisible) {
|
|
this.setState({
|
|
numVisible: this.props.numVisible
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.state.slideShowActive) {
|
|
this.stopSlideShow();
|
|
}
|
|
|
|
ZIndexUtils.clear(this.mask);
|
|
}
|
|
}, {
|
|
key: "renderHeader",
|
|
value: function renderHeader() {
|
|
if (this.props.header) {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-galleria-header"
|
|
}, this.props.header);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderFooter",
|
|
value: function renderFooter() {
|
|
if (this.props.footer) {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-galleria-footer"
|
|
}, this.props.footer);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
var _this3 = this;
|
|
|
|
var isVertical = this.isVertical();
|
|
var thumbnailsPosClassName = this.props.showThumbnails && this.getPositionClassName('p-galleria-thumbnails', this.props.thumbnailsPosition);
|
|
var indicatorPosClassName = this.props.showIndicators && this.getPositionClassName('p-galleria-indicators', this.props.indicatorsPosition);
|
|
var galleriaClassName = classNames('p-galleria p-component', this.props.className, {
|
|
'p-galleria-fullscreen': this.props.fullScreen,
|
|
'p-galleria-indicator-onitem': this.props.showIndicatorsOnItem,
|
|
'p-galleria-item-nav-onhover': this.props.showItemNavigatorsOnHover && !this.props.fullScreen
|
|
}, thumbnailsPosClassName, indicatorPosClassName);
|
|
var closeIcon = this.props.fullScreen && /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "p-galleria-close p-link",
|
|
onClick: this.hide
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-galleria-close-icon pi pi-times"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
var header = this.renderHeader();
|
|
var footer = this.renderFooter();
|
|
var element = /*#__PURE__*/React.createElement("div", {
|
|
ref: this.galleriaRef,
|
|
id: this.props.id,
|
|
className: galleriaClassName,
|
|
style: this.props.style
|
|
}, closeIcon, header, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-galleria-content"
|
|
}, /*#__PURE__*/React.createElement(GalleriaItem, {
|
|
ref: function ref(el) {
|
|
return _this3.previewContent = el;
|
|
},
|
|
value: this.props.value,
|
|
activeItemIndex: this.activeItemIndex,
|
|
onActiveItemChange: this.onActiveItemChange,
|
|
itemTemplate: this.props.item,
|
|
circular: this.props.circular,
|
|
caption: this.props.caption,
|
|
showIndicators: this.props.showIndicators,
|
|
changeItemOnIndicatorHover: this.props.changeItemOnIndicatorHover,
|
|
indicator: this.props.indicator,
|
|
showItemNavigators: this.props.showItemNavigators,
|
|
autoPlay: this.props.autoPlay,
|
|
slideShowActive: this.state.slideShowActive,
|
|
startSlideShow: this.startSlideShow,
|
|
stopSlideShow: this.stopSlideShow
|
|
}), this.props.showThumbnails && /*#__PURE__*/React.createElement(GalleriaThumbnails, {
|
|
value: this.props.value,
|
|
activeItemIndex: this.activeItemIndex,
|
|
onActiveItemChange: this.onActiveItemChange,
|
|
itemTemplate: this.props.thumbnail,
|
|
numVisible: this.state.numVisible,
|
|
responsiveOptions: this.props.responsiveOptions,
|
|
circular: this.props.circular,
|
|
isVertical: isVertical,
|
|
contentHeight: this.props.verticalThumbnailViewPortHeight,
|
|
showThumbnailNavigators: this.props.showThumbnailNavigators,
|
|
autoPlay: this.props.autoPlay,
|
|
slideShowActive: this.state.slideShowActive,
|
|
stopSlideShow: this.stopSlideShow
|
|
})), footer);
|
|
return element;
|
|
}
|
|
}, {
|
|
key: "renderGalleria",
|
|
value: function renderGalleria() {
|
|
var _this4 = this;
|
|
|
|
var element = this.renderElement();
|
|
|
|
if (this.props.fullScreen) {
|
|
var maskClassName = classNames('p-galleria-mask', {
|
|
'p-galleria-visible': this.state.visible
|
|
});
|
|
var galleriaWrapper = /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this4.mask = el;
|
|
},
|
|
className: maskClassName
|
|
}, /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.galleriaRef,
|
|
classNames: "p-galleria",
|
|
"in": this.state.visible,
|
|
timeout: {
|
|
enter: 150,
|
|
exit: 150
|
|
},
|
|
options: this.props.transitionOptions,
|
|
unmountOnExit: true,
|
|
onEnter: this.onEnter,
|
|
onEntering: this.onEntering,
|
|
onEntered: this.onEntered,
|
|
onExit: this.onExit,
|
|
onExited: this.onExited
|
|
}, element));
|
|
return /*#__PURE__*/React.createElement(Portal, {
|
|
element: galleriaWrapper
|
|
});
|
|
} else {
|
|
return element;
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
return this.props.value && this.props.value.length > 0 && this.renderGalleria();
|
|
}
|
|
}]);
|
|
|
|
return Galleria;
|
|
}(Component);
|
|
|
|
_defineProperty(Galleria, "defaultProps", {
|
|
id: null,
|
|
value: null,
|
|
activeIndex: 0,
|
|
fullScreen: false,
|
|
item: null,
|
|
thumbnail: null,
|
|
indicator: null,
|
|
caption: null,
|
|
className: null,
|
|
style: null,
|
|
header: null,
|
|
footer: null,
|
|
numVisible: 3,
|
|
responsiveOptions: null,
|
|
showItemNavigators: false,
|
|
showThumbnailNavigators: true,
|
|
showItemNavigatorsOnHover: false,
|
|
changeItemOnIndicatorHover: false,
|
|
circular: false,
|
|
autoPlay: false,
|
|
transitionInterval: 4000,
|
|
showThumbnails: true,
|
|
thumbnailsPosition: "bottom",
|
|
verticalThumbnailViewPortHeight: "300px",
|
|
showIndicators: false,
|
|
showIndicatorsOnItem: false,
|
|
indicatorsPosition: "bottom",
|
|
baseZIndex: 0,
|
|
transitionOptions: null,
|
|
onItemChange: null
|
|
});
|
|
|
|
function _createForOfIteratorHelper$a(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$a(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$a(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$a(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$a(o, minLen); }
|
|
|
|
function _arrayLikeToArray$a(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 _createSuper$1c(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1c(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1c() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var GMap = /*#__PURE__*/function (_Component) {
|
|
_inherits(GMap, _Component);
|
|
|
|
var _super = _createSuper$1c(GMap);
|
|
|
|
function GMap() {
|
|
_classCallCheck(this, GMap);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(GMap, [{
|
|
key: "initMap",
|
|
value: function initMap() {
|
|
this.map = new google.maps.Map(this.container, this.props.options);
|
|
|
|
if (this.props.onMapReady) {
|
|
this.props.onMapReady({
|
|
map: this.map
|
|
});
|
|
}
|
|
|
|
this.initOverlays(this.props.overlays);
|
|
this.bindMapEvent('click', this.props.onMapClick);
|
|
this.bindMapEvent('dragend', this.props.onMapDragEnd);
|
|
this.bindMapEvent('zoom_changed', this.props.onZoomChanged);
|
|
}
|
|
}, {
|
|
key: "initOverlays",
|
|
value: function initOverlays(overlays) {
|
|
if (overlays) {
|
|
var _iterator = _createForOfIteratorHelper$a(overlays),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var overlay = _step.value;
|
|
overlay.setMap(this.map);
|
|
this.bindOverlayEvents(overlay);
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindOverlayEvents",
|
|
value: function bindOverlayEvents(overlay) {
|
|
var _this = this;
|
|
|
|
overlay.addListener('click', function (event) {
|
|
if (_this.props.onOverlayClick) {
|
|
_this.props.onOverlayClick({
|
|
originalEvent: event,
|
|
overlay: overlay,
|
|
map: _this.map
|
|
});
|
|
}
|
|
});
|
|
|
|
if (overlay.getDraggable()) {
|
|
this.bindDragEvents(overlay);
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindDragEvents",
|
|
value: function bindDragEvents(overlay) {
|
|
this.bindDragEvent(overlay, 'dragstart', this.props.onOverlayDragStart);
|
|
this.bindDragEvent(overlay, 'drag', this.props.onOverlayDrag);
|
|
this.bindDragEvent(overlay, 'dragend', this.props.onOverlayDragEnd);
|
|
}
|
|
}, {
|
|
key: "bindMapEvent",
|
|
value: function bindMapEvent(eventName, callback) {
|
|
this.map.addListener(eventName, function (event) {
|
|
if (callback) {
|
|
callback(event);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "bindDragEvent",
|
|
value: function bindDragEvent(overlay, eventName, callback) {
|
|
var _this2 = this;
|
|
|
|
overlay.addListener(eventName, function (event) {
|
|
if (callback) {
|
|
callback({
|
|
originalEvent: event,
|
|
overlay: overlay,
|
|
map: _this2.map
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "getMap",
|
|
value: function getMap() {
|
|
return this.map;
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps, prevState, snapshot) {
|
|
if (prevProps.overlays !== this.props.overlays) {
|
|
if (prevProps.overlays) {
|
|
var _iterator2 = _createForOfIteratorHelper$a(prevProps.overlays),
|
|
_step2;
|
|
|
|
try {
|
|
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
|
|
var overlay = _step2.value;
|
|
google.maps.event.clearInstanceListeners(overlay);
|
|
overlay.setMap(null);
|
|
}
|
|
} catch (err) {
|
|
_iterator2.e(err);
|
|
} finally {
|
|
_iterator2.f();
|
|
}
|
|
}
|
|
|
|
this.initOverlays(this.props.overlays);
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.initMap();
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this3 = this;
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this3.container = el;
|
|
},
|
|
style: this.props.style,
|
|
className: this.props.className
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return GMap;
|
|
}(Component);
|
|
|
|
_defineProperty(GMap, "defaultProps", {
|
|
options: null,
|
|
overlays: null,
|
|
style: null,
|
|
className: null,
|
|
onMapReady: null,
|
|
onMapClick: null,
|
|
onMapDragEnd: null,
|
|
onZoomChanged: null,
|
|
onOverlayDragStart: null,
|
|
onOverlayDrag: null,
|
|
onOverlayDragEnd: null,
|
|
onOverlayClick: null
|
|
});
|
|
|
|
function _createSuper$1b(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1b(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1b() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var InplaceDisplay = /*#__PURE__*/function (_Component) {
|
|
_inherits(InplaceDisplay, _Component);
|
|
|
|
var _super = _createSuper$1b(InplaceDisplay);
|
|
|
|
function InplaceDisplay() {
|
|
_classCallCheck(this, InplaceDisplay);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(InplaceDisplay, [{
|
|
key: "render",
|
|
value: function render() {
|
|
return this.props.children;
|
|
}
|
|
}]);
|
|
|
|
return InplaceDisplay;
|
|
}(Component);
|
|
var InplaceContent = /*#__PURE__*/function (_Component2) {
|
|
_inherits(InplaceContent, _Component2);
|
|
|
|
var _super2 = _createSuper$1b(InplaceContent);
|
|
|
|
function InplaceContent() {
|
|
_classCallCheck(this, InplaceContent);
|
|
|
|
return _super2.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(InplaceContent, [{
|
|
key: "render",
|
|
value: function render() {
|
|
return this.props.children;
|
|
}
|
|
}]);
|
|
|
|
return InplaceContent;
|
|
}(Component);
|
|
var Inplace = /*#__PURE__*/function (_Component3) {
|
|
_inherits(Inplace, _Component3);
|
|
|
|
var _super3 = _createSuper$1b(Inplace);
|
|
|
|
function Inplace(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Inplace);
|
|
|
|
_this = _super3.call(this, props);
|
|
|
|
if (!_this.props.onToggle) {
|
|
_this.state = {
|
|
active: false
|
|
};
|
|
}
|
|
|
|
_this.open = _this.open.bind(_assertThisInitialized(_this));
|
|
_this.close = _this.close.bind(_assertThisInitialized(_this));
|
|
_this.onDisplayKeyDown = _this.onDisplayKeyDown.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Inplace, [{
|
|
key: "open",
|
|
value: function open(event) {
|
|
if (this.props.disabled) {
|
|
return;
|
|
}
|
|
|
|
if (this.props.onOpen) {
|
|
this.props.onOpen(event);
|
|
}
|
|
|
|
if (this.props.onToggle) {
|
|
this.props.onToggle({
|
|
originalEvent: event,
|
|
value: true
|
|
});
|
|
} else {
|
|
this.setState({
|
|
active: true
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "close",
|
|
value: function close(event) {
|
|
if (this.props.onClose) {
|
|
this.props.onClose(event);
|
|
}
|
|
|
|
if (this.props.onToggle) {
|
|
this.props.onToggle({
|
|
originalEvent: event,
|
|
value: false
|
|
});
|
|
} else {
|
|
this.setState({
|
|
active: false
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDisplayKeyDown",
|
|
value: function onDisplayKeyDown(event) {
|
|
if (event.key === 'Enter') {
|
|
this.open(event);
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "isActive",
|
|
value: function isActive() {
|
|
return this.props.onToggle ? this.props.active : this.state.active;
|
|
}
|
|
}, {
|
|
key: "renderDisplay",
|
|
value: function renderDisplay(content) {
|
|
var className = classNames('p-inplace-display', {
|
|
'p-disabled': this.props.disabled
|
|
});
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: className,
|
|
onClick: this.open,
|
|
onKeyDown: this.onDisplayKeyDown,
|
|
tabIndex: this.props.tabIndex,
|
|
"aria-label": this.props.ariaLabel
|
|
}, content);
|
|
}
|
|
}, {
|
|
key: "renderCloseButton",
|
|
value: function renderCloseButton() {
|
|
if (this.props.closable) {
|
|
return /*#__PURE__*/React.createElement(Button, {
|
|
type: "button",
|
|
className: "p-inplace-content-close",
|
|
icon: "pi pi-times",
|
|
onClick: this.close
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent(content) {
|
|
var closeButton = this.renderCloseButton();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-inplace-content"
|
|
}, content, closeButton);
|
|
}
|
|
}, {
|
|
key: "renderChildren",
|
|
value: function renderChildren() {
|
|
var _this2 = this;
|
|
|
|
var active = this.isActive();
|
|
return React.Children.map(this.props.children, function (child, i) {
|
|
if (active && child.type === InplaceContent) {
|
|
return _this2.renderContent(child);
|
|
} else if (!active && child.type === InplaceDisplay) {
|
|
return _this2.renderDisplay(child);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-inplace p-component', {
|
|
'p-inplace-closable': this.props.closable
|
|
}, this.props.className);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: className
|
|
}, this.renderChildren());
|
|
}
|
|
}]);
|
|
|
|
return Inplace;
|
|
}(Component);
|
|
|
|
_defineProperty(Inplace, "defaultProps", {
|
|
style: null,
|
|
className: null,
|
|
active: false,
|
|
closable: false,
|
|
disabled: false,
|
|
tabIndex: 0,
|
|
ariaLabel: null,
|
|
onOpen: null,
|
|
onClose: null,
|
|
onToggle: null
|
|
});
|
|
|
|
function ownKeys$o(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$o(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$o(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$o(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$1a(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1a(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1a() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var InputMask = /*#__PURE__*/function (_Component) {
|
|
_inherits(InputMask, _Component);
|
|
|
|
var _super = _createSuper$1a(InputMask);
|
|
|
|
function InputMask(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, InputMask);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onFocus = _this.onFocus.bind(_assertThisInitialized(_this));
|
|
_this.onBlur = _this.onBlur.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onKeyPress = _this.onKeyPress.bind(_assertThisInitialized(_this));
|
|
_this.onInput = _this.onInput.bind(_assertThisInitialized(_this));
|
|
_this.handleInputChange = _this.handleInputChange.bind(_assertThisInitialized(_this));
|
|
_this.inputRef = /*#__PURE__*/createRef(_this.props.inputRef);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(InputMask, [{
|
|
key: "caret",
|
|
value: function caret(first, last) {
|
|
var range, begin, end;
|
|
var inputEl = this.inputRef && this.inputRef.current;
|
|
|
|
if (!inputEl || !inputEl.offsetParent || inputEl !== document.activeElement) {
|
|
return;
|
|
}
|
|
|
|
if (typeof first === 'number') {
|
|
begin = first;
|
|
end = typeof last === 'number' ? last : begin;
|
|
|
|
if (inputEl.setSelectionRange) {
|
|
inputEl.setSelectionRange(begin, end);
|
|
} else if (inputEl['createTextRange']) {
|
|
range = inputEl['createTextRange']();
|
|
range.collapse(true);
|
|
range.moveEnd('character', end);
|
|
range.moveStart('character', begin);
|
|
range.select();
|
|
}
|
|
} else {
|
|
if (inputEl.setSelectionRange) {
|
|
begin = inputEl.selectionStart;
|
|
end = inputEl.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
|
|
};
|
|
}
|
|
}
|
|
}, {
|
|
key: "isCompleted",
|
|
value: function isCompleted() {
|
|
for (var i = this.firstNonMaskPos; i <= this.lastRequiredNonMaskPos; i++) {
|
|
if (this.tests[i] && this.buffer[i] === this.getPlaceholder(i)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}, {
|
|
key: "getPlaceholder",
|
|
value: function getPlaceholder(i) {
|
|
if (i < this.props.slotChar.length) {
|
|
return this.props.slotChar.charAt(i);
|
|
}
|
|
|
|
return this.props.slotChar.charAt(0);
|
|
}
|
|
}, {
|
|
key: "getValue",
|
|
value: function getValue() {
|
|
return this.props.unmask ? this.getUnmaskedValue() : this.inputRef && this.inputRef.current && this.inputRef.current.value;
|
|
}
|
|
}, {
|
|
key: "seekNext",
|
|
value: function seekNext(pos) {
|
|
while (++pos < this.len && !this.tests[pos]) {
|
|
}
|
|
|
|
return pos;
|
|
}
|
|
}, {
|
|
key: "seekPrev",
|
|
value: function seekPrev(pos) {
|
|
while (--pos >= 0 && !this.tests[pos]) {
|
|
}
|
|
|
|
return pos;
|
|
}
|
|
}, {
|
|
key: "shiftL",
|
|
value: function shiftL(begin, end) {
|
|
var i, j;
|
|
|
|
if (begin < 0) {
|
|
return;
|
|
}
|
|
|
|
for (i = begin, j = this.seekNext(end); i < this.len; i++) {
|
|
if (this.tests[i]) {
|
|
if (j < this.len && this.tests[i].test(this.buffer[j])) {
|
|
this.buffer[i] = this.buffer[j];
|
|
this.buffer[j] = this.getPlaceholder(j);
|
|
} else {
|
|
break;
|
|
}
|
|
|
|
j = this.seekNext(j);
|
|
}
|
|
}
|
|
|
|
this.writeBuffer();
|
|
this.caret(Math.max(this.firstNonMaskPos, begin));
|
|
}
|
|
}, {
|
|
key: "shiftR",
|
|
value: function shiftR(pos) {
|
|
var i, c, j, t;
|
|
|
|
for (i = pos, c = this.getPlaceholder(pos); i < this.len; i++) {
|
|
if (this.tests[i]) {
|
|
j = this.seekNext(i);
|
|
t = this.buffer[i];
|
|
this.buffer[i] = c;
|
|
|
|
if (j < this.len && this.tests[j].test(t)) {
|
|
c = t;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "handleAndroidInput",
|
|
value: function handleAndroidInput(e) {
|
|
var curVal = this.inputRef.current.value;
|
|
var pos = this.caret();
|
|
|
|
if (this.oldVal && this.oldVal.length && this.oldVal.length > curVal.length) {
|
|
// a deletion or backspace happened
|
|
this.checkVal(true);
|
|
|
|
while (pos.begin > 0 && !this.tests[pos.begin - 1]) {
|
|
pos.begin--;
|
|
}
|
|
|
|
if (pos.begin === 0) {
|
|
while (pos.begin < this.firstNonMaskPos && !this.tests[pos.begin]) {
|
|
pos.begin++;
|
|
}
|
|
}
|
|
|
|
this.caret(pos.begin, pos.begin);
|
|
} else {
|
|
this.checkVal(true);
|
|
|
|
while (pos.begin < this.len && !this.tests[pos.begin]) {
|
|
pos.begin++;
|
|
}
|
|
|
|
this.caret(pos.begin, pos.begin);
|
|
}
|
|
|
|
if (this.props.onComplete && this.isCompleted()) {
|
|
this.props.onComplete({
|
|
originalEvent: e,
|
|
value: this.getValue()
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onBlur",
|
|
value: function onBlur(e) {
|
|
this.focus = false;
|
|
this.checkVal();
|
|
this.updateModel(e);
|
|
this.updateFilledState();
|
|
|
|
if (this.props.onBlur) {
|
|
this.props.onBlur(e);
|
|
}
|
|
|
|
if (this.inputRef.current.value !== this.focusText) {
|
|
var event = document.createEvent('HTMLEvents');
|
|
event.initEvent('change', true, false);
|
|
this.inputRef.current.dispatchEvent(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(e) {
|
|
if (this.props.readOnly) {
|
|
return;
|
|
}
|
|
|
|
var k = e.which || e.keyCode,
|
|
pos,
|
|
begin,
|
|
end;
|
|
var iPhone = /iphone/i.test(DomHandler.getUserAgent());
|
|
this.oldVal = this.inputRef.current.value; //backspace, delete, and escape get special treatment
|
|
|
|
if (k === 8 || k === 46 || iPhone && k === 127) {
|
|
pos = this.caret();
|
|
begin = pos.begin;
|
|
end = pos.end;
|
|
|
|
if (end - begin === 0) {
|
|
begin = k !== 46 ? this.seekPrev(begin) : end = this.seekNext(begin - 1);
|
|
end = k === 46 ? this.seekNext(end) : end;
|
|
}
|
|
|
|
this.clearBuffer(begin, end);
|
|
this.shiftL(begin, end - 1);
|
|
this.updateModel(e);
|
|
e.preventDefault();
|
|
} else if (k === 13) {
|
|
// enter
|
|
this.onBlur(e);
|
|
this.updateModel(e);
|
|
} else if (k === 27) {
|
|
// escape
|
|
this.inputRef.current.value = this.focusText;
|
|
this.caret(0, this.checkVal());
|
|
this.updateModel(e);
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onKeyPress",
|
|
value: function onKeyPress(e) {
|
|
var _this2 = this;
|
|
|
|
if (this.props.readOnly) {
|
|
return;
|
|
}
|
|
|
|
var k = e.which || e.keyCode,
|
|
pos = this.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) {
|
|
this.clearBuffer(pos.begin, pos.end);
|
|
this.shiftL(pos.begin, pos.end - 1);
|
|
}
|
|
|
|
p = this.seekNext(pos.begin - 1);
|
|
|
|
if (p < this.len) {
|
|
c = String.fromCharCode(k);
|
|
|
|
if (this.tests[p].test(c)) {
|
|
this.shiftR(p);
|
|
this.buffer[p] = c;
|
|
this.writeBuffer();
|
|
next = this.seekNext(p);
|
|
|
|
if (/android/i.test(DomHandler.getUserAgent())) {
|
|
//Path for CSP Violation on FireFox OS 1.1
|
|
var proxy = function proxy() {
|
|
_this2.caret(next);
|
|
};
|
|
|
|
setTimeout(proxy, 0);
|
|
} else {
|
|
this.caret(next);
|
|
}
|
|
|
|
if (pos.begin <= this.lastRequiredNonMaskPos) {
|
|
completed = this.isCompleted();
|
|
}
|
|
}
|
|
}
|
|
|
|
e.preventDefault();
|
|
}
|
|
|
|
this.updateModel(e);
|
|
|
|
if (this.props.onComplete && completed) {
|
|
this.props.onComplete({
|
|
originalEvent: e,
|
|
value: this.getValue()
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "clearBuffer",
|
|
value: function clearBuffer(start, end) {
|
|
var i;
|
|
|
|
for (i = start; i < end && i < this.len; i++) {
|
|
if (this.tests[i]) {
|
|
this.buffer[i] = this.getPlaceholder(i);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "writeBuffer",
|
|
value: function writeBuffer() {
|
|
this.inputRef.current.value = this.buffer.join('');
|
|
}
|
|
}, {
|
|
key: "checkVal",
|
|
value: function checkVal(allow) {
|
|
this.isValueChecked = true; //try to place characters where they belong
|
|
|
|
var test = this.inputRef.current.value,
|
|
lastMatch = -1,
|
|
i,
|
|
c,
|
|
pos;
|
|
|
|
for (i = 0, pos = 0; i < this.len; i++) {
|
|
if (this.tests[i]) {
|
|
this.buffer[i] = this.getPlaceholder(i);
|
|
|
|
while (pos++ < test.length) {
|
|
c = test.charAt(pos - 1);
|
|
|
|
if (this.tests[i].test(c)) {
|
|
this.buffer[i] = c;
|
|
lastMatch = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (pos > test.length) {
|
|
this.clearBuffer(i + 1, this.len);
|
|
break;
|
|
}
|
|
} else {
|
|
if (this.buffer[i] === test.charAt(pos)) {
|
|
pos++;
|
|
}
|
|
|
|
if (i < this.partialPosition) {
|
|
lastMatch = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (allow) {
|
|
this.writeBuffer();
|
|
} else if (lastMatch + 1 < this.partialPosition) {
|
|
if (this.props.autoClear || this.buffer.join('') === this.defaultBuffer) {
|
|
// Invalid value. Remove it and replace it with the
|
|
// mask, which is the default behavior.
|
|
if (this.inputRef.current.value) this.inputRef.current.value = '';
|
|
this.clearBuffer(0, this.len);
|
|
} else {
|
|
// Invalid value, but we opt to show the value to the
|
|
// user and allow them to correct their mistake.
|
|
this.writeBuffer();
|
|
}
|
|
} else {
|
|
this.writeBuffer();
|
|
this.inputRef.current.value = this.inputRef.current.value.substring(0, lastMatch + 1);
|
|
}
|
|
|
|
return this.partialPosition ? i : this.firstNonMaskPos;
|
|
}
|
|
}, {
|
|
key: "onFocus",
|
|
value: function onFocus(e) {
|
|
var _this3 = this;
|
|
|
|
if (this.props.readOnly) {
|
|
return;
|
|
}
|
|
|
|
this.focus = true;
|
|
clearTimeout(this.caretTimeoutId);
|
|
var pos;
|
|
this.focusText = this.inputRef.current.value;
|
|
pos = this.checkVal();
|
|
this.caretTimeoutId = setTimeout(function () {
|
|
if (_this3.inputRef.current !== document.activeElement) {
|
|
return;
|
|
}
|
|
|
|
_this3.writeBuffer();
|
|
|
|
if (pos === _this3.props.mask.replace("?", "").length) {
|
|
_this3.caret(0, pos);
|
|
} else {
|
|
_this3.caret(pos);
|
|
}
|
|
|
|
_this3.updateFilledState();
|
|
}, 10);
|
|
|
|
if (this.props.onFocus) {
|
|
this.props.onFocus(e);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onInput",
|
|
value: function onInput(event) {
|
|
if (this.androidChrome) this.handleAndroidInput(event);else this.handleInputChange(event);
|
|
}
|
|
}, {
|
|
key: "handleInputChange",
|
|
value: function handleInputChange(e) {
|
|
if (this.props.readOnly) {
|
|
return;
|
|
}
|
|
|
|
var pos = this.checkVal(true);
|
|
this.caret(pos);
|
|
this.updateModel(e);
|
|
|
|
if (this.props.onComplete && this.isCompleted()) {
|
|
this.props.onComplete({
|
|
originalEvent: e,
|
|
value: this.getValue()
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "getUnmaskedValue",
|
|
value: function getUnmaskedValue() {
|
|
var unmaskedBuffer = [];
|
|
|
|
for (var i = 0; i < this.buffer.length; i++) {
|
|
var c = this.buffer[i];
|
|
|
|
if (this.tests[i] && c !== this.getPlaceholder(i)) {
|
|
unmaskedBuffer.push(c);
|
|
}
|
|
}
|
|
|
|
return unmaskedBuffer.join('');
|
|
}
|
|
}, {
|
|
key: "updateModel",
|
|
value: function updateModel(e) {
|
|
if (this.props.onChange) {
|
|
var val = this.props.unmask ? this.getUnmaskedValue() : e && e.target.value;
|
|
this.props.onChange({
|
|
originalEvent: e,
|
|
value: this.defaultBuffer !== val ? val : '',
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: this.defaultBuffer !== val ? val : ''
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateFilledState",
|
|
value: function updateFilledState() {
|
|
if (this.inputRef && this.inputRef.current && this.inputRef.current.value && this.inputRef.current.value.length > 0) DomHandler.addClass(this.inputRef.current, 'p-filled');else DomHandler.removeClass(this.inputRef.current, 'p-filled');
|
|
}
|
|
}, {
|
|
key: "updateValue",
|
|
value: function updateValue(allow) {
|
|
var _this4 = this;
|
|
|
|
var pos;
|
|
|
|
if (this.inputRef && this.inputRef.current) {
|
|
if (this.props.value == null) {
|
|
this.inputRef.current.value = '';
|
|
} else {
|
|
this.inputRef.current.value = this.props.value;
|
|
pos = this.checkVal(allow);
|
|
setTimeout(function () {
|
|
if (_this4.inputRef && _this4.inputRef.current) {
|
|
_this4.writeBuffer();
|
|
|
|
return _this4.checkVal(allow);
|
|
}
|
|
}, 10);
|
|
}
|
|
|
|
this.focusText = this.inputRef.current.value;
|
|
}
|
|
|
|
this.updateFilledState();
|
|
return pos;
|
|
}
|
|
}, {
|
|
key: "isValueUpdated",
|
|
value: function isValueUpdated() {
|
|
return this.props.unmask ? this.props.value !== this.getUnmaskedValue() : this.defaultBuffer !== this.inputRef.current.value && this.inputRef.current.value !== this.props.value;
|
|
}
|
|
}, {
|
|
key: "init",
|
|
value: function init() {
|
|
if (this.props.mask) {
|
|
this.tests = [];
|
|
this.partialPosition = this.props.mask.length;
|
|
this.len = this.props.mask.length;
|
|
this.firstNonMaskPos = null;
|
|
this.defs = {
|
|
'9': '[0-9]',
|
|
'a': '[A-Za-z]',
|
|
'*': '[A-Za-z0-9]'
|
|
};
|
|
var ua = DomHandler.getUserAgent();
|
|
this.androidChrome = /chrome/i.test(ua) && /android/i.test(ua);
|
|
var maskTokens = this.props.mask.split('');
|
|
|
|
for (var i = 0; i < maskTokens.length; i++) {
|
|
var c = maskTokens[i];
|
|
|
|
if (c === '?') {
|
|
this.len--;
|
|
this.partialPosition = i;
|
|
} else if (this.defs[c]) {
|
|
this.tests.push(new RegExp(this.defs[c]));
|
|
|
|
if (this.firstNonMaskPos === null) {
|
|
this.firstNonMaskPos = this.tests.length - 1;
|
|
}
|
|
|
|
if (i < this.partialPosition) {
|
|
this.lastRequiredNonMaskPos = this.tests.length - 1;
|
|
}
|
|
} else {
|
|
this.tests.push(null);
|
|
}
|
|
}
|
|
|
|
this.buffer = [];
|
|
|
|
for (var _i = 0; _i < maskTokens.length; _i++) {
|
|
var _c = maskTokens[_i];
|
|
|
|
if (_c !== '?') {
|
|
if (this.defs[_c]) this.buffer.push(this.getPlaceholder(_i));else this.buffer.push(_c);
|
|
}
|
|
}
|
|
|
|
this.defaultBuffer = this.buffer.join('');
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateInputRef",
|
|
value: function updateInputRef() {
|
|
var ref = this.props.inputRef;
|
|
|
|
if (ref) {
|
|
if (typeof ref === 'function') {
|
|
ref(this.inputRef.current);
|
|
} else {
|
|
ref.current = this.inputRef.current;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.updateInputRef();
|
|
this.init();
|
|
this.updateValue();
|
|
|
|
if (this.props.tooltip) {
|
|
this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$o({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
}
|
|
|
|
if (this.isValueUpdated()) {
|
|
this.updateValue();
|
|
}
|
|
|
|
if (prevProps.mask !== this.props.mask) {
|
|
this.init();
|
|
this.caret(this.updateValue(true));
|
|
this.updateModel();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.inputRef.current,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var inputMaskClassName = classNames('p-inputmask', this.props.className);
|
|
return /*#__PURE__*/React.createElement(InputText, {
|
|
id: this.props.id,
|
|
ref: this.inputRef,
|
|
type: this.props.type,
|
|
name: this.props.name,
|
|
style: this.props.style,
|
|
className: inputMaskClassName,
|
|
placeholder: this.props.placeholder,
|
|
size: this.props.size,
|
|
maxLength: this.props.maxLength,
|
|
tabIndex: this.props.tabIndex,
|
|
disabled: this.props.disabled,
|
|
readOnly: this.props.readOnly,
|
|
onFocus: this.onFocus,
|
|
onBlur: this.onBlur,
|
|
onKeyDown: this.onKeyDown,
|
|
onKeyPress: this.onKeyPress,
|
|
onInput: this.onInput,
|
|
onPaste: this.handleInputChange,
|
|
required: this.props.required,
|
|
"aria-labelledby": this.props.ariaLabelledBy
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return InputMask;
|
|
}(Component);
|
|
|
|
_defineProperty(InputMask, "defaultProps", {
|
|
id: null,
|
|
inputRef: null,
|
|
value: null,
|
|
type: 'text',
|
|
mask: null,
|
|
slotChar: '_',
|
|
autoClear: true,
|
|
unmask: false,
|
|
style: null,
|
|
className: null,
|
|
placeholder: null,
|
|
size: null,
|
|
maxLength: null,
|
|
tabIndex: null,
|
|
disabled: false,
|
|
readOnly: false,
|
|
name: null,
|
|
required: false,
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
ariaLabelledBy: null,
|
|
onComplete: null,
|
|
onChange: null,
|
|
onFocus: null,
|
|
onBlur: null
|
|
});
|
|
|
|
function ownKeys$n(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$n(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$n(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$n(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$19(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$19(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$19() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var InputSwitch = /*#__PURE__*/function (_Component) {
|
|
_inherits(InputSwitch, _Component);
|
|
|
|
var _super = _createSuper$19(InputSwitch);
|
|
|
|
function InputSwitch(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, InputSwitch);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
focused: false
|
|
};
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.toggle = _this.toggle.bind(_assertThisInitialized(_this));
|
|
_this.onFocus = _this.onFocus.bind(_assertThisInitialized(_this));
|
|
_this.onBlur = _this.onBlur.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.inputRef = /*#__PURE__*/createRef(_this.props.inputRef);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(InputSwitch, [{
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
if (this.props.disabled) {
|
|
return;
|
|
}
|
|
|
|
this.toggle(event);
|
|
this.inputRef.current.focus();
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "toggle",
|
|
value: function toggle(event) {
|
|
if (this.props.onChange) {
|
|
var value = this.isChecked() ? this.props.falseValue : this.props.trueValue;
|
|
this.props.onChange({
|
|
originalEvent: event,
|
|
value: value,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: value
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onFocus",
|
|
value: function onFocus(event) {
|
|
var _this2 = this;
|
|
|
|
var currentEvent = event;
|
|
this.setState({
|
|
focused: true
|
|
}, function () {
|
|
if (_this2.props.onFocus) {
|
|
_this2.props.onFocus(currentEvent);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onBlur",
|
|
value: function onBlur(event) {
|
|
var _this3 = this;
|
|
|
|
var currentEvent = event;
|
|
this.setState({
|
|
focused: false
|
|
}, function () {
|
|
if (_this3.props.onBlur) {
|
|
_this3.props.onBlur(currentEvent);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event) {
|
|
if (event.key === 'Enter') {
|
|
this.onClick(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateInputRef",
|
|
value: function updateInputRef() {
|
|
var ref = this.props.inputRef;
|
|
|
|
if (ref) {
|
|
if (typeof ref === 'function') {
|
|
ref(this.inputRef.current);
|
|
} else {
|
|
ref.current = this.inputRef.current;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.updateInputRef();
|
|
|
|
if (this.props.tooltip) {
|
|
this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$n({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.container,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "isChecked",
|
|
value: function isChecked() {
|
|
return this.props.checked === this.props.trueValue;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this4 = this;
|
|
|
|
var checked = this.isChecked();
|
|
var className = classNames('p-inputswitch p-component', {
|
|
'p-inputswitch-checked': checked,
|
|
'p-disabled': this.props.disabled,
|
|
'p-inputswitch-focus': this.state.focused
|
|
}, this.props.className);
|
|
var inputSwitchProps = ObjectUtils.findDiffKeys(this.props, InputSwitch.defaultProps);
|
|
return /*#__PURE__*/React.createElement("div", _extends({
|
|
ref: function ref(el) {
|
|
return _this4.container = el;
|
|
},
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style,
|
|
onClick: this.onClick,
|
|
role: "checkbox",
|
|
"aria-checked": checked
|
|
}, inputSwitchProps), /*#__PURE__*/React.createElement("div", {
|
|
className: "p-hidden-accessible"
|
|
}, /*#__PURE__*/React.createElement("input", {
|
|
ref: this.inputRef,
|
|
type: "checkbox",
|
|
id: this.props.inputId,
|
|
name: this.props.name,
|
|
checked: checked,
|
|
onChange: this.toggle,
|
|
onFocus: this.onFocus,
|
|
onBlur: this.onBlur,
|
|
onKeyDown: this.onKeyDown,
|
|
disabled: this.props.disabled,
|
|
role: "switch",
|
|
"aria-checked": checked,
|
|
"aria-labelledby": this.props.ariaLabelledBy
|
|
})), /*#__PURE__*/React.createElement("span", {
|
|
className: "p-inputswitch-slider"
|
|
}));
|
|
}
|
|
}]);
|
|
|
|
return InputSwitch;
|
|
}(Component);
|
|
|
|
_defineProperty(InputSwitch, "defaultProps", {
|
|
id: null,
|
|
inputRef: null,
|
|
style: null,
|
|
className: null,
|
|
inputId: null,
|
|
name: null,
|
|
checked: false,
|
|
trueValue: true,
|
|
falseValue: false,
|
|
disabled: false,
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
ariaLabelledBy: null,
|
|
onChange: null,
|
|
onFocus: null,
|
|
onBlur: null
|
|
});
|
|
|
|
function ownKeys$m(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$m(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$m(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$m(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$18(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$18(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$18() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
var InputTextareaComponent = /*#__PURE__*/function (_Component) {
|
|
_inherits(InputTextareaComponent, _Component);
|
|
|
|
var _super = _createSuper$18(InputTextareaComponent);
|
|
|
|
function InputTextareaComponent(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, InputTextareaComponent);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onFocus = _this.onFocus.bind(_assertThisInitialized(_this));
|
|
_this.onBlur = _this.onBlur.bind(_assertThisInitialized(_this));
|
|
_this.onKeyUp = _this.onKeyUp.bind(_assertThisInitialized(_this));
|
|
_this.onInput = _this.onInput.bind(_assertThisInitialized(_this));
|
|
_this.elementRef = /*#__PURE__*/createRef(_this.props.forwardRef);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(InputTextareaComponent, [{
|
|
key: "onFocus",
|
|
value: function onFocus(e) {
|
|
if (this.props.autoResize) {
|
|
this.resize();
|
|
}
|
|
|
|
if (this.props.onFocus) {
|
|
this.props.onFocus(e);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onBlur",
|
|
value: function onBlur(e) {
|
|
if (this.props.autoResize) {
|
|
this.resize();
|
|
}
|
|
|
|
if (this.props.onBlur) {
|
|
this.props.onBlur(e);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onKeyUp",
|
|
value: function onKeyUp(e) {
|
|
if (this.props.autoResize) {
|
|
this.resize();
|
|
}
|
|
|
|
if (this.props.onKeyUp) {
|
|
this.props.onKeyUp(e);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onInput",
|
|
value: function onInput(e) {
|
|
if (this.props.autoResize) {
|
|
this.resize();
|
|
}
|
|
|
|
if (e.target.value.length > 0) DomHandler.addClass(e.target, 'p-filled');else DomHandler.removeClass(e.target, 'p-filled');
|
|
|
|
if (this.props.onInput) {
|
|
this.props.onInput(e);
|
|
}
|
|
}
|
|
}, {
|
|
key: "resize",
|
|
value: function resize(initial) {
|
|
var inputEl = this.elementRef && this.elementRef.current;
|
|
|
|
if (inputEl && DomHandler.isVisible(inputEl)) {
|
|
if (!this.cachedScrollHeight) {
|
|
this.cachedScrollHeight = inputEl.scrollHeight;
|
|
inputEl.style.overflow = "hidden";
|
|
}
|
|
|
|
if (this.cachedScrollHeight !== inputEl.scrollHeight || initial) {
|
|
inputEl.style.height = '';
|
|
inputEl.style.height = inputEl.scrollHeight + 'px';
|
|
|
|
if (parseFloat(inputEl.style.height) >= parseFloat(inputEl.style.maxHeight)) {
|
|
inputEl.style.overflowY = "scroll";
|
|
inputEl.style.height = inputEl.style.maxHeight;
|
|
} else {
|
|
inputEl.style.overflow = "hidden";
|
|
}
|
|
|
|
this.cachedScrollHeight = inputEl.scrollHeight;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "isFilled",
|
|
value: function isFilled() {
|
|
return this.props.value != null && this.props.value.toString().length > 0 || this.props.defaultValue != null && this.props.defaultValue.toString().length > 0 || this.elementRef && this.elementRef.current && this.elementRef.current.value.toString().length > 0;
|
|
}
|
|
}, {
|
|
key: "updateForwardRef",
|
|
value: function updateForwardRef() {
|
|
var ref = this.props.forwardRef;
|
|
|
|
if (ref) {
|
|
if (typeof ref === 'function') {
|
|
ref(this.elementRef.current);
|
|
} else {
|
|
ref.current = this.elementRef.current;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.updateForwardRef();
|
|
|
|
if (this.props.tooltip) {
|
|
this.renderTooltip();
|
|
}
|
|
|
|
if (this.props.autoResize) {
|
|
this.resize(true);
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$m({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
}
|
|
|
|
if (this.props.autoResize) {
|
|
this.resize(true);
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.elementRef.current,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-inputtextarea p-inputtext p-component', {
|
|
'p-disabled': this.props.disabled,
|
|
'p-filled': this.isFilled(),
|
|
'p-inputtextarea-resizable': this.props.autoResize
|
|
}, this.props.className);
|
|
var textareaProps = ObjectUtils.findDiffKeys(this.props, InputTextareaComponent.defaultProps);
|
|
return /*#__PURE__*/React.createElement("textarea", _extends({
|
|
ref: this.elementRef
|
|
}, textareaProps, {
|
|
className: className,
|
|
onFocus: this.onFocus,
|
|
onBlur: this.onBlur,
|
|
onKeyUp: this.onKeyUp,
|
|
onInput: this.onInput
|
|
}));
|
|
}
|
|
}]);
|
|
|
|
return InputTextareaComponent;
|
|
}(Component);
|
|
|
|
_defineProperty(InputTextareaComponent, "defaultProps", {
|
|
autoResize: false,
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
onInput: null,
|
|
forwardRef: null
|
|
});
|
|
|
|
var InputTextarea = /*#__PURE__*/React.forwardRef(function (props, ref) {
|
|
return /*#__PURE__*/React.createElement(InputTextareaComponent, _extends({
|
|
forwardRef: ref
|
|
}, props));
|
|
});
|
|
|
|
function _createSuper$17(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$17(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$17() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Knob = /*#__PURE__*/function (_Component) {
|
|
_inherits(Knob, _Component);
|
|
|
|
var _super = _createSuper$17(Knob);
|
|
|
|
function Knob(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Knob);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {};
|
|
_this.radius = 40;
|
|
_this.midX = 50;
|
|
_this.midY = 50;
|
|
_this.minRadians = 4 * Math.PI / 3;
|
|
_this.maxRadians = -Math.PI / 3;
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onMouseDown = _this.onMouseDown.bind(_assertThisInitialized(_this));
|
|
_this.onMouseUp = _this.onMouseUp.bind(_assertThisInitialized(_this));
|
|
_this.onTouchStart = _this.onTouchStart.bind(_assertThisInitialized(_this));
|
|
_this.onTouchEnd = _this.onTouchEnd.bind(_assertThisInitialized(_this));
|
|
_this.onMouseMove = _this.onMouseMove.bind(_assertThisInitialized(_this));
|
|
_this.onTouchMove = _this.onTouchMove.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Knob, [{
|
|
key: "updateValue",
|
|
value: function updateValue(offsetX, offsetY) {
|
|
var dx = offsetX - this.props.size / 2;
|
|
var dy = this.props.size / 2 - offsetY;
|
|
var angle = Math.atan2(dy, dx);
|
|
var start = -Math.PI / 2 - Math.PI / 6;
|
|
this.updateModel(angle, start);
|
|
}
|
|
}, {
|
|
key: "updateModel",
|
|
value: function updateModel(angle, start) {
|
|
var mappedValue;
|
|
if (angle > this.maxRadians) mappedValue = this.mapRange(angle, this.minRadians, this.maxRadians, this.props.min, this.props.max);else if (angle < start) mappedValue = this.mapRange(angle + 2 * Math.PI, this.minRadians, this.maxRadians, this.props.min, this.props.max);else return;
|
|
|
|
if (this.props.onChange) {
|
|
var newValue = Math.round((mappedValue - this.props.min) / this.props.step) * this.props.step + this.props.min;
|
|
this.props.onChange({
|
|
value: newValue
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "mapRange",
|
|
value: function mapRange(x, inMin, inMax, outMin, outMax) {
|
|
return (x - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
|
|
}
|
|
}, {
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
if (!this.props.disabled && !this.props.readOnly) {
|
|
this.updateValue(event.nativeEvent.offsetX, event.nativeEvent.offsetY);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onMouseDown",
|
|
value: function onMouseDown(event) {
|
|
if (!this.props.disabled && !this.props.readOnly) {
|
|
this.windowMouseMoveListener = this.onMouseMove;
|
|
this.windowMouseUpListener = this.onMouseUp;
|
|
window.addEventListener('mousemove', this.windowMouseMoveListener);
|
|
window.addEventListener('mouseup', this.windowMouseUpListener);
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onMouseUp",
|
|
value: function onMouseUp(event) {
|
|
if (!this.props.disabled && !this.props.readOnly) {
|
|
window.removeEventListener('mousemove', this.windowMouseMoveListener);
|
|
window.removeEventListener('mouseup', this.windowMouseUpListener);
|
|
this.windowMouseMoveListener = null;
|
|
this.windowMouseUpListener = null;
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onTouchStart",
|
|
value: function onTouchStart(event) {
|
|
if (!this.props.disabled && !this.props.readOnly) {
|
|
this.windowTouchMoveListener = this.onTouchMove;
|
|
this.windowTouchEndListener = this.onTouchEnd;
|
|
window.addEventListener('touchmove', this.windowTouchMoveListener, {
|
|
passive: false,
|
|
cancelable: false
|
|
});
|
|
window.addEventListener('touchend', this.windowTouchEndListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onTouchEnd",
|
|
value: function onTouchEnd(event) {
|
|
if (!this.props.disabled && !this.props.readOnly) {
|
|
window.removeEventListener('touchmove', this.windowTouchMoveListener);
|
|
window.removeEventListener('touchend', this.windowTouchEndListener);
|
|
this.windowTouchMoveListener = null;
|
|
this.windowTouchEndListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "onMouseMove",
|
|
value: function onMouseMove(event) {
|
|
if (!this.props.disabled && !this.props.readOnly) {
|
|
this.updateValue(event.offsetX, event.offsetY);
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onTouchMove",
|
|
value: function onTouchMove(event) {
|
|
if (!this.props.disabled && !this.props.readOnly && event.touches.length === 1) {
|
|
var rect = this.element.getBoundingClientRect();
|
|
var touch = event.targetTouches.item(0);
|
|
var offsetX = touch.clientX - rect.left;
|
|
var offsetY = touch.clientY - rect.top;
|
|
this.updateValue(offsetX, offsetY);
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "rangePath",
|
|
value: function rangePath() {
|
|
return "M ".concat(this.minX(), " ").concat(this.minY(), " A ").concat(this.radius, " ").concat(this.radius, " 0 1 1 ").concat(this.maxX(), " ").concat(this.maxY());
|
|
}
|
|
}, {
|
|
key: "valuePath",
|
|
value: function valuePath() {
|
|
return "M ".concat(this.zeroX(), " ").concat(this.zeroY(), " A ").concat(this.radius, " ").concat(this.radius, " 0 ").concat(this.largeArc(), " ").concat(this.sweep(), " ").concat(this.valueX(), " ").concat(this.valueY());
|
|
}
|
|
}, {
|
|
key: "zeroRadians",
|
|
value: function zeroRadians() {
|
|
if (this.props.min > 0 && this.props.max > 0) return this.mapRange(this.props.min, this.props.min, this.props.max, this.minRadians, this.maxRadians);else return this.mapRange(0, this.props.min, this.props.max, this.minRadians, this.maxRadians);
|
|
}
|
|
}, {
|
|
key: "valueRadians",
|
|
value: function valueRadians() {
|
|
return this.mapRange(this.props.value, this.props.min, this.props.max, this.minRadians, this.maxRadians);
|
|
}
|
|
}, {
|
|
key: "minX",
|
|
value: function minX() {
|
|
return this.midX + Math.cos(this.minRadians) * this.radius;
|
|
}
|
|
}, {
|
|
key: "minY",
|
|
value: function minY() {
|
|
return this.midY - Math.sin(this.minRadians) * this.radius;
|
|
}
|
|
}, {
|
|
key: "maxX",
|
|
value: function maxX() {
|
|
return this.midX + Math.cos(this.maxRadians) * this.radius;
|
|
}
|
|
}, {
|
|
key: "maxY",
|
|
value: function maxY() {
|
|
return this.midY - Math.sin(this.maxRadians) * this.radius;
|
|
}
|
|
}, {
|
|
key: "zeroX",
|
|
value: function zeroX() {
|
|
return this.midX + Math.cos(this.zeroRadians()) * this.radius;
|
|
}
|
|
}, {
|
|
key: "zeroY",
|
|
value: function zeroY() {
|
|
return this.midY - Math.sin(this.zeroRadians()) * this.radius;
|
|
}
|
|
}, {
|
|
key: "valueX",
|
|
value: function valueX() {
|
|
return this.midX + Math.cos(this.valueRadians()) * this.radius;
|
|
}
|
|
}, {
|
|
key: "valueY",
|
|
value: function valueY() {
|
|
return this.midY - Math.sin(this.valueRadians()) * this.radius;
|
|
}
|
|
}, {
|
|
key: "largeArc",
|
|
value: function largeArc() {
|
|
return Math.abs(this.zeroRadians() - this.valueRadians()) < Math.PI ? 0 : 1;
|
|
}
|
|
}, {
|
|
key: "sweep",
|
|
value: function sweep() {
|
|
return this.valueRadians() > this.zeroRadians() ? 0 : 1;
|
|
}
|
|
}, {
|
|
key: "valueToDisplay",
|
|
value: function valueToDisplay() {
|
|
return this.props.valueTemplate.replace("{value}", this.props.value.toString());
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this2 = this;
|
|
|
|
var containerClassName = classNames('p-knob p-component', {
|
|
'p-disabled': this.props.disabled
|
|
}, this.props.className);
|
|
var text = this.props.showValue && /*#__PURE__*/React.createElement("text", {
|
|
x: 50,
|
|
y: 57,
|
|
textAnchor: 'middle',
|
|
fill: this.props.textColor,
|
|
className: 'p-knob-text',
|
|
name: this.props.name
|
|
}, this.valueToDisplay());
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
className: containerClassName,
|
|
style: this.props.style,
|
|
ref: function ref(el) {
|
|
return _this2.element = el;
|
|
}
|
|
}, /*#__PURE__*/React.createElement("svg", {
|
|
viewBox: "0 0 100 100",
|
|
width: this.props.size,
|
|
height: this.props.size,
|
|
onClick: this.onClick,
|
|
onMouseDown: this.onMouseDown,
|
|
onMouseUp: this.onMouseUp,
|
|
onTouchStart: this.onTouchStart,
|
|
onTouchEnd: this.onTouchEnd
|
|
}, /*#__PURE__*/React.createElement("path", {
|
|
d: this.rangePath(),
|
|
strokeWidth: this.props.strokeWidth,
|
|
stroke: this.props.rangeColor,
|
|
className: 'p-knob-range'
|
|
}), /*#__PURE__*/React.createElement("path", {
|
|
d: this.valuePath(),
|
|
strokeWidth: this.props.strokeWidth,
|
|
stroke: this.props.valueColor,
|
|
className: 'p-knob-value'
|
|
}), text));
|
|
}
|
|
}]);
|
|
|
|
return Knob;
|
|
}(Component);
|
|
|
|
_defineProperty(Knob, "defaultProps", {
|
|
id: null,
|
|
style: null,
|
|
className: null,
|
|
value: null,
|
|
size: 100,
|
|
disabled: false,
|
|
readOnly: false,
|
|
showValue: true,
|
|
step: 1,
|
|
min: 0,
|
|
max: 100,
|
|
strokeWidth: 14,
|
|
name: null,
|
|
valueColor: 'var(--primary-color, Black)',
|
|
rangeColor: 'var(--surface-d, LightGray)',
|
|
textColor: 'var(--text-color-secondary, Black)',
|
|
valueTemplate: '{value}',
|
|
onChange: null
|
|
});
|
|
|
|
function _createSuper$16(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$16(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$16() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var ListBoxItem = /*#__PURE__*/function (_Component) {
|
|
_inherits(ListBoxItem, _Component);
|
|
|
|
var _super = _createSuper$16(ListBoxItem);
|
|
|
|
function ListBoxItem(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, ListBoxItem);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onTouchEnd = _this.onTouchEnd.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(ListBoxItem, [{
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
if (this.props.onClick) {
|
|
this.props.onClick({
|
|
originalEvent: event,
|
|
option: this.props.option
|
|
});
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onTouchEnd",
|
|
value: function onTouchEnd(event) {
|
|
if (this.props.onTouchEnd) {
|
|
this.props.onTouchEnd({
|
|
originalEvent: event,
|
|
option: this.props.option
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event) {
|
|
var item = event.currentTarget;
|
|
|
|
switch (event.which) {
|
|
//down
|
|
case 40:
|
|
var nextItem = this.findNextItem(item);
|
|
|
|
if (nextItem) {
|
|
nextItem.focus();
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//up
|
|
|
|
case 38:
|
|
var prevItem = this.findPrevItem(item);
|
|
|
|
if (prevItem) {
|
|
prevItem.focus();
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//enter
|
|
|
|
case 13:
|
|
this.onClick(event);
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
}
|
|
}, {
|
|
key: "findNextItem",
|
|
value: function findNextItem(item) {
|
|
var nextItem = item.nextElementSibling;
|
|
if (nextItem) return DomHandler.hasClass(nextItem, 'p-disabled') || DomHandler.hasClass(nextItem, 'p-listbox-item-group') ? this.findNextItem(nextItem) : nextItem;else return null;
|
|
}
|
|
}, {
|
|
key: "findPrevItem",
|
|
value: function findPrevItem(item) {
|
|
var prevItem = item.previousElementSibling;
|
|
if (prevItem) return DomHandler.hasClass(prevItem, 'p-disabled') || DomHandler.hasClass(prevItem, 'p-listbox-item-group') ? this.findPrevItem(prevItem) : prevItem;else return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-listbox-item', {
|
|
'p-highlight': this.props.selected,
|
|
'p-disabled': this.props.disabled
|
|
}, this.props.option.className);
|
|
var content = this.props.template ? ObjectUtils.getJSXElement(this.props.template, this.props.option) : this.props.label;
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
className: className,
|
|
onClick: this.onClick,
|
|
onTouchEnd: this.onTouchEnd,
|
|
onKeyDown: this.onKeyDown,
|
|
tabIndex: this.props.tabIndex,
|
|
"aria-label": this.props.label,
|
|
key: this.props.label,
|
|
role: "option",
|
|
"aria-selected": this.props.selected
|
|
}, content, /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
}]);
|
|
|
|
return ListBoxItem;
|
|
}(Component);
|
|
|
|
_defineProperty(ListBoxItem, "defaultProps", {
|
|
option: null,
|
|
label: null,
|
|
selected: false,
|
|
disabled: false,
|
|
tabIndex: null,
|
|
onClick: null,
|
|
onTouchEnd: null,
|
|
template: null
|
|
});
|
|
|
|
function _createSuper$15(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$15(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$15() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var ListBoxHeader = /*#__PURE__*/function (_Component) {
|
|
_inherits(ListBoxHeader, _Component);
|
|
|
|
var _super = _createSuper$15(ListBoxHeader);
|
|
|
|
function ListBoxHeader(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, ListBoxHeader);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onFilter = _this.onFilter.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(ListBoxHeader, [{
|
|
key: "onFilter",
|
|
value: function onFilter(event) {
|
|
if (this.props.onFilter) {
|
|
this.props.onFilter({
|
|
originalEvent: event,
|
|
value: event.target.value
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-listbox-header"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-listbox-filter-container"
|
|
}, /*#__PURE__*/React.createElement(InputText, {
|
|
type: "text",
|
|
value: this.props.filter,
|
|
onChange: this.onFilter,
|
|
className: "p-listbox-filter",
|
|
disabled: this.props.disabled,
|
|
placeholder: this.props.filterPlaceholder
|
|
}), /*#__PURE__*/React.createElement("span", {
|
|
className: "p-listbox-filter-icon pi pi-search"
|
|
})));
|
|
}
|
|
}]);
|
|
|
|
return ListBoxHeader;
|
|
}(Component);
|
|
|
|
_defineProperty(ListBoxHeader, "defaultProps", {
|
|
filter: null,
|
|
filterPlaceholder: null,
|
|
disabled: false,
|
|
onFilter: null
|
|
});
|
|
|
|
function _createForOfIteratorHelper$9(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$9(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$9(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$9(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$9(o, minLen); }
|
|
|
|
function _arrayLikeToArray$9(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 ownKeys$l(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$l(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$l(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$l(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$14(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$14(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$14() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var ListBox = /*#__PURE__*/function (_Component) {
|
|
_inherits(ListBox, _Component);
|
|
|
|
var _super = _createSuper$14(ListBox);
|
|
|
|
function ListBox(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, ListBox);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {};
|
|
|
|
if (!_this.props.onFilterValueChange) {
|
|
_this.state.filterValue = '';
|
|
}
|
|
|
|
_this.onFilter = _this.onFilter.bind(_assertThisInitialized(_this));
|
|
_this.onOptionSelect = _this.onOptionSelect.bind(_assertThisInitialized(_this));
|
|
_this.onOptionTouchEnd = _this.onOptionTouchEnd.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(ListBox, [{
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (this.props.tooltip) {
|
|
this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$l({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.element,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "getFilterValue",
|
|
value: function getFilterValue() {
|
|
return (this.props.onFilterValueChange ? this.props.filterValue : this.state.filterValue) || '';
|
|
}
|
|
}, {
|
|
key: "onOptionSelect",
|
|
value: function onOptionSelect(event) {
|
|
var option = event.option;
|
|
|
|
if (this.props.disabled || this.isOptionDisabled(option)) {
|
|
return;
|
|
}
|
|
|
|
if (this.props.multiple) this.onOptionSelectMultiple(event.originalEvent, option);else this.onOptionSelectSingle(event.originalEvent, option);
|
|
this.optionTouched = false;
|
|
}
|
|
}, {
|
|
key: "onOptionTouchEnd",
|
|
value: function onOptionTouchEnd() {
|
|
if (this.props.disabled) {
|
|
return;
|
|
}
|
|
|
|
this.optionTouched = true;
|
|
}
|
|
}, {
|
|
key: "onOptionSelectSingle",
|
|
value: function onOptionSelectSingle(event, option) {
|
|
var selected = this.isSelected(option);
|
|
var valueChanged = false;
|
|
var value = null;
|
|
var metaSelection = this.optionTouched ? false : this.props.metaKeySelection;
|
|
|
|
if (metaSelection) {
|
|
var metaKey = event.metaKey || event.ctrlKey;
|
|
|
|
if (selected) {
|
|
if (metaKey) {
|
|
value = null;
|
|
valueChanged = true;
|
|
}
|
|
} else {
|
|
value = this.getOptionValue(option);
|
|
valueChanged = true;
|
|
}
|
|
} else {
|
|
value = selected ? null : this.getOptionValue(option);
|
|
valueChanged = true;
|
|
}
|
|
|
|
if (valueChanged) {
|
|
this.updateModel(event, value);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onOptionSelectMultiple",
|
|
value: function onOptionSelectMultiple(event, option) {
|
|
var selected = this.isSelected(option);
|
|
var valueChanged = false;
|
|
var value = null;
|
|
var metaSelection = this.optionTouched ? false : this.props.metaKeySelection;
|
|
|
|
if (metaSelection) {
|
|
var metaKey = event.metaKey || event.ctrlKey;
|
|
|
|
if (selected) {
|
|
if (metaKey) value = this.removeOption(option);else value = [this.getOptionValue(option)];
|
|
valueChanged = true;
|
|
} else {
|
|
value = metaKey ? this.props.value || [] : [];
|
|
value = [].concat(_toConsumableArray(value), [this.getOptionValue(option)]);
|
|
valueChanged = true;
|
|
}
|
|
} else {
|
|
if (selected) value = this.removeOption(option);else value = [].concat(_toConsumableArray(this.props.value || []), [this.getOptionValue(option)]);
|
|
valueChanged = true;
|
|
}
|
|
|
|
if (valueChanged) {
|
|
this.props.onChange({
|
|
originalEvent: event,
|
|
value: value,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: value
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onFilter",
|
|
value: function onFilter(event) {
|
|
var originalEvent = event.originalEvent,
|
|
value = event.value;
|
|
|
|
if (this.props.onFilterValueChange) {
|
|
this.props.onFilterValueChange({
|
|
originalEvent: originalEvent,
|
|
value: value
|
|
});
|
|
} else {
|
|
this.setState({
|
|
filterValue: value
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateModel",
|
|
value: function updateModel(event, value) {
|
|
if (this.props.onChange) {
|
|
this.props.onChange({
|
|
originalEvent: event,
|
|
value: value,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: value
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "removeOption",
|
|
value: function removeOption(option) {
|
|
var _this2 = this;
|
|
|
|
return this.props.value.filter(function (val) {
|
|
return !ObjectUtils.equals(val, _this2.getOptionValue(option), _this2.props.dataKey);
|
|
});
|
|
}
|
|
}, {
|
|
key: "isSelected",
|
|
value: function isSelected(option) {
|
|
var selected = false;
|
|
var optionValue = this.getOptionValue(option);
|
|
|
|
if (this.props.multiple) {
|
|
if (this.props.value) {
|
|
var _iterator = _createForOfIteratorHelper$9(this.props.value),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var val = _step.value;
|
|
|
|
if (ObjectUtils.equals(val, optionValue, this.props.dataKey)) {
|
|
selected = true;
|
|
break;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
}
|
|
} else {
|
|
selected = ObjectUtils.equals(this.props.value, optionValue, this.props.dataKey);
|
|
}
|
|
|
|
return selected;
|
|
}
|
|
}, {
|
|
key: "filter",
|
|
value: function filter(option) {
|
|
var filterValue = this.getFilterValue().trim().toLocaleLowerCase(this.props.filterLocale);
|
|
var optionLabel = this.getOptionLabel(option).toLocaleLowerCase(this.props.filterLocale);
|
|
return optionLabel.indexOf(filterValue) > -1;
|
|
}
|
|
}, {
|
|
key: "hasFilter",
|
|
value: function hasFilter() {
|
|
var filter = this.getFilterValue();
|
|
return filter && filter.trim().length > 0;
|
|
}
|
|
}, {
|
|
key: "getOptionLabel",
|
|
value: function getOptionLabel(option) {
|
|
return this.props.optionLabel ? ObjectUtils.resolveFieldData(option, this.props.optionLabel) : option && option['label'] !== undefined ? option['label'] : option;
|
|
}
|
|
}, {
|
|
key: "getOptionValue",
|
|
value: function getOptionValue(option) {
|
|
return this.props.optionValue ? ObjectUtils.resolveFieldData(option, this.props.optionValue) : option && option['value'] !== undefined ? option['value'] : option;
|
|
}
|
|
}, {
|
|
key: "getOptionRenderKey",
|
|
value: function getOptionRenderKey(option) {
|
|
return this.props.dataKey ? ObjectUtils.resolveFieldData(option, this.props.dataKey) : this.getOptionLabel(option);
|
|
}
|
|
}, {
|
|
key: "isOptionDisabled",
|
|
value: function isOptionDisabled(option) {
|
|
if (this.props.optionDisabled) {
|
|
return ObjectUtils.isFunction(this.props.optionDisabled) ? this.props.optionDisabled(option) : ObjectUtils.resolveFieldData(option, this.props.optionDisabled);
|
|
}
|
|
|
|
return option && option['disabled'] !== undefined ? option['disabled'] : false;
|
|
}
|
|
}, {
|
|
key: "getOptionGroupRenderKey",
|
|
value: function getOptionGroupRenderKey(optionGroup) {
|
|
return ObjectUtils.resolveFieldData(optionGroup, this.props.optionGroupLabel);
|
|
}
|
|
}, {
|
|
key: "getOptionGroupLabel",
|
|
value: function getOptionGroupLabel(optionGroup) {
|
|
return ObjectUtils.resolveFieldData(optionGroup, this.props.optionGroupLabel);
|
|
}
|
|
}, {
|
|
key: "getOptionGroupChildren",
|
|
value: function getOptionGroupChildren(optionGroup) {
|
|
return ObjectUtils.resolveFieldData(optionGroup, this.props.optionGroupChildren);
|
|
}
|
|
}, {
|
|
key: "getVisibleOptions",
|
|
value: function getVisibleOptions() {
|
|
if (this.hasFilter()) {
|
|
var filterValue = this.getFilterValue().trim().toLocaleLowerCase(this.props.filterLocale);
|
|
var searchFields = this.props.filterBy ? this.props.filterBy.split(',') : [this.props.optionLabel || 'label'];
|
|
|
|
if (this.props.optionGroupLabel) {
|
|
var filteredGroups = [];
|
|
|
|
var _iterator2 = _createForOfIteratorHelper$9(this.props.options),
|
|
_step2;
|
|
|
|
try {
|
|
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
|
|
var optgroup = _step2.value;
|
|
var filteredSubOptions = FilterService.filter(this.getOptionGroupChildren(optgroup), searchFields, filterValue, this.props.filterMatchMode, this.props.filterLocale);
|
|
|
|
if (filteredSubOptions && filteredSubOptions.length) {
|
|
filteredGroups.push(_objectSpread$l(_objectSpread$l({}, optgroup), {
|
|
items: filteredSubOptions
|
|
}));
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator2.e(err);
|
|
} finally {
|
|
_iterator2.f();
|
|
}
|
|
|
|
return filteredGroups;
|
|
} else {
|
|
return FilterService.filter(this.props.options, searchFields, filterValue, this.props.filterMatchMode, this.props.filterLocale);
|
|
}
|
|
} else {
|
|
return this.props.options;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderGroupChildren",
|
|
value: function renderGroupChildren(optionGroup) {
|
|
var _this3 = this;
|
|
|
|
var groupChildren = this.getOptionGroupChildren(optionGroup);
|
|
return groupChildren.map(function (option, j) {
|
|
var optionLabel = _this3.getOptionLabel(option);
|
|
|
|
var optionKey = j + '_' + _this3.getOptionRenderKey(option);
|
|
|
|
var disabled = _this3.isOptionDisabled(option);
|
|
|
|
var tabIndex = disabled ? null : _this3.props.tabIndex || 0;
|
|
return /*#__PURE__*/React.createElement(ListBoxItem, {
|
|
key: optionKey,
|
|
label: optionLabel,
|
|
option: option,
|
|
template: _this3.props.itemTemplate,
|
|
selected: _this3.isSelected(option),
|
|
onClick: _this3.onOptionSelect,
|
|
onTouchEnd: _this3.onOptionTouchEnd,
|
|
tabIndex: tabIndex,
|
|
disabled: disabled
|
|
});
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderItem",
|
|
value: function renderItem(option, index) {
|
|
if (this.props.optionGroupLabel) {
|
|
var groupContent = this.props.optionGroupTemplate ? ObjectUtils.getJSXElement(this.props.optionGroupTemplate, option, index) : this.getOptionGroupLabel(option);
|
|
var groupChildrenContent = this.renderGroupChildren(option);
|
|
var key = index + '_' + this.getOptionGroupRenderKey(option);
|
|
return /*#__PURE__*/React.createElement(React.Fragment, {
|
|
key: key
|
|
}, /*#__PURE__*/React.createElement("li", {
|
|
className: "p-listbox-item-group"
|
|
}, groupContent), groupChildrenContent);
|
|
} else {
|
|
var optionLabel = this.getOptionLabel(option);
|
|
var optionKey = index + '_' + this.getOptionRenderKey(option);
|
|
var disabled = this.isOptionDisabled(option);
|
|
var tabIndex = disabled ? null : this.props.tabIndex || 0;
|
|
return /*#__PURE__*/React.createElement(ListBoxItem, {
|
|
key: optionKey,
|
|
label: optionLabel,
|
|
option: option,
|
|
template: this.props.itemTemplate,
|
|
selected: this.isSelected(option),
|
|
onClick: this.onOptionSelect,
|
|
onTouchEnd: this.onOptionTouchEnd,
|
|
tabIndex: tabIndex,
|
|
disabled: disabled
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderItems",
|
|
value: function renderItems(visibleOptions) {
|
|
var _this4 = this;
|
|
|
|
if (visibleOptions && visibleOptions.length) {
|
|
return visibleOptions.map(function (option, index) {
|
|
return _this4.renderItem(option, index);
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderList",
|
|
value: function renderList(visibleOptions) {
|
|
var _this5 = this;
|
|
|
|
if (this.props.virtualScrollerOptions) {
|
|
var virtualScrollerProps = _objectSpread$l(_objectSpread$l({}, this.props.virtualScrollerOptions), {
|
|
items: visibleOptions,
|
|
onLazyLoad: function onLazyLoad(event) {
|
|
return _this5.props.virtualScrollerOptions.onLazyLoad(_objectSpread$l(_objectSpread$l({}, event), {
|
|
filter: _this5.getFilterValue()
|
|
}));
|
|
},
|
|
itemTemplate: function itemTemplate(item, options) {
|
|
return item && _this5.renderItem(item, options.index);
|
|
},
|
|
contentTemplate: function contentTemplate(options) {
|
|
var className = classNames('p-listbox-list', options.className);
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
ref: options.contentRef,
|
|
className: className,
|
|
role: "listbox",
|
|
"aria-multiselectable": _this5.props.multiple
|
|
}, options.children);
|
|
}
|
|
});
|
|
|
|
return /*#__PURE__*/React.createElement(VirtualScroller, _extends({
|
|
ref: function ref(el) {
|
|
return _this5.virtualScrollerRef = el;
|
|
}
|
|
}, virtualScrollerProps));
|
|
} else {
|
|
var items = this.renderItems(visibleOptions);
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
className: "p-listbox-list",
|
|
role: "listbox",
|
|
"aria-multiselectable": this.props.multiple
|
|
}, items);
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this6 = this;
|
|
|
|
var className = classNames('p-listbox p-component', {
|
|
'p-disabled': this.props.disabled
|
|
}, this.props.className);
|
|
var listClassName = classNames('p-listbox-list-wrapper', this.props.listClassName);
|
|
var visibleOptions = this.getVisibleOptions();
|
|
var list = this.renderList(visibleOptions);
|
|
var header;
|
|
|
|
if (this.props.filter) {
|
|
header = /*#__PURE__*/React.createElement(ListBoxHeader, {
|
|
filter: this.getFilterValue(),
|
|
onFilter: this.onFilter,
|
|
disabled: this.props.disabled,
|
|
filterPlaceholder: this.props.filterPlaceholder
|
|
});
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this6.element = el;
|
|
},
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, header, /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this6.wrapper = el;
|
|
},
|
|
className: listClassName,
|
|
style: this.props.listStyle
|
|
}, list));
|
|
}
|
|
}]);
|
|
|
|
return ListBox;
|
|
}(Component);
|
|
|
|
_defineProperty(ListBox, "defaultProps", {
|
|
id: null,
|
|
value: null,
|
|
options: null,
|
|
optionLabel: null,
|
|
optionValue: null,
|
|
optionDisabled: null,
|
|
optionGroupLabel: null,
|
|
optionGroupChildren: null,
|
|
optionGroupTemplate: null,
|
|
itemTemplate: null,
|
|
style: null,
|
|
listStyle: null,
|
|
listClassName: null,
|
|
className: null,
|
|
virtualScrollerOptions: null,
|
|
disabled: null,
|
|
dataKey: null,
|
|
multiple: false,
|
|
metaKeySelection: false,
|
|
filter: false,
|
|
filterBy: null,
|
|
filterValue: null,
|
|
filterMatchMode: 'contains',
|
|
filterPlaceholder: null,
|
|
filterLocale: undefined,
|
|
tabIndex: 0,
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
ariaLabelledBy: null,
|
|
onChange: null,
|
|
onFilterValueChange: null
|
|
});
|
|
|
|
function _createSuper$13(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$13(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$13() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var MegaMenu = /*#__PURE__*/function (_Component) {
|
|
_inherits(MegaMenu, _Component);
|
|
|
|
var _super = _createSuper$13(MegaMenu);
|
|
|
|
function MegaMenu(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, MegaMenu);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
activeItem: null
|
|
};
|
|
_this.onLeafClick = _this.onLeafClick.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(MegaMenu, [{
|
|
key: "onLeafClick",
|
|
value: function onLeafClick(event, item) {
|
|
if (item.disabled) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
if (!item.url) {
|
|
event.preventDefault();
|
|
}
|
|
|
|
if (item.command) {
|
|
item.command({
|
|
originalEvent: event,
|
|
item: item
|
|
});
|
|
}
|
|
|
|
this.setState({
|
|
activeItem: null
|
|
});
|
|
}
|
|
}, {
|
|
key: "onCategoryMouseEnter",
|
|
value: function onCategoryMouseEnter(event, item) {
|
|
if (item.disabled) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
if (this.state.activeItem) {
|
|
this.setState({
|
|
activeItem: item
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onCategoryClick",
|
|
value: function onCategoryClick(event, item) {
|
|
if (item.disabled) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
if (!item.url) {
|
|
event.preventDefault();
|
|
}
|
|
|
|
if (item.command) {
|
|
item.command({
|
|
originalEvent: event,
|
|
item: this.props.item
|
|
});
|
|
}
|
|
|
|
if (item.items) {
|
|
if (this.state.activeItem && this.state.activeItem === item) {
|
|
this.setState({
|
|
activeItem: null
|
|
});
|
|
} else {
|
|
this.setState({
|
|
activeItem: item
|
|
});
|
|
}
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onCategoryKeyDown",
|
|
value: function onCategoryKeyDown(event, item) {
|
|
var listItem = event.currentTarget.parentElement;
|
|
|
|
switch (event.which) {
|
|
//down
|
|
case 40:
|
|
if (this.isHorizontal()) this.expandMenu(item);else this.navigateToNextItem(listItem);
|
|
event.preventDefault();
|
|
break;
|
|
//up
|
|
|
|
case 38:
|
|
if (this.isVertical()) this.navigateToPrevItem(listItem);else if (item.items && item === this.state.activeItem) this.collapseMenu();
|
|
event.preventDefault();
|
|
break;
|
|
//right
|
|
|
|
case 39:
|
|
if (this.isHorizontal()) this.navigateToNextItem(listItem);else this.expandMenu(item);
|
|
event.preventDefault();
|
|
break;
|
|
//left
|
|
|
|
case 37:
|
|
if (this.isHorizontal()) this.navigateToPrevItem(listItem);else if (item.items && item === this.state.activeItem) this.collapseMenu();
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
}
|
|
}, {
|
|
key: "expandMenu",
|
|
value: function expandMenu(item) {
|
|
if (item.items) {
|
|
this.setState({
|
|
activeItem: item
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "collapseMenu",
|
|
value: function collapseMenu(item) {
|
|
this.setState({
|
|
activeItem: null
|
|
});
|
|
}
|
|
}, {
|
|
key: "findNextItem",
|
|
value: function findNextItem(item) {
|
|
var nextItem = item.nextElementSibling;
|
|
if (nextItem) return DomHandler.hasClass(nextItem, 'p-disabled') || !DomHandler.hasClass(nextItem, 'p-menuitem') ? this.findNextItem(nextItem) : nextItem;else return null;
|
|
}
|
|
}, {
|
|
key: "findPrevItem",
|
|
value: function findPrevItem(item) {
|
|
var prevItem = item.previousElementSibling;
|
|
if (prevItem) return DomHandler.hasClass(prevItem, 'p-disabled') || !DomHandler.hasClass(prevItem, 'p-menuitem') ? this.findPrevItem(prevItem) : prevItem;else return null;
|
|
}
|
|
}, {
|
|
key: "navigateToNextItem",
|
|
value: function navigateToNextItem(listItem) {
|
|
var nextItem = this.findNextItem(listItem);
|
|
|
|
if (nextItem) {
|
|
nextItem.children[0].focus();
|
|
}
|
|
}
|
|
}, {
|
|
key: "navigateToPrevItem",
|
|
value: function navigateToPrevItem(listItem) {
|
|
var prevItem = this.findPrevItem(listItem);
|
|
|
|
if (prevItem) {
|
|
prevItem.children[0].focus();
|
|
}
|
|
}
|
|
}, {
|
|
key: "isHorizontal",
|
|
value: function isHorizontal() {
|
|
return this.props.orientation === 'horizontal';
|
|
}
|
|
}, {
|
|
key: "isVertical",
|
|
value: function isVertical() {
|
|
return this.props.orientation === 'vertical';
|
|
}
|
|
}, {
|
|
key: "getColumnClassName",
|
|
value: function getColumnClassName(category) {
|
|
var length = category.items ? category.items.length : 0;
|
|
var columnClass;
|
|
|
|
switch (length) {
|
|
case 2:
|
|
columnClass = 'p-megamenu-col-6';
|
|
break;
|
|
|
|
case 3:
|
|
columnClass = 'p-megamenu-col-4';
|
|
break;
|
|
|
|
case 4:
|
|
columnClass = 'p-megamenu-col-3';
|
|
break;
|
|
|
|
case 6:
|
|
columnClass = 'p-megamenu-col-2';
|
|
break;
|
|
|
|
default:
|
|
columnClass = 'p-megamenu-col-12';
|
|
break;
|
|
}
|
|
|
|
return columnClass;
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
var _this2 = this;
|
|
|
|
if (!this.documentClickListener) {
|
|
this.documentClickListener = function (event) {
|
|
if (_this2.container && !_this2.container.contains(event.target)) {
|
|
_this2.setState({
|
|
activeItem: null
|
|
});
|
|
}
|
|
};
|
|
|
|
document.addEventListener('click', this.documentClickListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.documentClickListener) {
|
|
document.removeEventListener('click', this.documentClickListener);
|
|
this.documentClickListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderSeparator",
|
|
value: function renderSeparator(index) {
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: 'separator_' + index,
|
|
className: "p-menu-separator",
|
|
role: "separator"
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderSubmenuIcon",
|
|
value: function renderSubmenuIcon(item) {
|
|
if (item.items) {
|
|
var className = classNames('p-submenu-icon pi', {
|
|
'pi-angle-down': this.isHorizontal(),
|
|
'pi-angle-right': this.isVertical()
|
|
});
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: className
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderSubmenuItem",
|
|
value: function renderSubmenuItem(item, index) {
|
|
var _this3 = this;
|
|
|
|
if (item.separator) {
|
|
return this.renderSeparator(index);
|
|
} else {
|
|
var className = classNames('p-menuitem', item.className);
|
|
var linkClassName = classNames('p-menuitem-link', {
|
|
'p-disabled': item.disabled
|
|
});
|
|
var iconClassName = classNames(item.icon, 'p-menuitem-icon');
|
|
var icon = item.icon && /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
});
|
|
var label = item.label && /*#__PURE__*/React.createElement("span", {
|
|
className: "p-menuitem-text"
|
|
}, item.label);
|
|
var content = /*#__PURE__*/React.createElement("a", {
|
|
href: item.url || '#',
|
|
className: linkClassName,
|
|
target: item.target,
|
|
onClick: function onClick(event) {
|
|
return _this3.onLeafClick(event, item);
|
|
},
|
|
role: "menuitem",
|
|
"aria-disabled": item.disabled
|
|
}, icon, label, /*#__PURE__*/React.createElement(Ripple, null));
|
|
|
|
if (item.template) {
|
|
var defaultContentOptions = {
|
|
onClick: function onClick(event) {
|
|
return _this3.onLeafClick(event, item);
|
|
},
|
|
className: linkClassName,
|
|
labelClassName: 'p-menuitem-text',
|
|
iconClassName: iconClassName,
|
|
element: content,
|
|
props: this.props
|
|
};
|
|
content = ObjectUtils.getJSXElement(item.template, item, defaultContentOptions);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: item.label + '_' + index,
|
|
className: className,
|
|
style: item.style,
|
|
role: "none"
|
|
}, content);
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderSubmenu",
|
|
value: function renderSubmenu(submenu) {
|
|
var _this4 = this;
|
|
|
|
var className = classNames('p-megamenu-submenu-header', {
|
|
'p-disabled': submenu.disabled
|
|
}, submenu.className);
|
|
var items = submenu.items.map(function (item, index) {
|
|
return _this4.renderSubmenuItem(item, index);
|
|
});
|
|
return /*#__PURE__*/React.createElement(React.Fragment, {
|
|
key: submenu.label
|
|
}, /*#__PURE__*/React.createElement("li", {
|
|
className: className,
|
|
style: submenu.style,
|
|
role: "presentation",
|
|
"aria-disabled": submenu.disabled
|
|
}, submenu.label), items);
|
|
}
|
|
}, {
|
|
key: "renderSubmenus",
|
|
value: function renderSubmenus(column) {
|
|
var _this5 = this;
|
|
|
|
return column.map(function (submenu, index) {
|
|
return _this5.renderSubmenu(submenu, index);
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderColumn",
|
|
value: function renderColumn(category, column, index, columnClassName) {
|
|
var submenus = this.renderSubmenus(column);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
key: category.label + '_column_' + index,
|
|
className: columnClassName
|
|
}, /*#__PURE__*/React.createElement("ul", {
|
|
className: "p-megamenu-submenu",
|
|
role: "menu"
|
|
}, submenus));
|
|
}
|
|
}, {
|
|
key: "renderColumns",
|
|
value: function renderColumns(category) {
|
|
var _this6 = this;
|
|
|
|
if (category.items) {
|
|
var columnClassName = this.getColumnClassName(category);
|
|
return category.items.map(function (column, index) {
|
|
return _this6.renderColumn(category, column, index, columnClassName);
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderCategoryPanel",
|
|
value: function renderCategoryPanel(category) {
|
|
if (category.items) {
|
|
var columns = this.renderColumns(category);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-megamenu-panel"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-megamenu-grid"
|
|
}, columns));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderCategory",
|
|
value: function renderCategory(category, index) {
|
|
var _this7 = this;
|
|
|
|
var className = classNames('p-menuitem', {
|
|
'p-menuitem-active': category === this.state.activeItem
|
|
}, category.className);
|
|
var linkClassName = classNames('p-menuitem-link', {
|
|
'p-disabled': category.disabled
|
|
});
|
|
var iconClassName = classNames('p-menuitem-icon', category.icon);
|
|
var icon = category.icon && /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
});
|
|
var label = category.label && /*#__PURE__*/React.createElement("span", {
|
|
className: "p-menuitem-text"
|
|
}, category.label);
|
|
var itemContent = category.template ? ObjectUtils.getJSXElement(category.template, category) : null;
|
|
var submenuIcon = this.renderSubmenuIcon(category);
|
|
var panel = this.renderCategoryPanel(category);
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: category.label + '_' + index,
|
|
className: className,
|
|
style: category.style,
|
|
onMouseEnter: function onMouseEnter(e) {
|
|
return _this7.onCategoryMouseEnter(e, category);
|
|
},
|
|
role: "none"
|
|
}, /*#__PURE__*/React.createElement("a", {
|
|
href: category.url || '#',
|
|
className: linkClassName,
|
|
target: category.target,
|
|
onClick: function onClick(e) {
|
|
return _this7.onCategoryClick(e, category);
|
|
},
|
|
onKeyDown: function onKeyDown(e) {
|
|
return _this7.onCategoryKeyDown(e, category);
|
|
},
|
|
role: "menuitem",
|
|
"aria-haspopup": category.items != null
|
|
}, icon, label, itemContent, submenuIcon, /*#__PURE__*/React.createElement(Ripple, null)), panel);
|
|
}
|
|
}, {
|
|
key: "renderMenu",
|
|
value: function renderMenu() {
|
|
var _this8 = this;
|
|
|
|
if (this.props.model) {
|
|
return this.props.model.map(function (item, index) {
|
|
return _this8.renderCategory(item, index, true);
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderCustomContent",
|
|
value: function renderCustomContent() {
|
|
if (this.props.children) {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-megamenu-custom"
|
|
}, this.props.children);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this9 = this;
|
|
|
|
var className = classNames('p-megamenu p-component', {
|
|
'p-megamenu-horizontal': this.props.orientation === 'horizontal',
|
|
'p-megamenu-vertical': this.props.orientation === 'vertical'
|
|
}, this.props.className);
|
|
var menu = this.renderMenu();
|
|
var customContent = this.renderCustomContent();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this9.container = el;
|
|
},
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, /*#__PURE__*/React.createElement("ul", {
|
|
className: "p-megamenu-root-list",
|
|
role: "menubar"
|
|
}, menu), customContent);
|
|
}
|
|
}]);
|
|
|
|
return MegaMenu;
|
|
}(Component);
|
|
|
|
_defineProperty(MegaMenu, "defaultProps", {
|
|
id: null,
|
|
model: null,
|
|
style: null,
|
|
className: null,
|
|
orientation: 'horizontal'
|
|
});
|
|
|
|
function _createSuper$12(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$12(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$12() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Menu = /*#__PURE__*/function (_Component) {
|
|
_inherits(Menu, _Component);
|
|
|
|
var _super = _createSuper$12(Menu);
|
|
|
|
function Menu(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Menu);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
visible: !props.popup
|
|
};
|
|
_this.onEnter = _this.onEnter.bind(_assertThisInitialized(_this));
|
|
_this.onEntered = _this.onEntered.bind(_assertThisInitialized(_this));
|
|
_this.onExit = _this.onExit.bind(_assertThisInitialized(_this));
|
|
_this.onExited = _this.onExited.bind(_assertThisInitialized(_this));
|
|
_this.onPanelClick = _this.onPanelClick.bind(_assertThisInitialized(_this));
|
|
_this.menuRef = /*#__PURE__*/React.createRef();
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Menu, [{
|
|
key: "onPanelClick",
|
|
value: function onPanelClick(event) {
|
|
if (this.props.popup) {
|
|
OverlayService.emit('overlay-click', {
|
|
originalEvent: event,
|
|
target: this.target
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onItemClick",
|
|
value: function onItemClick(event, item) {
|
|
if (item.disabled) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
if (!item.url) {
|
|
event.preventDefault();
|
|
}
|
|
|
|
if (item.command) {
|
|
item.command({
|
|
originalEvent: event,
|
|
item: item
|
|
});
|
|
}
|
|
|
|
if (this.props.popup) {
|
|
this.hide(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onItemKeyDown",
|
|
value: function onItemKeyDown(event, item) {
|
|
var listItem = event.currentTarget.parentElement;
|
|
|
|
switch (event.which) {
|
|
//down
|
|
case 40:
|
|
var nextItem = this.findNextItem(listItem);
|
|
|
|
if (nextItem) {
|
|
nextItem.children[0].focus();
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//up
|
|
|
|
case 38:
|
|
var prevItem = this.findPrevItem(listItem);
|
|
|
|
if (prevItem) {
|
|
prevItem.children[0].focus();
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
}
|
|
}, {
|
|
key: "findNextItem",
|
|
value: function findNextItem(item) {
|
|
var nextItem = item.nextElementSibling;
|
|
if (nextItem) return DomHandler.hasClass(nextItem, 'p-disabled') || !DomHandler.hasClass(nextItem, 'p-menuitem') ? this.findNextItem(nextItem) : nextItem;else return null;
|
|
}
|
|
}, {
|
|
key: "findPrevItem",
|
|
value: function findPrevItem(item) {
|
|
var prevItem = item.previousElementSibling;
|
|
if (prevItem) return DomHandler.hasClass(prevItem, 'p-disabled') || !DomHandler.hasClass(prevItem, 'p-menuitem') ? this.findPrevItem(prevItem) : prevItem;else return null;
|
|
}
|
|
}, {
|
|
key: "toggle",
|
|
value: function toggle(event) {
|
|
if (this.props.popup) {
|
|
if (this.state.visible) this.hide(event);else this.show(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "show",
|
|
value: function show(event) {
|
|
var _this2 = this;
|
|
|
|
this.target = event.currentTarget;
|
|
var currentEvent = event;
|
|
this.setState({
|
|
visible: true
|
|
}, function () {
|
|
if (_this2.props.onShow) {
|
|
_this2.props.onShow(currentEvent);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "hide",
|
|
value: function hide(event) {
|
|
var _this3 = this;
|
|
|
|
var currentEvent = event;
|
|
this.setState({
|
|
visible: false
|
|
}, function () {
|
|
if (_this3.props.onHide) {
|
|
_this3.props.onHide(currentEvent);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onEnter",
|
|
value: function onEnter() {
|
|
ZIndexUtils.set('menu', this.menuRef.current, PrimeReact.autoZIndex, this.props.baseZIndex || PrimeReact.zIndex['menu']);
|
|
DomHandler.absolutePosition(this.menuRef.current, this.target);
|
|
}
|
|
}, {
|
|
key: "onEntered",
|
|
value: function onEntered() {
|
|
this.bindDocumentListeners();
|
|
this.bindScrollListener();
|
|
}
|
|
}, {
|
|
key: "onExit",
|
|
value: function onExit() {
|
|
this.target = null;
|
|
this.unbindDocumentListeners();
|
|
this.unbindScrollListener();
|
|
}
|
|
}, {
|
|
key: "onExited",
|
|
value: function onExited() {
|
|
ZIndexUtils.clear(this.menuRef.current);
|
|
}
|
|
}, {
|
|
key: "bindDocumentListeners",
|
|
value: function bindDocumentListeners() {
|
|
var _this4 = this;
|
|
|
|
if (!this.documentClickListener) {
|
|
this.documentClickListener = function (event) {
|
|
if (_this4.state.visible && _this4.isOutsideClicked(event)) {
|
|
_this4.hide(event);
|
|
}
|
|
};
|
|
|
|
document.addEventListener('click', this.documentClickListener);
|
|
}
|
|
|
|
if (!this.documentResizeListener) {
|
|
this.documentResizeListener = function (event) {
|
|
if (_this4.state.visible && !DomHandler.isTouchDevice()) {
|
|
_this4.hide(event);
|
|
}
|
|
};
|
|
|
|
window.addEventListener('resize', this.documentResizeListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentListeners",
|
|
value: function unbindDocumentListeners() {
|
|
if (this.documentClickListener) {
|
|
document.removeEventListener('click', this.documentClickListener);
|
|
this.documentClickListener = null;
|
|
}
|
|
|
|
if (this.documentResizeListener) {
|
|
window.removeEventListener('resize', this.documentResizeListener);
|
|
this.documentResizeListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindScrollListener",
|
|
value: function bindScrollListener() {
|
|
var _this5 = this;
|
|
|
|
if (!this.scrollHandler) {
|
|
this.scrollHandler = new ConnectedOverlayScrollHandler(this.target, function (event) {
|
|
if (_this5.state.visible) {
|
|
_this5.hide(event);
|
|
}
|
|
});
|
|
}
|
|
|
|
this.scrollHandler.bindScrollListener();
|
|
}
|
|
}, {
|
|
key: "unbindScrollListener",
|
|
value: function unbindScrollListener() {
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.unbindScrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "isOutsideClicked",
|
|
value: function isOutsideClicked(event) {
|
|
return this.menuRef && this.menuRef.current && !(this.menuRef.current.isSameNode(event.target) || this.menuRef.current.contains(event.target));
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.unbindDocumentListeners();
|
|
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.destroy();
|
|
this.scrollHandler = null;
|
|
}
|
|
|
|
ZIndexUtils.clear(this.menuRef.current);
|
|
}
|
|
}, {
|
|
key: "renderSubmenu",
|
|
value: function renderSubmenu(submenu, index) {
|
|
var _this6 = this;
|
|
|
|
var className = classNames('p-submenu-header', {
|
|
'p-disabled': submenu.disabled
|
|
}, submenu.className);
|
|
var items = submenu.items.map(function (item, index) {
|
|
return _this6.renderMenuitem(item, index);
|
|
});
|
|
return /*#__PURE__*/React.createElement(React.Fragment, {
|
|
key: submenu.label + '_' + index
|
|
}, /*#__PURE__*/React.createElement("li", {
|
|
className: className,
|
|
style: submenu.style,
|
|
role: "presentation",
|
|
"aria-disabled": submenu.disabled
|
|
}, submenu.label), items);
|
|
}
|
|
}, {
|
|
key: "renderSeparator",
|
|
value: function renderSeparator(index) {
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: 'separator_' + index,
|
|
className: "p-menu-separator",
|
|
role: "separator"
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderMenuitem",
|
|
value: function renderMenuitem(item, index) {
|
|
var _this7 = this;
|
|
|
|
var className = classNames('p-menuitem', item.className);
|
|
var linkClassName = classNames('p-menuitem-link', {
|
|
'p-disabled': item.disabled
|
|
});
|
|
var iconClassName = classNames('p-menuitem-icon', item.icon);
|
|
var icon = item.icon && /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
});
|
|
var label = item.label && /*#__PURE__*/React.createElement("span", {
|
|
className: "p-menuitem-text"
|
|
}, item.label);
|
|
var tabIndex = item.disabled ? null : 0;
|
|
var content = /*#__PURE__*/React.createElement("a", {
|
|
href: item.url || '#',
|
|
className: linkClassName,
|
|
role: "menuitem",
|
|
target: item.target,
|
|
onClick: function onClick(event) {
|
|
return _this7.onItemClick(event, item);
|
|
},
|
|
onKeyDown: function onKeyDown(event) {
|
|
return _this7.onItemKeyDown(event, item);
|
|
},
|
|
tabIndex: tabIndex,
|
|
"aria-disabled": item.disabled
|
|
}, icon, label);
|
|
|
|
if (item.template) {
|
|
var defaultContentOptions = {
|
|
onClick: function onClick(event) {
|
|
return _this7.onItemClick(event, item);
|
|
},
|
|
onKeyDown: function onKeyDown(event) {
|
|
return _this7.onItemKeyDown(event, item);
|
|
},
|
|
className: linkClassName,
|
|
tabIndex: tabIndex,
|
|
labelClassName: 'p-menuitem-text',
|
|
iconClassName: iconClassName,
|
|
element: content,
|
|
props: this.props
|
|
};
|
|
content = ObjectUtils.getJSXElement(item.template, item, defaultContentOptions);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: item.label + '_' + index,
|
|
className: className,
|
|
style: item.style,
|
|
role: "none"
|
|
}, content);
|
|
}
|
|
}, {
|
|
key: "renderItem",
|
|
value: function renderItem(item, index) {
|
|
if (item.separator) {
|
|
return this.renderSeparator(index);
|
|
} else {
|
|
if (item.items) return this.renderSubmenu(item, index);else return this.renderMenuitem(item, index);
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderMenu",
|
|
value: function renderMenu() {
|
|
var _this8 = this;
|
|
|
|
return this.props.model.map(function (item, index) {
|
|
return _this8.renderItem(item, index);
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
if (this.props.model) {
|
|
var className = classNames('p-menu p-component', this.props.className, {
|
|
'p-menu-overlay': this.props.popup
|
|
});
|
|
var menuitems = this.renderMenu();
|
|
return /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.menuRef,
|
|
classNames: "p-connected-overlay",
|
|
"in": this.state.visible,
|
|
timeout: {
|
|
enter: 120,
|
|
exit: 100
|
|
},
|
|
options: this.props.transitionOptions,
|
|
unmountOnExit: true,
|
|
onEnter: this.onEnter,
|
|
onEntered: this.onEntered,
|
|
onExit: this.onExit,
|
|
onExited: this.onExited
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.menuRef,
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style,
|
|
onClick: this.onPanelClick
|
|
}, /*#__PURE__*/React.createElement("ul", {
|
|
className: "p-menu-list p-reset",
|
|
role: "menu"
|
|
}, menuitems)));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var element = this.renderElement();
|
|
return this.props.popup ? /*#__PURE__*/React.createElement(Portal, {
|
|
element: element,
|
|
appendTo: this.props.appendTo
|
|
}) : element;
|
|
}
|
|
}]);
|
|
|
|
return Menu;
|
|
}(Component);
|
|
|
|
_defineProperty(Menu, "defaultProps", {
|
|
id: null,
|
|
model: null,
|
|
popup: false,
|
|
style: null,
|
|
className: null,
|
|
autoZIndex: true,
|
|
baseZIndex: 0,
|
|
appendTo: null,
|
|
transitionOptions: null,
|
|
onShow: null,
|
|
onHide: null
|
|
});
|
|
|
|
function _createSuper$11(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$11(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$11() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var MenubarSubComponent = /*#__PURE__*/function (_Component) {
|
|
_inherits(MenubarSubComponent, _Component);
|
|
|
|
var _super = _createSuper$11(MenubarSubComponent);
|
|
|
|
function MenubarSubComponent(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, MenubarSubComponent);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
activeItem: null
|
|
};
|
|
_this.onLeafClick = _this.onLeafClick.bind(_assertThisInitialized(_this));
|
|
_this.onChildItemKeyDown = _this.onChildItemKeyDown.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(MenubarSubComponent, [{
|
|
key: "getElementRef",
|
|
value: function getElementRef(el) {
|
|
this.element = el;
|
|
|
|
if (this.props.forwardRef) {
|
|
return this.props.forwardRef(el);
|
|
}
|
|
|
|
return this.element;
|
|
}
|
|
}, {
|
|
key: "onItemMouseEnter",
|
|
value: function onItemMouseEnter(event, item) {
|
|
if (item.disabled || this.props.mobileActive) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
if (this.props.root) {
|
|
if (this.state.activeItem || this.props.popup) {
|
|
this.setState({
|
|
activeItem: item
|
|
});
|
|
}
|
|
} else {
|
|
this.setState({
|
|
activeItem: item
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onItemClick",
|
|
value: function onItemClick(event, item) {
|
|
if (item.disabled) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
if (!item.url) {
|
|
event.preventDefault();
|
|
}
|
|
|
|
if (item.command) {
|
|
item.command({
|
|
originalEvent: event,
|
|
item: item
|
|
});
|
|
}
|
|
|
|
if (item.items) {
|
|
if (this.state.activeItem && item === this.state.activeItem) {
|
|
this.setState({
|
|
activeItem: null
|
|
});
|
|
} else {
|
|
this.setState({
|
|
activeItem: item
|
|
});
|
|
}
|
|
} else {
|
|
this.onLeafClick();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onItemKeyDown",
|
|
value: function onItemKeyDown(event, item) {
|
|
var listItem = event.currentTarget.parentElement;
|
|
|
|
switch (event.which) {
|
|
//down
|
|
case 40:
|
|
if (this.props.root) {
|
|
if (item.items) {
|
|
this.expandSubmenu(item, listItem);
|
|
}
|
|
} else {
|
|
this.navigateToNextItem(listItem);
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//up
|
|
|
|
case 38:
|
|
if (!this.props.root) {
|
|
this.navigateToPrevItem(listItem);
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//right
|
|
|
|
case 39:
|
|
if (this.props.root) {
|
|
var nextItem = this.findNextItem(listItem);
|
|
|
|
if (nextItem) {
|
|
nextItem.children[0].focus();
|
|
}
|
|
} else {
|
|
if (item.items) {
|
|
this.expandSubmenu(item, listItem);
|
|
}
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//left
|
|
|
|
case 37:
|
|
if (this.props.root) {
|
|
this.navigateToPrevItem(listItem);
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
|
|
if (this.props.onKeyDown) {
|
|
this.props.onKeyDown(event, listItem);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onChildItemKeyDown",
|
|
value: function onChildItemKeyDown(event, childListItem) {
|
|
if (this.props.root) {
|
|
//up
|
|
if (event.which === 38 && childListItem.previousElementSibling == null) {
|
|
this.collapseMenu(childListItem);
|
|
}
|
|
} else {
|
|
//left
|
|
if (event.which === 37) {
|
|
this.collapseMenu(childListItem);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "expandSubmenu",
|
|
value: function expandSubmenu(item, listItem) {
|
|
this.setState({
|
|
activeItem: item
|
|
});
|
|
setTimeout(function () {
|
|
listItem.children[1].children[0].children[0].focus();
|
|
}, 50);
|
|
}
|
|
}, {
|
|
key: "collapseMenu",
|
|
value: function collapseMenu(listItem) {
|
|
this.setState({
|
|
activeItem: null
|
|
});
|
|
listItem.parentElement.previousElementSibling.focus();
|
|
}
|
|
}, {
|
|
key: "navigateToNextItem",
|
|
value: function navigateToNextItem(listItem) {
|
|
var nextItem = this.findNextItem(listItem);
|
|
|
|
if (nextItem) {
|
|
nextItem.children[0].focus();
|
|
}
|
|
}
|
|
}, {
|
|
key: "navigateToPrevItem",
|
|
value: function navigateToPrevItem(listItem) {
|
|
var prevItem = this.findPrevItem(listItem);
|
|
|
|
if (prevItem) {
|
|
prevItem.children[0].focus();
|
|
}
|
|
}
|
|
}, {
|
|
key: "findNextItem",
|
|
value: function findNextItem(item) {
|
|
var nextItem = item.nextElementSibling;
|
|
if (nextItem) return DomHandler.hasClass(nextItem, 'p-disabled') || !DomHandler.hasClass(nextItem, 'p-menuitem') ? this.findNextItem(nextItem) : nextItem;else return null;
|
|
}
|
|
}, {
|
|
key: "findPrevItem",
|
|
value: function findPrevItem(item) {
|
|
var prevItem = item.previousElementSibling;
|
|
if (prevItem) return DomHandler.hasClass(prevItem, 'p-disabled') || !DomHandler.hasClass(prevItem, 'p-menuitem') ? this.findPrevItem(prevItem) : prevItem;else return null;
|
|
}
|
|
}, {
|
|
key: "onLeafClick",
|
|
value: function onLeafClick() {
|
|
this.setState({
|
|
activeItem: null
|
|
});
|
|
|
|
if (this.props.onLeafClick) {
|
|
this.props.onLeafClick();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
var _this2 = this;
|
|
|
|
if (!this.documentClickListener) {
|
|
this.documentClickListener = function (event) {
|
|
if (_this2.element && !_this2.element.contains(event.target)) {
|
|
_this2.setState({
|
|
activeItem: null
|
|
});
|
|
}
|
|
};
|
|
|
|
document.addEventListener('click', this.documentClickListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.parentActive && !this.props.parentActive) {
|
|
this.setState({
|
|
activeItem: null
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.documentClickListener) {
|
|
document.removeEventListener('click', this.documentClickListener);
|
|
this.documentClickListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderSeparator",
|
|
value: function renderSeparator(index) {
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: 'separator_' + index,
|
|
className: "p-menu-separator",
|
|
role: "separator"
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderSubmenu",
|
|
value: function renderSubmenu(item) {
|
|
if (item.items) {
|
|
return /*#__PURE__*/React.createElement(MenubarSub, {
|
|
model: item.items,
|
|
mobileActive: this.props.mobileActive,
|
|
onLeafClick: this.onLeafClick,
|
|
onKeyDown: this.onChildItemKeyDown,
|
|
parentActive: item === this.state.activeItem
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderMenuitem",
|
|
value: function renderMenuitem(item, index) {
|
|
var _this3 = this;
|
|
|
|
var className = classNames('p-menuitem', {
|
|
'p-menuitem-active': this.state.activeItem === item
|
|
}, item.className);
|
|
var linkClassName = classNames('p-menuitem-link', {
|
|
'p-disabled': item.disabled
|
|
});
|
|
var iconClassName = classNames('p-menuitem-icon', item.icon);
|
|
var submenuIconClassName = classNames('p-submenu-icon pi', {
|
|
'pi-angle-down': this.props.root,
|
|
'pi-angle-right': !this.props.root
|
|
});
|
|
var icon = item.icon && /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
});
|
|
var label = item.label && /*#__PURE__*/React.createElement("span", {
|
|
className: "p-menuitem-text"
|
|
}, item.label);
|
|
var submenuIcon = item.items && /*#__PURE__*/React.createElement("span", {
|
|
className: submenuIconClassName
|
|
});
|
|
var submenu = this.renderSubmenu(item);
|
|
var content = /*#__PURE__*/React.createElement("a", {
|
|
href: item.url || '#',
|
|
role: "menuitem",
|
|
className: linkClassName,
|
|
target: item.target,
|
|
"aria-haspopup": item.items != null,
|
|
onClick: function onClick(event) {
|
|
return _this3.onItemClick(event, item);
|
|
},
|
|
onKeyDown: function onKeyDown(event) {
|
|
return _this3.onItemKeyDown(event, item);
|
|
}
|
|
}, icon, label, submenuIcon, /*#__PURE__*/React.createElement(Ripple, null));
|
|
|
|
if (item.template) {
|
|
var defaultContentOptions = {
|
|
onClick: function onClick(event) {
|
|
return _this3.onItemClick(event, item);
|
|
},
|
|
onKeyDown: function onKeyDown(event) {
|
|
return _this3.onItemKeyDown(event, item);
|
|
},
|
|
className: linkClassName,
|
|
labelClassName: 'p-menuitem-text',
|
|
iconClassName: iconClassName,
|
|
submenuIconClassName: submenuIconClassName,
|
|
element: content,
|
|
props: this.props
|
|
};
|
|
content = ObjectUtils.getJSXElement(item.template, item, defaultContentOptions);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: item.label + '_' + index,
|
|
role: "none",
|
|
className: className,
|
|
style: item.style,
|
|
onMouseEnter: function onMouseEnter(event) {
|
|
return _this3.onItemMouseEnter(event, item);
|
|
}
|
|
}, content, submenu);
|
|
}
|
|
}, {
|
|
key: "renderItem",
|
|
value: function renderItem(item, index) {
|
|
if (item.separator) return this.renderSeparator(index);else return this.renderMenuitem(item, index);
|
|
}
|
|
}, {
|
|
key: "renderMenu",
|
|
value: function renderMenu() {
|
|
var _this4 = this;
|
|
|
|
if (this.props.model) {
|
|
return this.props.model.map(function (item, index) {
|
|
return _this4.renderItem(item, index);
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this5 = this;
|
|
|
|
var className = classNames({
|
|
'p-submenu-list': !this.props.root,
|
|
'p-menubar-root-list': this.props.root
|
|
});
|
|
var submenu = this.renderMenu();
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
ref: function ref(el) {
|
|
return _this5.getElementRef(el);
|
|
},
|
|
className: className,
|
|
role: this.props.root ? 'menubar' : 'menu'
|
|
}, submenu);
|
|
}
|
|
}]);
|
|
|
|
return MenubarSubComponent;
|
|
}(Component);
|
|
|
|
_defineProperty(MenubarSubComponent, "defaultProps", {
|
|
model: null,
|
|
root: false,
|
|
className: null,
|
|
popup: false,
|
|
onLeafClick: null,
|
|
onKeyDown: null,
|
|
parentActive: false,
|
|
mobileActive: false,
|
|
forwardRef: null
|
|
});
|
|
|
|
var MenubarSub = /*#__PURE__*/React.forwardRef(function (props, ref) {
|
|
return /*#__PURE__*/React.createElement(MenubarSubComponent, _extends({
|
|
forwardRef: ref
|
|
}, props));
|
|
});
|
|
|
|
function _createSuper$10(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$10(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$10() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Menubar = /*#__PURE__*/function (_Component) {
|
|
_inherits(Menubar, _Component);
|
|
|
|
var _super = _createSuper$10(Menubar);
|
|
|
|
function Menubar(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Menubar);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
mobileActive: false
|
|
};
|
|
_this.toggle = _this.toggle.bind(_assertThisInitialized(_this));
|
|
_this.onLeafClick = _this.onLeafClick.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Menubar, [{
|
|
key: "toggle",
|
|
value: function toggle(event) {
|
|
var _this2 = this;
|
|
|
|
event.preventDefault();
|
|
this.setState(function (prevState) {
|
|
return {
|
|
mobileActive: !prevState.mobileActive
|
|
};
|
|
}, function () {
|
|
if (_this2.state.mobileActive) {
|
|
ZIndexUtils.set('menu', _this2.rootmenu, PrimeReact.autoZIndex, PrimeReact.zIndex['menu']);
|
|
|
|
_this2.bindDocumentClickListener();
|
|
} else {
|
|
_this2.unbindDocumentClickListener();
|
|
|
|
ZIndexUtils.clear(_this2.rootmenu);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "bindDocumentClickListener",
|
|
value: function bindDocumentClickListener() {
|
|
var _this3 = this;
|
|
|
|
if (!this.documentClickListener) {
|
|
this.documentClickListener = function (event) {
|
|
if (_this3.state.mobileActive && _this3.isOutsideClicked(event)) {
|
|
_this3.setState({
|
|
mobileActive: false
|
|
}, function () {
|
|
_this3.unbindDocumentClickListener();
|
|
|
|
ZIndexUtils.clear(_this3.rootmenu);
|
|
});
|
|
}
|
|
};
|
|
|
|
document.addEventListener('click', this.documentClickListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "isOutsideClicked",
|
|
value: function isOutsideClicked(event) {
|
|
return this.rootmenu !== event.target && !this.rootmenu.contains(event.target) && this.menubutton !== event.target && !this.menubutton.contains(event.target);
|
|
}
|
|
}, {
|
|
key: "unbindDocumentClickListener",
|
|
value: function unbindDocumentClickListener() {
|
|
if (this.documentClickListener) {
|
|
document.removeEventListener('click', this.documentClickListener);
|
|
this.documentClickListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "onLeafClick",
|
|
value: function onLeafClick() {
|
|
var _this4 = this;
|
|
|
|
this.setState({
|
|
mobileActive: false
|
|
}, function () {
|
|
_this4.unbindDocumentClickListener();
|
|
|
|
ZIndexUtils.clear(_this4.rootmenu);
|
|
});
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
ZIndexUtils.clear(this.rootmenu);
|
|
}
|
|
}, {
|
|
key: "renderCustomContent",
|
|
value: function renderCustomContent() {
|
|
if (this.props.children) {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-menubar-custom"
|
|
}, this.props.children);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderStartContent",
|
|
value: function renderStartContent() {
|
|
if (this.props.start) {
|
|
var start = ObjectUtils.getJSXElement(this.props.start, this.props);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-menubar-start"
|
|
}, start);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderEndContent",
|
|
value: function renderEndContent() {
|
|
if (this.props.end) {
|
|
var end = ObjectUtils.getJSXElement(this.props.end, this.props);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-menubar-end"
|
|
}, end);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderMenuButton",
|
|
value: function renderMenuButton() {
|
|
var _this5 = this;
|
|
|
|
/* eslint-disable */
|
|
var button = /*#__PURE__*/React.createElement("a", {
|
|
ref: function ref(el) {
|
|
return _this5.menubutton = el;
|
|
},
|
|
href: '#',
|
|
role: "button",
|
|
tabIndex: 0,
|
|
className: "p-menubar-button",
|
|
onClick: this.toggle
|
|
}, /*#__PURE__*/React.createElement("i", {
|
|
className: "pi pi-bars"
|
|
}));
|
|
/* eslint-enable */
|
|
|
|
return button;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this6 = this;
|
|
|
|
var className = classNames('p-menubar p-component', {
|
|
'p-menubar-mobile-active': this.state.mobileActive
|
|
}, this.props.className);
|
|
var start = this.renderStartContent();
|
|
var end = this.renderEndContent();
|
|
var menuButton = this.renderMenuButton();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, start, menuButton, /*#__PURE__*/React.createElement(MenubarSub, {
|
|
ref: function ref(el) {
|
|
return _this6.rootmenu = el;
|
|
},
|
|
model: this.props.model,
|
|
root: true,
|
|
mobileActive: this.state.mobileActive,
|
|
onLeafClick: this.onLeafClick
|
|
}), end);
|
|
}
|
|
}]);
|
|
|
|
return Menubar;
|
|
}(Component);
|
|
|
|
_defineProperty(Menubar, "defaultProps", {
|
|
id: null,
|
|
model: null,
|
|
style: null,
|
|
className: null,
|
|
start: null,
|
|
end: null
|
|
});
|
|
|
|
function _createSuper$$(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$$(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$$() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Message = /*#__PURE__*/function (_Component) {
|
|
_inherits(Message, _Component);
|
|
|
|
var _super = _createSuper$$(Message);
|
|
|
|
function Message() {
|
|
_classCallCheck(this, Message);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(Message, [{
|
|
key: "getContent",
|
|
value: function getContent() {
|
|
if (this.props.content) {
|
|
return ObjectUtils.getJSXElement(this.props.content, this.props);
|
|
}
|
|
|
|
var text = ObjectUtils.getJSXElement(this.props.text, this.props);
|
|
var icon = classNames('p-inline-message-icon pi', {
|
|
'pi-info-circle': this.props.severity === 'info',
|
|
'pi-exclamation-triangle': this.props.severity === 'warn',
|
|
'pi-times-circle': this.props.severity === 'error',
|
|
'pi-check': this.props.severity === 'success'
|
|
});
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("span", {
|
|
className: icon
|
|
}), /*#__PURE__*/React.createElement("span", {
|
|
className: "p-inline-message-text"
|
|
}, text));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-inline-message p-component', {
|
|
'p-inline-message-info': this.props.severity === 'info',
|
|
'p-inline-message-warn': this.props.severity === 'warn',
|
|
'p-inline-message-error': this.props.severity === 'error',
|
|
'p-inline-message-success': this.props.severity === 'success',
|
|
'p-inline-message-icon-only': !this.props.text
|
|
}, this.props.className);
|
|
var content = this.getContent();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
"aria-live": "polite",
|
|
className: className,
|
|
style: this.props.style,
|
|
role: "alert"
|
|
}, content);
|
|
}
|
|
}]);
|
|
|
|
return Message;
|
|
}(Component);
|
|
|
|
_defineProperty(Message, "defaultProps", {
|
|
id: null,
|
|
className: null,
|
|
style: null,
|
|
text: null,
|
|
severity: 'info',
|
|
content: null
|
|
});
|
|
|
|
function _createSuper$_(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$_(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$_() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var MultiSelectHeader = /*#__PURE__*/function (_Component) {
|
|
_inherits(MultiSelectHeader, _Component);
|
|
|
|
var _super = _createSuper$_(MultiSelectHeader);
|
|
|
|
function MultiSelectHeader(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, MultiSelectHeader);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onFilter = _this.onFilter.bind(_assertThisInitialized(_this));
|
|
_this.onSelectAll = _this.onSelectAll.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(MultiSelectHeader, [{
|
|
key: "onFilter",
|
|
value: function onFilter(event) {
|
|
if (this.props.onFilter) {
|
|
this.props.onFilter({
|
|
originalEvent: event,
|
|
query: event.target.value
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onSelectAll",
|
|
value: function onSelectAll(event) {
|
|
if (this.props.onSelectAll) {
|
|
this.props.onSelectAll({
|
|
originalEvent: event,
|
|
checked: this.props.selectAll
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderFilterElement",
|
|
value: function renderFilterElement() {
|
|
if (this.props.filter) {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-multiselect-filter-container"
|
|
}, /*#__PURE__*/React.createElement(InputText, {
|
|
type: "text",
|
|
role: "textbox",
|
|
value: this.props.filterValue,
|
|
onChange: this.onFilter,
|
|
className: "p-multiselect-filter",
|
|
placeholder: this.props.filterPlaceholder
|
|
}), /*#__PURE__*/React.createElement("span", {
|
|
className: "p-multiselect-filter-icon pi pi-search"
|
|
}));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var filterElement = this.renderFilterElement();
|
|
var checkboxElement = this.props.showSelectAll && /*#__PURE__*/React.createElement(Checkbox, {
|
|
checked: this.props.selectAll,
|
|
onChange: this.onSelectAll,
|
|
role: "checkbox",
|
|
"aria-checked": this.props.selectAll
|
|
});
|
|
var closeElement = /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "p-multiselect-close p-link",
|
|
onClick: this.props.onClose
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-multiselect-close-icon pi pi-times"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
var element = /*#__PURE__*/React.createElement("div", {
|
|
className: "p-multiselect-header"
|
|
}, checkboxElement, filterElement, closeElement);
|
|
|
|
if (this.props.template) {
|
|
var defaultOptions = {
|
|
className: 'p-multiselect-header',
|
|
checkboxElement: checkboxElement,
|
|
checked: this.props.selectAll,
|
|
onChange: this.onSelectAll,
|
|
filterElement: filterElement,
|
|
closeElement: closeElement,
|
|
closeElementClassName: 'p-multiselect-close p-link',
|
|
closeIconClassName: 'p-multiselect-close-icon pi pi-times',
|
|
onCloseClick: this.props.onClose,
|
|
element: element,
|
|
props: this.props
|
|
};
|
|
return ObjectUtils.getJSXElement(this.props.template, defaultOptions);
|
|
}
|
|
|
|
return element;
|
|
}
|
|
}]);
|
|
|
|
return MultiSelectHeader;
|
|
}(Component);
|
|
|
|
function _createSuper$Z(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$Z(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$Z() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var MultiSelectItem = /*#__PURE__*/function (_Component) {
|
|
_inherits(MultiSelectItem, _Component);
|
|
|
|
var _super = _createSuper$Z(MultiSelectItem);
|
|
|
|
function MultiSelectItem(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, MultiSelectItem);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(MultiSelectItem, [{
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
if (this.props.onClick) {
|
|
this.props.onClick({
|
|
originalEvent: event,
|
|
option: this.props.option
|
|
});
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event) {
|
|
if (this.props.onKeyDown) {
|
|
this.props.onKeyDown({
|
|
originalEvent: event,
|
|
option: this.props.option
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-multiselect-item', {
|
|
'p-highlight': this.props.selected,
|
|
'p-disabled': this.props.disabled
|
|
}, this.props.option.className);
|
|
var checkboxClassName = classNames('p-checkbox-box', {
|
|
'p-highlight': this.props.selected
|
|
});
|
|
var checkboxIcon = classNames('p-checkbox-icon p-c', {
|
|
'pi pi-check': this.props.selected
|
|
});
|
|
var content = this.props.template ? ObjectUtils.getJSXElement(this.props.template, this.props.option) : this.props.label;
|
|
var tabIndex = this.props.disabled ? null : this.props.tabIndex || 0;
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
className: className,
|
|
onClick: this.onClick,
|
|
tabIndex: tabIndex,
|
|
onKeyDown: this.onKeyDown,
|
|
role: "option",
|
|
"aria-selected": this.props.selected
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-checkbox p-component"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: checkboxClassName
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: checkboxIcon
|
|
}))), /*#__PURE__*/React.createElement("span", null, content), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
}]);
|
|
|
|
return MultiSelectItem;
|
|
}(Component);
|
|
|
|
_defineProperty(MultiSelectItem, "defaultProps", {
|
|
option: null,
|
|
label: null,
|
|
selected: false,
|
|
disabled: false,
|
|
tabIndex: null,
|
|
template: null,
|
|
onClick: null,
|
|
onKeyDown: null
|
|
});
|
|
|
|
function ownKeys$k(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$k(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$k(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$k(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$Y(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$Y(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$Y() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
var MultiSelectPanelComponent = /*#__PURE__*/function (_Component) {
|
|
_inherits(MultiSelectPanelComponent, _Component);
|
|
|
|
var _super = _createSuper$Y(MultiSelectPanelComponent);
|
|
|
|
function MultiSelectPanelComponent(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, MultiSelectPanelComponent);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onEnter = _this.onEnter.bind(_assertThisInitialized(_this));
|
|
_this.onFilterInputChange = _this.onFilterInputChange.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(MultiSelectPanelComponent, [{
|
|
key: "onEnter",
|
|
value: function onEnter() {
|
|
var _this2 = this;
|
|
|
|
this.props.onEnter(function () {
|
|
if (_this2.virtualScrollerRef) {
|
|
var selectedIndex = _this2.props.getSelectedOptionIndex();
|
|
|
|
if (selectedIndex !== -1) {
|
|
_this2.virtualScrollerRef.scrollToIndex(selectedIndex);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onFilterInputChange",
|
|
value: function onFilterInputChange(event) {
|
|
if (this.virtualScrollerRef) {
|
|
this.virtualScrollerRef.scrollToIndex(0);
|
|
}
|
|
|
|
this.props.onFilterInputChange && this.props.onFilterInputChange(event);
|
|
}
|
|
}, {
|
|
key: "isEmptyFilter",
|
|
value: function isEmptyFilter() {
|
|
return !(this.props.visibleOptions && this.props.visibleOptions.length) && this.props.hasFilter();
|
|
}
|
|
}, {
|
|
key: "renderHeader",
|
|
value: function renderHeader() {
|
|
return /*#__PURE__*/React.createElement(MultiSelectHeader, {
|
|
filter: this.props.filter,
|
|
filterValue: this.props.filterValue,
|
|
onFilter: this.onFilterInputChange,
|
|
filterPlaceholder: this.props.filterPlaceholder,
|
|
onClose: this.props.onCloseClick,
|
|
showSelectAll: this.props.showSelectAll,
|
|
selectAll: this.props.isAllSelected(),
|
|
onSelectAll: this.props.onSelectAll,
|
|
template: this.props.panelHeaderTemplate
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderFooter",
|
|
value: function renderFooter() {
|
|
if (this.props.panelFooterTemplate) {
|
|
var content = ObjectUtils.getJSXElement(this.props.panelFooterTemplate, this.props, this.props.onOverlayHide);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-multiselect-footer"
|
|
}, content);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderGroupChildren",
|
|
value: function renderGroupChildren(optionGroup) {
|
|
var _this3 = this;
|
|
|
|
var groupChildren = this.props.getOptionGroupChildren(optionGroup);
|
|
return groupChildren.map(function (option, j) {
|
|
var optionLabel = _this3.props.getOptionLabel(option);
|
|
|
|
var optionKey = j + '_' + _this3.props.getOptionRenderKey(option);
|
|
|
|
var disabled = _this3.props.isOptionDisabled(option);
|
|
|
|
var tabIndex = disabled ? null : _this3.props.tabIndex || 0;
|
|
return /*#__PURE__*/React.createElement(MultiSelectItem, {
|
|
key: optionKey,
|
|
label: optionLabel,
|
|
option: option,
|
|
template: _this3.props.itemTemplate,
|
|
selected: _this3.props.isSelected(option),
|
|
onClick: _this3.props.onOptionSelect,
|
|
onKeyDown: _this3.props.onOptionKeyDown,
|
|
tabIndex: tabIndex,
|
|
disabled: disabled
|
|
});
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderEmptyFilter",
|
|
value: function renderEmptyFilter() {
|
|
var emptyFilterMessage = ObjectUtils.getJSXElement(this.props.emptyFilterMessage, this.props) || localeOption('emptyFilterMessage');
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
className: "p-multiselect-empty-message"
|
|
}, emptyFilterMessage);
|
|
}
|
|
}, {
|
|
key: "renderItem",
|
|
value: function renderItem(option, index) {
|
|
if (this.props.optionGroupLabel) {
|
|
var groupContent = this.props.optionGroupTemplate ? ObjectUtils.getJSXElement(this.props.optionGroupTemplate, option, index) : this.props.getOptionGroupLabel(option);
|
|
var groupChildrenContent = this.renderGroupChildren(option);
|
|
var key = index + '_' + this.props.getOptionGroupRenderKey(option);
|
|
return /*#__PURE__*/React.createElement(React.Fragment, {
|
|
key: key
|
|
}, /*#__PURE__*/React.createElement("li", {
|
|
className: "p-multiselect-item-group"
|
|
}, groupContent), groupChildrenContent);
|
|
} else {
|
|
var optionLabel = this.props.getOptionLabel(option);
|
|
var optionKey = index + '_' + this.props.getOptionRenderKey(option);
|
|
var disabled = this.props.isOptionDisabled(option);
|
|
var tabIndex = disabled ? null : this.props.tabIndex || 0;
|
|
return /*#__PURE__*/React.createElement(MultiSelectItem, {
|
|
key: optionKey,
|
|
label: optionLabel,
|
|
option: option,
|
|
template: this.props.itemTemplate,
|
|
selected: this.props.isSelected(option),
|
|
onClick: this.props.onOptionSelect,
|
|
onKeyDown: this.props.onOptionKeyDown,
|
|
tabIndex: tabIndex,
|
|
disabled: disabled
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderItems",
|
|
value: function renderItems() {
|
|
var _this4 = this;
|
|
|
|
if (this.props.visibleOptions && this.props.visibleOptions.length) {
|
|
return this.props.visibleOptions.map(function (option, index) {
|
|
return _this4.renderItem(option, index);
|
|
});
|
|
} else if (this.props.hasFilter()) {
|
|
return this.renderEmptyFilter();
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
var _this5 = this;
|
|
|
|
if (this.props.virtualScrollerOptions) {
|
|
var virtualScrollerProps = _objectSpread$k(_objectSpread$k({}, this.props.virtualScrollerOptions), {
|
|
style: _objectSpread$k(_objectSpread$k({}, this.props.virtualScrollerOptions.style), {
|
|
height: this.props.scrollHeight
|
|
}),
|
|
className: classNames('p-multiselect-items-wrapper', this.props.virtualScrollerOptions.className),
|
|
items: this.props.visibleOptions,
|
|
onLazyLoad: function onLazyLoad(event) {
|
|
return _this5.props.virtualScrollerOptions.onLazyLoad(_objectSpread$k(_objectSpread$k({}, event), {
|
|
filter: _this5.props.filterValue
|
|
}));
|
|
},
|
|
itemTemplate: function itemTemplate(item, options) {
|
|
return item && _this5.renderItem(item, options.index);
|
|
},
|
|
contentTemplate: function contentTemplate(options) {
|
|
var className = classNames('p-multiselect-items p-component', options.className);
|
|
var content = _this5.isEmptyFilter() ? _this5.renderEmptyFilter() : options.children;
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
ref: options.contentRef,
|
|
className: className,
|
|
role: "listbox",
|
|
"aria-multiselectable": true
|
|
}, content);
|
|
}
|
|
});
|
|
|
|
return /*#__PURE__*/React.createElement(VirtualScroller, _extends({
|
|
ref: function ref(el) {
|
|
return _this5.virtualScrollerRef = el;
|
|
}
|
|
}, virtualScrollerProps));
|
|
} else {
|
|
var items = this.renderItems();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-multiselect-items-wrapper",
|
|
style: {
|
|
maxHeight: this.props.scrollHeight
|
|
}
|
|
}, /*#__PURE__*/React.createElement("ul", {
|
|
className: "p-multiselect-items p-component",
|
|
role: "listbox",
|
|
"aria-multiselectable": true
|
|
}, items));
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
var panelClassName = classNames('p-multiselect-panel p-component', {
|
|
'p-multiselect-limited': !this.props.allowOptionSelect()
|
|
}, this.props.panelClassName);
|
|
var header = this.renderHeader();
|
|
var content = this.renderContent();
|
|
var footer = this.renderFooter();
|
|
return /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.props.forwardRef,
|
|
classNames: "p-connected-overlay",
|
|
"in": this.props["in"],
|
|
timeout: {
|
|
enter: 120,
|
|
exit: 100
|
|
},
|
|
options: this.props.transitionOptions,
|
|
unmountOnExit: true,
|
|
onEnter: this.onEnter,
|
|
onEntered: this.props.onEntered,
|
|
onExit: this.props.onExit,
|
|
onExited: this.props.onExited
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.props.forwardRef,
|
|
className: panelClassName,
|
|
style: this.props.panelStyle,
|
|
onClick: this.props.onClick
|
|
}, header, content, footer));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var element = this.renderElement();
|
|
return /*#__PURE__*/React.createElement(Portal, {
|
|
element: element,
|
|
appendTo: this.props.appendTo
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return MultiSelectPanelComponent;
|
|
}(Component);
|
|
|
|
var MultiSelectPanel = /*#__PURE__*/React.forwardRef(function (props, ref) {
|
|
return /*#__PURE__*/React.createElement(MultiSelectPanelComponent, _extends({
|
|
forwardRef: ref
|
|
}, props));
|
|
});
|
|
|
|
function ownKeys$j(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$j(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$j(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$j(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createForOfIteratorHelper$8(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$8(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$8(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$8(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$8(o, minLen); }
|
|
|
|
function _arrayLikeToArray$8(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 _createSuper$X(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$X(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$X() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var MultiSelect = /*#__PURE__*/function (_Component) {
|
|
_inherits(MultiSelect, _Component);
|
|
|
|
var _super = _createSuper$X(MultiSelect);
|
|
|
|
function MultiSelect(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, MultiSelect);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
filter: '',
|
|
focused: false,
|
|
overlayVisible: false
|
|
};
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onOptionSelect = _this.onOptionSelect.bind(_assertThisInitialized(_this));
|
|
_this.onOptionKeyDown = _this.onOptionKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onFocus = _this.onFocus.bind(_assertThisInitialized(_this));
|
|
_this.onBlur = _this.onBlur.bind(_assertThisInitialized(_this));
|
|
_this.onFilterInputChange = _this.onFilterInputChange.bind(_assertThisInitialized(_this));
|
|
_this.onCloseClick = _this.onCloseClick.bind(_assertThisInitialized(_this));
|
|
_this.onSelectAll = _this.onSelectAll.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEnter = _this.onOverlayEnter.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEntered = _this.onOverlayEntered.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExit = _this.onOverlayExit.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExited = _this.onOverlayExited.bind(_assertThisInitialized(_this));
|
|
_this.onPanelClick = _this.onPanelClick.bind(_assertThisInitialized(_this));
|
|
_this.getOptionLabel = _this.getOptionLabel.bind(_assertThisInitialized(_this));
|
|
_this.getOptionRenderKey = _this.getOptionRenderKey.bind(_assertThisInitialized(_this));
|
|
_this.isOptionDisabled = _this.isOptionDisabled.bind(_assertThisInitialized(_this));
|
|
_this.getOptionGroupChildren = _this.getOptionGroupChildren.bind(_assertThisInitialized(_this));
|
|
_this.getOptionGroupLabel = _this.getOptionGroupLabel.bind(_assertThisInitialized(_this));
|
|
_this.getOptionGroupRenderKey = _this.getOptionGroupRenderKey.bind(_assertThisInitialized(_this));
|
|
_this.allowOptionSelect = _this.allowOptionSelect.bind(_assertThisInitialized(_this));
|
|
_this.isSelected = _this.isSelected.bind(_assertThisInitialized(_this));
|
|
_this.isAllSelected = _this.isAllSelected.bind(_assertThisInitialized(_this));
|
|
_this.hasFilter = _this.hasFilter.bind(_assertThisInitialized(_this));
|
|
_this.getSelectedOptionIndex = _this.getSelectedOptionIndex.bind(_assertThisInitialized(_this));
|
|
_this.hide = _this.hide.bind(_assertThisInitialized(_this));
|
|
_this.onOptionKeyDown = _this.onOptionKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.overlayRef = /*#__PURE__*/createRef();
|
|
_this.inputRef = /*#__PURE__*/createRef(_this.props.inputRef);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(MultiSelect, [{
|
|
key: "onPanelClick",
|
|
value: function onPanelClick(event) {
|
|
OverlayService.emit('overlay-click', {
|
|
originalEvent: event,
|
|
target: this.container
|
|
});
|
|
}
|
|
}, {
|
|
key: "allowOptionSelect",
|
|
value: function allowOptionSelect() {
|
|
return !this.props.selectionLimit || !this.props.value || this.props.value && this.props.value.length < this.props.selectionLimit;
|
|
}
|
|
}, {
|
|
key: "onOptionSelect",
|
|
value: function onOptionSelect(event) {
|
|
var _this2 = this;
|
|
|
|
var originalEvent = event.originalEvent,
|
|
option = event.option;
|
|
|
|
if (this.props.disabled || this.isOptionDisabled(option)) {
|
|
return;
|
|
}
|
|
|
|
var optionValue = this.getOptionValue(option);
|
|
var isOptionValueUsed = this.isOptionValueUsed(option);
|
|
var selected = this.isSelected(option);
|
|
var allowOptionSelect = this.allowOptionSelect();
|
|
if (selected) this.updateModel(originalEvent, this.props.value.filter(function (val) {
|
|
return !ObjectUtils.equals(isOptionValueUsed ? val : _this2.getOptionValue(val), optionValue, _this2.equalityKey());
|
|
}));else if (allowOptionSelect) this.updateModel(originalEvent, [].concat(_toConsumableArray(this.props.value || []), [optionValue]));
|
|
}
|
|
}, {
|
|
key: "onOptionKeyDown",
|
|
value: function onOptionKeyDown(event) {
|
|
var originalEvent = event.originalEvent;
|
|
var listItem = originalEvent.currentTarget;
|
|
|
|
switch (originalEvent.which) {
|
|
//down
|
|
case 40:
|
|
var nextItem = this.findNextItem(listItem);
|
|
|
|
if (nextItem) {
|
|
nextItem.focus();
|
|
}
|
|
|
|
originalEvent.preventDefault();
|
|
break;
|
|
//up
|
|
|
|
case 38:
|
|
var prevItem = this.findPrevItem(listItem);
|
|
|
|
if (prevItem) {
|
|
prevItem.focus();
|
|
}
|
|
|
|
originalEvent.preventDefault();
|
|
break;
|
|
//enter and space
|
|
|
|
case 13:
|
|
case 32:
|
|
this.onOptionSelect(event);
|
|
originalEvent.preventDefault();
|
|
break;
|
|
//escape
|
|
|
|
case 27:
|
|
this.hide();
|
|
this.inputRef.current.focus();
|
|
break;
|
|
}
|
|
}
|
|
}, {
|
|
key: "findNextItem",
|
|
value: function findNextItem(item) {
|
|
var nextItem = item.nextElementSibling;
|
|
if (nextItem) return DomHandler.hasClass(nextItem, 'p-disabled') || DomHandler.hasClass(nextItem, 'p-multiselect-item-group') ? this.findNextItem(nextItem) : nextItem;else return null;
|
|
}
|
|
}, {
|
|
key: "findPrevItem",
|
|
value: function findPrevItem(item) {
|
|
var prevItem = item.previousElementSibling;
|
|
if (prevItem) return DomHandler.hasClass(prevItem, 'p-disabled') || DomHandler.hasClass(prevItem, 'p-multiselect-item-group') ? this.findPrevItem(prevItem) : prevItem;else return null;
|
|
}
|
|
}, {
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
if (!this.props.disabled && !this.isPanelClicked(event) && !DomHandler.hasClass(event.target, 'p-multiselect-token-icon') && !this.isClearClicked(event)) {
|
|
if (this.state.overlayVisible) {
|
|
this.hide();
|
|
} else {
|
|
this.show();
|
|
}
|
|
|
|
this.inputRef.current.focus();
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event) {
|
|
switch (event.which) {
|
|
//down
|
|
case 40:
|
|
if (!this.state.overlayVisible && event.altKey) {
|
|
this.show();
|
|
event.preventDefault();
|
|
}
|
|
|
|
break;
|
|
//space
|
|
|
|
case 32:
|
|
if (this.state.overlayVisible) this.hide();else this.show();
|
|
event.preventDefault();
|
|
break;
|
|
//escape
|
|
|
|
case 27:
|
|
this.hide();
|
|
break;
|
|
//tab
|
|
|
|
case 9:
|
|
if (this.state.overlayVisible) {
|
|
var firstFocusableElement = DomHandler.getFirstFocusableElement(this.overlayRef.current);
|
|
|
|
if (firstFocusableElement) {
|
|
firstFocusableElement.focus();
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}, {
|
|
key: "onSelectAll",
|
|
value: function onSelectAll(event) {
|
|
var _this3 = this;
|
|
|
|
if (this.props.onSelectAll) {
|
|
this.props.onSelectAll(event);
|
|
} else {
|
|
var value = null;
|
|
var visibleOptions = this.getVisibleOptions();
|
|
|
|
if (event.checked) {
|
|
value = [];
|
|
|
|
if (visibleOptions) {
|
|
var selectedOptions = visibleOptions.filter(function (option) {
|
|
return _this3.isOptionDisabled(option) && _this3.isSelected(option);
|
|
});
|
|
value = selectedOptions.map(function (option) {
|
|
return _this3.getOptionValue(option);
|
|
});
|
|
}
|
|
} else if (visibleOptions) {
|
|
visibleOptions = visibleOptions.filter(function (option) {
|
|
return !_this3.isOptionDisabled(option);
|
|
});
|
|
|
|
if (this.props.optionGroupLabel) {
|
|
value = [];
|
|
visibleOptions.forEach(function (optionGroup) {
|
|
return value = [].concat(_toConsumableArray(value), _toConsumableArray(_this3.getOptionGroupChildren(optionGroup).filter(function (option) {
|
|
return !_this3.isOptionDisabled(option);
|
|
}).map(function (option) {
|
|
return _this3.getOptionValue(option);
|
|
})));
|
|
});
|
|
} else {
|
|
value = visibleOptions.map(function (option) {
|
|
return _this3.getOptionValue(option);
|
|
});
|
|
}
|
|
}
|
|
|
|
this.updateModel(event.originalEvent, value);
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateModel",
|
|
value: function updateModel(event, value) {
|
|
if (this.props.onChange) {
|
|
this.props.onChange({
|
|
originalEvent: event,
|
|
value: value,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: value
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onFilterInputChange",
|
|
value: function onFilterInputChange(event) {
|
|
var _this4 = this;
|
|
|
|
var filter = event.query;
|
|
this.setState({
|
|
filter: filter
|
|
}, function () {
|
|
if (_this4.props.onFilter) {
|
|
_this4.props.onFilter({
|
|
originalEvent: event,
|
|
filter: filter
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "resetFilter",
|
|
value: function resetFilter() {
|
|
var _this5 = this;
|
|
|
|
var filter = '';
|
|
this.setState({
|
|
filter: filter
|
|
}, function () {
|
|
_this5.props.onFilter && _this5.props.onFilter({
|
|
filter: filter
|
|
});
|
|
});
|
|
}
|
|
}, {
|
|
key: "show",
|
|
value: function show() {
|
|
this.setState({
|
|
overlayVisible: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "hide",
|
|
value: function hide() {
|
|
this.setState({
|
|
overlayVisible: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "onOverlayEnter",
|
|
value: function onOverlayEnter(callback) {
|
|
ZIndexUtils.set('overlay', this.overlayRef.current, PrimeReact.autoZIndex, PrimeReact.zIndex['overlay']);
|
|
this.alignOverlay();
|
|
this.scrollInView();
|
|
callback && callback();
|
|
}
|
|
}, {
|
|
key: "onOverlayEntered",
|
|
value: function onOverlayEntered() {
|
|
this.bindDocumentClickListener();
|
|
this.bindScrollListener();
|
|
this.bindResizeListener();
|
|
this.props.onShow && this.props.onShow();
|
|
}
|
|
}, {
|
|
key: "onOverlayExit",
|
|
value: function onOverlayExit() {
|
|
this.unbindDocumentClickListener();
|
|
this.unbindScrollListener();
|
|
this.unbindResizeListener();
|
|
}
|
|
}, {
|
|
key: "onOverlayExited",
|
|
value: function onOverlayExited() {
|
|
if (this.props.filter && this.props.resetFilterOnHide) {
|
|
this.resetFilter();
|
|
}
|
|
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
this.props.onHide && this.props.onHide();
|
|
}
|
|
}, {
|
|
key: "alignOverlay",
|
|
value: function alignOverlay() {
|
|
DomHandler.alignOverlay(this.overlayRef.current, this.label.parentElement, this.props.appendTo || PrimeReact.appendTo);
|
|
}
|
|
}, {
|
|
key: "scrollInView",
|
|
value: function scrollInView() {
|
|
var highlightItem = DomHandler.findSingle(this.overlayRef.current, 'li.p-highlight');
|
|
|
|
if (highlightItem) {
|
|
highlightItem.scrollIntoView({
|
|
block: 'nearest',
|
|
inline: 'start'
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onCloseClick",
|
|
value: function onCloseClick(event) {
|
|
this.hide();
|
|
this.inputRef.current.focus();
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
}
|
|
}, {
|
|
key: "getSelectedOptionIndex",
|
|
value: function getSelectedOptionIndex() {
|
|
if (this.props.value != null && this.props.options) {
|
|
if (this.props.optionGroupLabel) {
|
|
for (var i = 0; i < this.props.options.length; i++) {
|
|
var selectedOptionIndex = this.findOptionIndexInList(this.props.value, this.getOptionGroupChildren(this.props.options[i]));
|
|
|
|
if (selectedOptionIndex !== -1) {
|
|
return {
|
|
group: i,
|
|
option: selectedOptionIndex
|
|
};
|
|
}
|
|
}
|
|
} else {
|
|
return this.findOptionIndexInList(this.props.value, this.props.options);
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
}, {
|
|
key: "findOptionIndexInList",
|
|
value: function findOptionIndexInList(value, list) {
|
|
var _this6 = this;
|
|
|
|
var key = this.equalityKey();
|
|
return list.findIndex(function (item) {
|
|
return value.some(function (val) {
|
|
return ObjectUtils.equals(val, _this6.getOptionValue(item), key);
|
|
});
|
|
});
|
|
}
|
|
}, {
|
|
key: "isSelected",
|
|
value: function isSelected(option) {
|
|
var _this7 = this;
|
|
|
|
var selected = false;
|
|
|
|
if (this.props.value) {
|
|
var optionValue = this.getOptionValue(option);
|
|
var isOptionValueUsed = this.isOptionValueUsed(option);
|
|
var key = this.equalityKey();
|
|
selected = this.props.value.some(function (val) {
|
|
return ObjectUtils.equals(isOptionValueUsed ? val : _this7.getOptionValue(val), optionValue, key);
|
|
});
|
|
}
|
|
|
|
return selected;
|
|
}
|
|
}, {
|
|
key: "getLabelByValue",
|
|
value: function getLabelByValue(val) {
|
|
var option;
|
|
|
|
if (this.props.options) {
|
|
if (this.props.optionGroupLabel) {
|
|
var _iterator = _createForOfIteratorHelper$8(this.props.options),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var optionGroup = _step.value;
|
|
option = this.findOptionByValue(val, this.getOptionGroupChildren(optionGroup));
|
|
|
|
if (option) {
|
|
break;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
} else {
|
|
option = this.findOptionByValue(val, this.props.options);
|
|
}
|
|
}
|
|
|
|
return option ? this.getOptionLabel(option) : null;
|
|
}
|
|
}, {
|
|
key: "findOptionByValue",
|
|
value: function findOptionByValue(val, list) {
|
|
var key = this.equalityKey();
|
|
|
|
var _iterator2 = _createForOfIteratorHelper$8(list),
|
|
_step2;
|
|
|
|
try {
|
|
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
|
|
var option = _step2.value;
|
|
var optionValue = this.getOptionValue(option);
|
|
|
|
if (ObjectUtils.equals(optionValue, val, key)) {
|
|
return option;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator2.e(err);
|
|
} finally {
|
|
_iterator2.f();
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "onFocus",
|
|
value: function onFocus(event) {
|
|
var _this8 = this;
|
|
|
|
event.persist();
|
|
this.setState({
|
|
focused: true
|
|
}, function () {
|
|
if (_this8.props.onFocus) {
|
|
_this8.props.onFocus(event);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onBlur",
|
|
value: function onBlur(event) {
|
|
var _this9 = this;
|
|
|
|
event.persist();
|
|
this.setState({
|
|
focused: false
|
|
}, function () {
|
|
if (_this9.props.onBlur) {
|
|
_this9.props.onBlur(event);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "bindDocumentClickListener",
|
|
value: function bindDocumentClickListener() {
|
|
var _this10 = this;
|
|
|
|
if (!this.documentClickListener) {
|
|
this.documentClickListener = function (event) {
|
|
if (_this10.state.overlayVisible && _this10.isOutsideClicked(event)) {
|
|
_this10.hide();
|
|
}
|
|
};
|
|
|
|
document.addEventListener('click', this.documentClickListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindScrollListener",
|
|
value: function bindScrollListener() {
|
|
var _this11 = this;
|
|
|
|
if (!this.scrollHandler) {
|
|
this.scrollHandler = new ConnectedOverlayScrollHandler(this.container, function () {
|
|
if (_this11.state.overlayVisible) {
|
|
_this11.hide();
|
|
}
|
|
});
|
|
}
|
|
|
|
this.scrollHandler.bindScrollListener();
|
|
}
|
|
}, {
|
|
key: "unbindScrollListener",
|
|
value: function unbindScrollListener() {
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.unbindScrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindResizeListener",
|
|
value: function bindResizeListener() {
|
|
var _this12 = this;
|
|
|
|
if (!this.resizeListener) {
|
|
this.resizeListener = function () {
|
|
if (_this12.state.overlayVisible && !DomHandler.isTouchDevice()) {
|
|
_this12.hide();
|
|
}
|
|
};
|
|
|
|
window.addEventListener('resize', this.resizeListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindResizeListener",
|
|
value: function unbindResizeListener() {
|
|
if (this.resizeListener) {
|
|
window.removeEventListener('resize', this.resizeListener);
|
|
this.resizeListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "isOutsideClicked",
|
|
value: function isOutsideClicked(event) {
|
|
return this.container && !(this.container.isSameNode(event.target) || this.isClearClicked(event) || this.container.contains(event.target) || this.isPanelClicked(event));
|
|
}
|
|
}, {
|
|
key: "isClearClicked",
|
|
value: function isClearClicked(event) {
|
|
return DomHandler.hasClass(event.target, 'p-multiselect-clear-icon');
|
|
}
|
|
}, {
|
|
key: "isPanelClicked",
|
|
value: function isPanelClicked(event) {
|
|
return this.overlayRef && this.overlayRef.current && this.overlayRef.current.contains(event.target);
|
|
}
|
|
}, {
|
|
key: "unbindDocumentClickListener",
|
|
value: function unbindDocumentClickListener() {
|
|
if (this.documentClickListener) {
|
|
document.removeEventListener('click', this.documentClickListener);
|
|
this.documentClickListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateInputRef",
|
|
value: function updateInputRef() {
|
|
var ref = this.props.inputRef;
|
|
|
|
if (ref) {
|
|
if (typeof ref === 'function') {
|
|
ref(this.inputRef.current);
|
|
} else {
|
|
ref.current = this.inputRef.current;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.updateInputRef();
|
|
|
|
if (this.props.tooltip) {
|
|
this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$j({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
}
|
|
|
|
if (this.state.overlayVisible && this.hasFilter()) {
|
|
this.alignOverlay();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.unbindDocumentClickListener();
|
|
this.unbindResizeListener();
|
|
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.destroy();
|
|
this.scrollHandler = null;
|
|
}
|
|
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
}
|
|
}, {
|
|
key: "hasFilter",
|
|
value: function hasFilter() {
|
|
return this.state.filter && this.state.filter.trim().length > 0;
|
|
}
|
|
}, {
|
|
key: "isAllSelected",
|
|
value: function isAllSelected() {
|
|
var _this13 = this;
|
|
|
|
if (this.props.onSelectAll) {
|
|
return this.props.selectAll;
|
|
} else {
|
|
var visibleOptions = this.getVisibleOptions();
|
|
|
|
if (ObjectUtils.isEmpty(visibleOptions)) {
|
|
return false;
|
|
}
|
|
|
|
visibleOptions = visibleOptions.filter(function (option) {
|
|
return !_this13.isOptionDisabled(option);
|
|
});
|
|
|
|
if (this.props.optionGroupLabel) {
|
|
var _iterator3 = _createForOfIteratorHelper$8(visibleOptions),
|
|
_step3;
|
|
|
|
try {
|
|
for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
|
|
var optionGroup = _step3.value;
|
|
var visibleOptionsGroupChildren = this.getOptionGroupChildren(optionGroup).filter(function (option) {
|
|
return !_this13.isOptionDisabled(option);
|
|
});
|
|
|
|
var _iterator4 = _createForOfIteratorHelper$8(visibleOptionsGroupChildren),
|
|
_step4;
|
|
|
|
try {
|
|
for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
|
|
var option = _step4.value;
|
|
|
|
if (!this.isSelected(option)) {
|
|
return false;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator4.e(err);
|
|
} finally {
|
|
_iterator4.f();
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator3.e(err);
|
|
} finally {
|
|
_iterator3.f();
|
|
}
|
|
} else {
|
|
var _iterator5 = _createForOfIteratorHelper$8(visibleOptions),
|
|
_step5;
|
|
|
|
try {
|
|
for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
|
|
var _option = _step5.value;
|
|
|
|
if (!this.isSelected(_option)) {
|
|
return false;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator5.e(err);
|
|
} finally {
|
|
_iterator5.f();
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}, {
|
|
key: "getOptionLabel",
|
|
value: function getOptionLabel(option) {
|
|
return this.props.optionLabel ? ObjectUtils.resolveFieldData(option, this.props.optionLabel) : option && option['label'] !== undefined ? option['label'] : option;
|
|
}
|
|
}, {
|
|
key: "getOptionValue",
|
|
value: function getOptionValue(option) {
|
|
if (this.props.optionValue) {
|
|
var data = ObjectUtils.resolveFieldData(option, this.props.optionValue);
|
|
return data !== null ? data : option;
|
|
}
|
|
|
|
return option && option['value'] !== undefined ? option['value'] : option;
|
|
}
|
|
}, {
|
|
key: "getOptionRenderKey",
|
|
value: function getOptionRenderKey(option) {
|
|
return this.props.dataKey ? ObjectUtils.resolveFieldData(option, this.props.dataKey) : this.getOptionLabel(option);
|
|
}
|
|
}, {
|
|
key: "getOptionGroupRenderKey",
|
|
value: function getOptionGroupRenderKey(optionGroup) {
|
|
return ObjectUtils.resolveFieldData(optionGroup, this.props.optionGroupLabel);
|
|
}
|
|
}, {
|
|
key: "getOptionGroupLabel",
|
|
value: function getOptionGroupLabel(optionGroup) {
|
|
return ObjectUtils.resolveFieldData(optionGroup, this.props.optionGroupLabel);
|
|
}
|
|
}, {
|
|
key: "getOptionGroupChildren",
|
|
value: function getOptionGroupChildren(optionGroup) {
|
|
return ObjectUtils.resolveFieldData(optionGroup, this.props.optionGroupChildren);
|
|
}
|
|
}, {
|
|
key: "isOptionDisabled",
|
|
value: function isOptionDisabled(option) {
|
|
if (this.props.optionDisabled) {
|
|
return ObjectUtils.isFunction(this.props.optionDisabled) ? this.props.optionDisabled(option) : ObjectUtils.resolveFieldData(option, this.props.optionDisabled);
|
|
}
|
|
|
|
return option && option['disabled'] !== undefined ? option['disabled'] : false;
|
|
}
|
|
}, {
|
|
key: "isOptionValueUsed",
|
|
value: function isOptionValueUsed(option) {
|
|
return this.props.optionValue || option && option['value'] !== undefined;
|
|
}
|
|
}, {
|
|
key: "getVisibleOptions",
|
|
value: function getVisibleOptions() {
|
|
if (this.hasFilter()) {
|
|
var filterValue = this.state.filter.trim().toLocaleLowerCase(this.props.filterLocale);
|
|
var searchFields = this.props.filterBy ? this.props.filterBy.split(',') : [this.props.optionLabel || 'label'];
|
|
|
|
if (this.props.optionGroupLabel) {
|
|
var filteredGroups = [];
|
|
|
|
var _iterator6 = _createForOfIteratorHelper$8(this.props.options),
|
|
_step6;
|
|
|
|
try {
|
|
for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
|
|
var optgroup = _step6.value;
|
|
var filteredSubOptions = FilterService.filter(this.getOptionGroupChildren(optgroup), searchFields, filterValue, this.props.filterMatchMode, this.props.filterLocale);
|
|
|
|
if (filteredSubOptions && filteredSubOptions.length) {
|
|
filteredGroups.push(_objectSpread$j(_objectSpread$j({}, optgroup), {
|
|
items: filteredSubOptions
|
|
}));
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator6.e(err);
|
|
} finally {
|
|
_iterator6.f();
|
|
}
|
|
|
|
return filteredGroups;
|
|
} else {
|
|
return FilterService.filter(this.props.options, searchFields, filterValue, this.props.filterMatchMode, this.props.filterLocale);
|
|
}
|
|
} else {
|
|
return this.props.options;
|
|
}
|
|
}
|
|
}, {
|
|
key: "isEmpty",
|
|
value: function isEmpty() {
|
|
return !this.props.value || this.props.value.length === 0;
|
|
}
|
|
}, {
|
|
key: "equalityKey",
|
|
value: function equalityKey() {
|
|
return this.props.optionValue ? null : this.props.dataKey;
|
|
}
|
|
}, {
|
|
key: "checkValidity",
|
|
value: function checkValidity() {
|
|
return this.inputRef.current.checkValidity();
|
|
}
|
|
}, {
|
|
key: "removeChip",
|
|
value: function removeChip(event, item) {
|
|
var key = this.equalityKey();
|
|
var value = this.props.value.filter(function (val) {
|
|
return !ObjectUtils.equals(val, item, key);
|
|
});
|
|
this.updateModel(event, value);
|
|
}
|
|
}, {
|
|
key: "getSelectedItemsLabel",
|
|
value: function getSelectedItemsLabel() {
|
|
var pattern = /{(.*?)}/;
|
|
|
|
if (pattern.test(this.props.selectedItemsLabel)) {
|
|
return this.props.selectedItemsLabel.replace(this.props.selectedItemsLabel.match(pattern)[0], this.props.value.length + '');
|
|
}
|
|
|
|
return this.props.selectedItemsLabel;
|
|
}
|
|
}, {
|
|
key: "getLabel",
|
|
value: function getLabel() {
|
|
var label;
|
|
|
|
if (!this.isEmpty() && !this.props.fixedPlaceholder) {
|
|
if (this.props.maxSelectedLabels && this.props.value.length > this.props.maxSelectedLabels) {
|
|
return this.getSelectedItemsLabel();
|
|
} else {
|
|
label = '';
|
|
|
|
for (var i = 0; i < this.props.value.length; i++) {
|
|
if (i !== 0) {
|
|
label += ',';
|
|
}
|
|
|
|
label += this.getLabelByValue(this.props.value[i]);
|
|
}
|
|
|
|
return label;
|
|
}
|
|
}
|
|
|
|
return label;
|
|
}
|
|
}, {
|
|
key: "getLabelContent",
|
|
value: function getLabelContent() {
|
|
var _this14 = this;
|
|
|
|
if (this.props.selectedItemTemplate) {
|
|
if (!this.isEmpty()) {
|
|
if (this.props.maxSelectedLabels && this.props.value.length > this.props.maxSelectedLabels) {
|
|
return this.getSelectedItemsLabel();
|
|
} else {
|
|
return this.props.value.map(function (val, index) {
|
|
var item = ObjectUtils.getJSXElement(_this14.props.selectedItemTemplate, val);
|
|
return /*#__PURE__*/React.createElement(React.Fragment, {
|
|
key: index
|
|
}, item);
|
|
});
|
|
}
|
|
} else {
|
|
return ObjectUtils.getJSXElement(this.props.selectedItemTemplate);
|
|
}
|
|
} else {
|
|
if (this.props.display === 'chip' && !this.isEmpty()) {
|
|
var value = this.props.value.slice(0, this.props.maxSelectedLabels || this.props.value.length);
|
|
return value.map(function (val) {
|
|
var label = _this14.getLabelByValue(val);
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-multiselect-token",
|
|
key: label
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-multiselect-token-label"
|
|
}, label), !_this14.props.disabled && IconUtils.getJSXIcon(_this14.props.removeIcon, {
|
|
className: 'p-multiselect-token-icon',
|
|
onClick: function onClick(e) {
|
|
return _this14.removeChip(e, val);
|
|
}
|
|
}, {
|
|
props: _this14.props
|
|
}));
|
|
});
|
|
}
|
|
|
|
return this.getLabel();
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.container,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderClearIcon",
|
|
value: function renderClearIcon() {
|
|
var _this15 = this;
|
|
|
|
var empty = this.isEmpty();
|
|
|
|
if (!empty && this.props.showClear && !this.props.disabled) {
|
|
return /*#__PURE__*/React.createElement("i", {
|
|
className: "p-multiselect-clear-icon pi pi-times",
|
|
onClick: function onClick(e) {
|
|
return _this15.updateModel(e, null);
|
|
}
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderLabel",
|
|
value: function renderLabel() {
|
|
var _this16 = this;
|
|
|
|
var empty = this.isEmpty();
|
|
var content = this.getLabelContent();
|
|
var labelClassName = classNames('p-multiselect-label', {
|
|
'p-placeholder': empty && this.props.placeholder,
|
|
'p-multiselect-label-empty': empty && !this.props.placeholder && !this.props.selectedItemTemplate,
|
|
'p-multiselect-items-label': !empty && this.props.display !== 'chip' && this.props.value.length > this.props.maxSelectedLabels
|
|
});
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this16.label = el;
|
|
},
|
|
className: "p-multiselect-label-container"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: labelClassName
|
|
}, content || this.props.placeholder || 'empty'));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this17 = this;
|
|
|
|
var className = classNames('p-multiselect p-component p-inputwrapper', {
|
|
'p-multiselect-chip': this.props.display === 'chip',
|
|
'p-disabled': this.props.disabled,
|
|
'p-multiselect-clearable': this.props.showClear && !this.props.disabled,
|
|
'p-focus': this.state.focused,
|
|
'p-inputwrapper-filled': this.props.value && this.props.value.length > 0,
|
|
'p-inputwrapper-focus': this.state.focused || this.state.overlayVisible
|
|
}, this.props.className);
|
|
var visibleOptions = this.getVisibleOptions();
|
|
var label = this.renderLabel();
|
|
var clearIcon = this.renderClearIcon();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
className: className,
|
|
onClick: this.onClick,
|
|
ref: function ref(el) {
|
|
return _this17.container = el;
|
|
},
|
|
style: this.props.style
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-hidden-accessible"
|
|
}, /*#__PURE__*/React.createElement("input", {
|
|
ref: this.inputRef,
|
|
id: this.props.inputId,
|
|
name: this.props.name,
|
|
readOnly: true,
|
|
type: "text",
|
|
onFocus: this.onFocus,
|
|
onBlur: this.onBlur,
|
|
onKeyDown: this.onKeyDown,
|
|
role: "listbox",
|
|
"aria-haspopup": "listbox",
|
|
"aria-labelledby": this.props.ariaLabelledBy,
|
|
"aria-expanded": this.state.overlayVisible,
|
|
disabled: this.props.disabled,
|
|
tabIndex: this.props.tabIndex
|
|
})), label, clearIcon, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-multiselect-trigger"
|
|
}, IconUtils.getJSXIcon(this.props.dropdownIcon, {
|
|
className: 'p-multiselect-trigger-icon p-c'
|
|
}, {
|
|
props: this.props
|
|
})), /*#__PURE__*/React.createElement(MultiSelectPanel, _extends({
|
|
ref: this.overlayRef,
|
|
visibleOptions: visibleOptions
|
|
}, this.props, {
|
|
onClick: this.onPanelClick,
|
|
onOverlayHide: this.hide,
|
|
filterValue: this.state.filter,
|
|
hasFilter: this.hasFilter,
|
|
onFilterInputChange: this.onFilterInputChange,
|
|
onCloseClick: this.onCloseClick,
|
|
onSelectAll: this.onSelectAll,
|
|
getOptionLabel: this.getOptionLabel,
|
|
getOptionRenderKey: this.getOptionRenderKey,
|
|
isOptionDisabled: this.isOptionDisabled,
|
|
getOptionGroupChildren: this.getOptionGroupChildren,
|
|
getOptionGroupLabel: this.getOptionGroupLabel,
|
|
getOptionGroupRenderKey: this.getOptionGroupRenderKey,
|
|
isSelected: this.isSelected,
|
|
getSelectedOptionIndex: this.getSelectedOptionIndex,
|
|
isAllSelected: this.isAllSelected,
|
|
onOptionSelect: this.onOptionSelect,
|
|
allowOptionSelect: this.allowOptionSelect,
|
|
onOptionKeyDown: this.onOptionKeyDown,
|
|
"in": this.state.overlayVisible,
|
|
onEnter: this.onOverlayEnter,
|
|
onEntered: this.onOverlayEntered,
|
|
onExit: this.onOverlayExit,
|
|
onExited: this.onOverlayExited
|
|
})));
|
|
}
|
|
}]);
|
|
|
|
return MultiSelect;
|
|
}(Component);
|
|
|
|
_defineProperty(MultiSelect, "defaultProps", {
|
|
id: null,
|
|
inputRef: null,
|
|
name: null,
|
|
value: null,
|
|
options: null,
|
|
optionLabel: null,
|
|
optionValue: null,
|
|
optionDisabled: null,
|
|
optionGroupLabel: null,
|
|
optionGroupChildren: null,
|
|
optionGroupTemplate: null,
|
|
display: 'comma',
|
|
style: null,
|
|
className: null,
|
|
panelClassName: null,
|
|
panelStyle: null,
|
|
virtualScrollerOptions: null,
|
|
scrollHeight: '200px',
|
|
placeholder: null,
|
|
fixedPlaceholder: false,
|
|
disabled: false,
|
|
showClear: false,
|
|
filter: false,
|
|
filterBy: null,
|
|
filterMatchMode: 'contains',
|
|
filterPlaceholder: null,
|
|
filterLocale: undefined,
|
|
emptyFilterMessage: null,
|
|
resetFilterOnHide: false,
|
|
tabIndex: 0,
|
|
dataKey: null,
|
|
inputId: null,
|
|
appendTo: null,
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
maxSelectedLabels: null,
|
|
selectionLimit: null,
|
|
selectedItemsLabel: '{0} items selected',
|
|
ariaLabelledBy: null,
|
|
itemTemplate: null,
|
|
selectedItemTemplate: null,
|
|
panelHeaderTemplate: null,
|
|
panelFooterTemplate: null,
|
|
transitionOptions: null,
|
|
dropdownIcon: 'pi pi-chevron-down',
|
|
removeIcon: 'pi pi-times-circle',
|
|
showSelectAll: true,
|
|
selectAll: false,
|
|
onChange: null,
|
|
onFocus: null,
|
|
onBlur: null,
|
|
onShow: null,
|
|
onHide: null,
|
|
onFilter: null,
|
|
onSelectAll: null
|
|
});
|
|
|
|
function ownKeys$i(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$i(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$i(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$i(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$W(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$W(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$W() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var MultiStateCheckbox = /*#__PURE__*/function (_Component) {
|
|
_inherits(MultiStateCheckbox, _Component);
|
|
|
|
var _super = _createSuper$W(MultiStateCheckbox);
|
|
|
|
function MultiStateCheckbox(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, MultiStateCheckbox);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
focused: false
|
|
};
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onFocus = _this.onFocus.bind(_assertThisInitialized(_this));
|
|
_this.onBlur = _this.onBlur.bind(_assertThisInitialized(_this));
|
|
_this.inputRef = /*#__PURE__*/createRef(_this.props.inputRef);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(MultiStateCheckbox, [{
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
if (!this.props.disabled && !this.props.readOnly) {
|
|
this.toggle(event);
|
|
this.inputRef.current.focus();
|
|
}
|
|
}
|
|
}, {
|
|
key: "getOptionValue",
|
|
value: function getOptionValue(option) {
|
|
return this.props.optionValue ? ObjectUtils.resolveFieldData(option, this.props.optionValue) : option;
|
|
}
|
|
}, {
|
|
key: "equalityKey",
|
|
value: function equalityKey() {
|
|
return this.props.optionValue ? null : this.props.dataKey;
|
|
}
|
|
}, {
|
|
key: "findSelectedOptionMap",
|
|
value: function findSelectedOptionMap() {
|
|
var _this2 = this;
|
|
|
|
var option, index;
|
|
|
|
if (this.props.options) {
|
|
var key = this.equalityKey();
|
|
index = this.props.options.findIndex(function (option) {
|
|
return ObjectUtils.equals(_this2.props.value, _this2.getOptionValue(option), key);
|
|
});
|
|
option = this.props.options[index];
|
|
}
|
|
|
|
return {
|
|
option: option,
|
|
index: index
|
|
};
|
|
}
|
|
}, {
|
|
key: "findNextOption",
|
|
value: function findNextOption() {
|
|
if (this.props.options) {
|
|
var _this$findSelectedOpt = this.findSelectedOptionMap(),
|
|
index = _this$findSelectedOpt.index;
|
|
|
|
return index === this.props.options.length - 1 ? this.props.empty ? null : this.props.options[0] : this.props.options[index + 1];
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "toggle",
|
|
value: function toggle(event) {
|
|
var newValue = this.getOptionValue(this.findNextOption());
|
|
|
|
if (this.props.onChange) {
|
|
this.props.onChange({
|
|
originalEvent: event,
|
|
value: newValue,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: newValue
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onFocus",
|
|
value: function onFocus() {
|
|
this.setState({
|
|
focused: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "onBlur",
|
|
value: function onBlur() {
|
|
this.setState({
|
|
focused: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "updateInputRef",
|
|
value: function updateInputRef() {
|
|
var ref = this.props.inputRef;
|
|
|
|
if (ref) {
|
|
if (typeof ref === 'function') {
|
|
ref(this.inputRef.current);
|
|
} else {
|
|
ref.current = this.inputRef.current;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.updateInputRef();
|
|
|
|
if (this.props.tooltip && !this.props.disabled) {
|
|
this.renderTooltip();
|
|
}
|
|
|
|
if (!this.props.empty && this.props.value === null) {
|
|
this.toggle();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$i({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.element,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderIcon",
|
|
value: function renderIcon(option) {
|
|
var icon = option && option.icon || '';
|
|
var className = classNames('p-checkbox-icon p-c', _defineProperty({}, "".concat(icon), true));
|
|
var content = /*#__PURE__*/React.createElement("span", {
|
|
className: className
|
|
});
|
|
|
|
if (this.props.iconTemplate) {
|
|
var defaultOptions = {
|
|
option: option,
|
|
className: className,
|
|
element: content,
|
|
props: this.props
|
|
};
|
|
return ObjectUtils.getJSXElement(this.props.iconTemplate, defaultOptions);
|
|
}
|
|
|
|
return content;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this3 = this;
|
|
|
|
var _this$findSelectedOpt2 = this.findSelectedOptionMap(),
|
|
option = _this$findSelectedOpt2.option;
|
|
|
|
var containerClassName = classNames('p-multistatecheckbox p-checkbox p-component', this.props.className);
|
|
var boxClassName = classNames('p-checkbox-box', {
|
|
'p-highlight': !!option,
|
|
'p-disabled': this.props.disabled,
|
|
'p-focus': this.state.focused
|
|
}, option && option.className);
|
|
var icon = this.renderIcon(option);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this3.element = el;
|
|
},
|
|
id: this.props.id,
|
|
className: containerClassName,
|
|
style: this.props.style,
|
|
onClick: this.onClick
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-hidden-accessible"
|
|
}, /*#__PURE__*/React.createElement("input", {
|
|
ref: this.inputRef,
|
|
type: "checkbox",
|
|
"aria-labelledby": this.props.ariaLabelledBy,
|
|
id: this.props.inputId,
|
|
name: this.props.name,
|
|
onFocus: this.onFocus,
|
|
onBlur: this.onBlur,
|
|
disabled: this.props.disabled,
|
|
readOnly: this.props.readOnly,
|
|
defaultChecked: !!option
|
|
})), /*#__PURE__*/React.createElement("div", {
|
|
className: boxClassName,
|
|
ref: function ref(el) {
|
|
return _this3.box = el;
|
|
},
|
|
role: "checkbox",
|
|
"aria-checked": !!option,
|
|
style: option && option.style
|
|
}, icon));
|
|
}
|
|
}]);
|
|
|
|
return MultiStateCheckbox;
|
|
}(Component);
|
|
|
|
_defineProperty(MultiStateCheckbox, "defaultProps", {
|
|
id: null,
|
|
inputRef: null,
|
|
inputId: null,
|
|
value: null,
|
|
options: null,
|
|
optionValue: null,
|
|
iconTemplate: null,
|
|
dataKey: null,
|
|
name: null,
|
|
style: null,
|
|
className: null,
|
|
disabled: false,
|
|
readOnly: false,
|
|
empty: true,
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
ariaLabelledBy: null,
|
|
onChange: null
|
|
});
|
|
|
|
function _createSuper$V(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$V(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$V() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var OrderListControls = /*#__PURE__*/function (_Component) {
|
|
_inherits(OrderListControls, _Component);
|
|
|
|
var _super = _createSuper$V(OrderListControls);
|
|
|
|
function OrderListControls() {
|
|
var _this;
|
|
|
|
_classCallCheck(this, OrderListControls);
|
|
|
|
_this = _super.call(this);
|
|
_this.moveUp = _this.moveUp.bind(_assertThisInitialized(_this));
|
|
_this.moveTop = _this.moveTop.bind(_assertThisInitialized(_this));
|
|
_this.moveDown = _this.moveDown.bind(_assertThisInitialized(_this));
|
|
_this.moveBottom = _this.moveBottom.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(OrderListControls, [{
|
|
key: "moveUp",
|
|
value: function moveUp(event) {
|
|
if (this.props.selection) {
|
|
var value = _toConsumableArray(this.props.value);
|
|
|
|
for (var i = 0; i < this.props.selection.length; i++) {
|
|
var selectedItem = this.props.selection[i];
|
|
var selectedItemIndex = ObjectUtils.findIndexInList(selectedItem, value, this.props.dataKey);
|
|
|
|
if (selectedItemIndex !== 0) {
|
|
var movedItem = value[selectedItemIndex];
|
|
var temp = value[selectedItemIndex - 1];
|
|
value[selectedItemIndex - 1] = movedItem;
|
|
value[selectedItemIndex] = temp;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (this.props.onReorder) {
|
|
this.props.onReorder({
|
|
originalEvent: event,
|
|
value: value,
|
|
direction: 'up'
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "moveTop",
|
|
value: function moveTop(event) {
|
|
if (this.props.selection) {
|
|
var value = _toConsumableArray(this.props.value);
|
|
|
|
for (var i = 0; i < this.props.selection.length; i++) {
|
|
var selectedItem = this.props.selection[i];
|
|
var selectedItemIndex = ObjectUtils.findIndexInList(selectedItem, value, this.props.dataKey);
|
|
|
|
if (selectedItemIndex !== 0) {
|
|
var movedItem = value.splice(selectedItemIndex, 1)[0];
|
|
value.unshift(movedItem);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (this.props.onReorder) {
|
|
this.props.onReorder({
|
|
originalEvent: event,
|
|
value: value,
|
|
direction: 'top'
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "moveDown",
|
|
value: function moveDown(event) {
|
|
if (this.props.selection) {
|
|
var value = _toConsumableArray(this.props.value);
|
|
|
|
for (var i = this.props.selection.length - 1; i >= 0; i--) {
|
|
var selectedItem = this.props.selection[i];
|
|
var selectedItemIndex = ObjectUtils.findIndexInList(selectedItem, value, this.props.dataKey);
|
|
|
|
if (selectedItemIndex !== value.length - 1) {
|
|
var movedItem = value[selectedItemIndex];
|
|
var temp = value[selectedItemIndex + 1];
|
|
value[selectedItemIndex + 1] = movedItem;
|
|
value[selectedItemIndex] = temp;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (this.props.onReorder) {
|
|
this.props.onReorder({
|
|
originalEvent: event,
|
|
value: value,
|
|
direction: 'down'
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "moveBottom",
|
|
value: function moveBottom(event) {
|
|
if (this.props.selection) {
|
|
var value = _toConsumableArray(this.props.value);
|
|
|
|
for (var i = this.props.selection.length - 1; i >= 0; i--) {
|
|
var selectedItem = this.props.selection[i];
|
|
var selectedItemIndex = ObjectUtils.findIndexInList(selectedItem, value, this.props.dataKey);
|
|
|
|
if (selectedItemIndex !== value.length - 1) {
|
|
var movedItem = value.splice(selectedItemIndex, 1)[0];
|
|
value.push(movedItem);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (this.props.onReorder) {
|
|
this.props.onReorder({
|
|
originalEvent: event,
|
|
value: value,
|
|
direction: 'bottom'
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-orderlist-controls"
|
|
}, /*#__PURE__*/React.createElement(Button, {
|
|
type: "button",
|
|
icon: "pi pi-angle-up",
|
|
onClick: this.moveUp
|
|
}), /*#__PURE__*/React.createElement(Button, {
|
|
type: "button",
|
|
icon: "pi pi-angle-double-up",
|
|
onClick: this.moveTop
|
|
}), /*#__PURE__*/React.createElement(Button, {
|
|
type: "button",
|
|
icon: "pi pi-angle-down",
|
|
onClick: this.moveDown
|
|
}), /*#__PURE__*/React.createElement(Button, {
|
|
type: "button",
|
|
icon: "pi pi-angle-double-down",
|
|
onClick: this.moveBottom
|
|
}));
|
|
}
|
|
}]);
|
|
|
|
return OrderListControls;
|
|
}(Component);
|
|
|
|
function _createSuper$U(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$U(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$U() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var OrderListSubList = /*#__PURE__*/function (_Component) {
|
|
_inherits(OrderListSubList, _Component);
|
|
|
|
var _super = _createSuper$U(OrderListSubList);
|
|
|
|
function OrderListSubList(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, OrderListSubList);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onDragEnd = _this.onDragEnd.bind(_assertThisInitialized(_this));
|
|
_this.onDragLeave = _this.onDragLeave.bind(_assertThisInitialized(_this));
|
|
_this.onDrop = _this.onDrop.bind(_assertThisInitialized(_this));
|
|
_this.onListMouseMove = _this.onListMouseMove.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(OrderListSubList, [{
|
|
key: "isSelected",
|
|
value: function isSelected(item) {
|
|
return ObjectUtils.findIndexInList(item, this.props.selection, this.props.dataKey) !== -1;
|
|
}
|
|
}, {
|
|
key: "onDragStart",
|
|
value: function onDragStart(event, index) {
|
|
this.dragging = true;
|
|
this.draggedItemIndex = index;
|
|
|
|
if (this.props.dragdropScope) {
|
|
event.dataTransfer.setData('text', 'orderlist');
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDragOver",
|
|
value: function onDragOver(event, index) {
|
|
if (this.draggedItemIndex !== index && this.draggedItemIndex + 1 !== index) {
|
|
this.dragOverItemIndex = index;
|
|
DomHandler.addClass(event.target, 'p-orderlist-droppoint-highlight');
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDragLeave",
|
|
value: function onDragLeave(event) {
|
|
this.dragOverItemIndex = null;
|
|
DomHandler.removeClass(event.target, 'p-orderlist-droppoint-highlight');
|
|
}
|
|
}, {
|
|
key: "onDrop",
|
|
value: function onDrop(event) {
|
|
var dropIndex = this.draggedItemIndex > this.dragOverItemIndex ? this.dragOverItemIndex : this.dragOverItemIndex === 0 ? 0 : this.dragOverItemIndex - 1;
|
|
|
|
var value = _toConsumableArray(this.props.value);
|
|
|
|
ObjectUtils.reorderArray(value, this.draggedItemIndex, dropIndex);
|
|
this.dragOverItemIndex = null;
|
|
DomHandler.removeClass(event.target, 'p-orderlist-droppoint-highlight');
|
|
|
|
if (this.props.onChange) {
|
|
this.props.onChange({
|
|
originalEvent: event,
|
|
value: value
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDragEnd",
|
|
value: function onDragEnd(event) {
|
|
this.dragging = false;
|
|
}
|
|
}, {
|
|
key: "onListMouseMove",
|
|
value: function onListMouseMove(event) {
|
|
if (this.dragging) {
|
|
var offsetY = this.listElement.getBoundingClientRect().top + DomHandler.getWindowScrollTop();
|
|
var bottomDiff = offsetY + this.listElement.clientHeight - event.pageY;
|
|
var topDiff = event.pageY - offsetY;
|
|
if (bottomDiff < 25 && bottomDiff > 0) this.listElement.scrollTop += 15;else if (topDiff < 25 && topDiff > 0) this.listElement.scrollTop -= 15;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderDropPoint",
|
|
value: function renderDropPoint(index, key) {
|
|
var _this2 = this;
|
|
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: key,
|
|
className: "p-orderlist-droppoint",
|
|
onDragOver: function onDragOver(e) {
|
|
return _this2.onDragOver(e, index + 1);
|
|
},
|
|
onDragLeave: this.onDragLeave,
|
|
onDrop: this.onDrop
|
|
});
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this3 = this;
|
|
|
|
var header = null;
|
|
var items = null;
|
|
|
|
if (this.props.header) {
|
|
header = /*#__PURE__*/React.createElement("div", {
|
|
className: "p-orderlist-header"
|
|
}, this.props.header);
|
|
}
|
|
|
|
if (this.props.value) {
|
|
items = this.props.value.map(function (item, i) {
|
|
var content = _this3.props.itemTemplate ? _this3.props.itemTemplate(item) : item;
|
|
var itemClassName = classNames('p-orderlist-item', {
|
|
'p-highlight': _this3.isSelected(item)
|
|
}, _this3.props.className);
|
|
var key = JSON.stringify(item);
|
|
|
|
if (_this3.props.dragdrop) {
|
|
var _items = [_this3.renderDropPoint(i, key + '_droppoint'), /*#__PURE__*/React.createElement("li", {
|
|
key: key,
|
|
className: itemClassName,
|
|
onClick: function onClick(e) {
|
|
return _this3.props.onItemClick({
|
|
originalEvent: e,
|
|
value: item,
|
|
index: i
|
|
});
|
|
},
|
|
onKeyDown: function onKeyDown(e) {
|
|
return _this3.props.onItemKeyDown({
|
|
originalEvent: e,
|
|
value: item,
|
|
index: i
|
|
});
|
|
},
|
|
role: "option",
|
|
"aria-selected": _this3.isSelected(item),
|
|
draggable: "true",
|
|
onDragStart: function onDragStart(e) {
|
|
return _this3.onDragStart(e, i);
|
|
},
|
|
onDragEnd: _this3.onDragEnd,
|
|
tabIndex: _this3.props.tabIndex
|
|
}, content, /*#__PURE__*/React.createElement(Ripple, null))];
|
|
|
|
if (i === _this3.props.value.length - 1) {
|
|
_items.push(_this3.renderDropPoint(item, i, key + '_droppoint_end'));
|
|
}
|
|
|
|
return _items;
|
|
} else {
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: JSON.stringify(item),
|
|
className: itemClassName,
|
|
role: "option",
|
|
"aria-selected": _this3.isSelected(item),
|
|
onClick: function onClick(e) {
|
|
return _this3.props.onItemClick({
|
|
originalEvent: e,
|
|
value: item,
|
|
index: i
|
|
});
|
|
},
|
|
onKeyDown: function onKeyDown(e) {
|
|
return _this3.props.onItemKeyDown({
|
|
originalEvent: e,
|
|
value: item,
|
|
index: i
|
|
});
|
|
},
|
|
tabIndex: _this3.props.tabIndex
|
|
}, content);
|
|
}
|
|
});
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-orderlist-list-container"
|
|
}, header, /*#__PURE__*/React.createElement("ul", {
|
|
ref: function ref(el) {
|
|
return _this3.listElement = el;
|
|
},
|
|
className: "p-orderlist-list",
|
|
style: this.props.listStyle,
|
|
onDragOver: this.onListMouseMove,
|
|
role: "listbox",
|
|
"aria-multiselectable": true
|
|
}, items));
|
|
}
|
|
}]);
|
|
|
|
return OrderListSubList;
|
|
}(Component);
|
|
|
|
function _createSuper$T(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$T(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$T() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var OrderList = /*#__PURE__*/function (_Component) {
|
|
_inherits(OrderList, _Component);
|
|
|
|
var _super = _createSuper$T(OrderList);
|
|
|
|
function OrderList(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, OrderList);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
selection: []
|
|
};
|
|
_this.onItemClick = _this.onItemClick.bind(_assertThisInitialized(_this));
|
|
_this.onItemKeyDown = _this.onItemKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onReorder = _this.onReorder.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(OrderList, [{
|
|
key: "onItemClick",
|
|
value: function onItemClick(event) {
|
|
var metaKey = event.originalEvent.metaKey || event.originalEvent.ctrlKey;
|
|
var index = ObjectUtils.findIndexInList(event.value, this.state.selection, this.props.dataKey);
|
|
var selected = index !== -1;
|
|
var selection;
|
|
|
|
if (selected) {
|
|
if (metaKey) selection = this.state.selection.filter(function (val, i) {
|
|
return i !== index;
|
|
});else selection = [event.value];
|
|
} else {
|
|
if (metaKey) selection = [].concat(_toConsumableArray(this.state.selection), [event.value]);else selection = [event.value];
|
|
}
|
|
|
|
this.setState({
|
|
selection: selection
|
|
});
|
|
}
|
|
}, {
|
|
key: "onItemKeyDown",
|
|
value: function onItemKeyDown(event) {
|
|
var listItem = event.originalEvent.currentTarget;
|
|
|
|
switch (event.originalEvent.which) {
|
|
//down
|
|
case 40:
|
|
var nextItem = this.findNextItem(listItem);
|
|
|
|
if (nextItem) {
|
|
nextItem.focus();
|
|
}
|
|
|
|
event.originalEvent.preventDefault();
|
|
break;
|
|
//up
|
|
|
|
case 38:
|
|
var prevItem = this.findPrevItem(listItem);
|
|
|
|
if (prevItem) {
|
|
prevItem.focus();
|
|
}
|
|
|
|
event.originalEvent.preventDefault();
|
|
break;
|
|
//enter
|
|
|
|
case 13:
|
|
this.onItemClick(event);
|
|
event.originalEvent.preventDefault();
|
|
break;
|
|
}
|
|
}
|
|
}, {
|
|
key: "findNextItem",
|
|
value: function findNextItem(item) {
|
|
var nextItem = item.nextElementSibling;
|
|
if (nextItem) return !DomHandler.hasClass(nextItem, 'p-orderlist-item') ? this.findNextItem(nextItem) : nextItem;else return null;
|
|
}
|
|
}, {
|
|
key: "findPrevItem",
|
|
value: function findPrevItem(item) {
|
|
var prevItem = item.previousElementSibling;
|
|
if (prevItem) return !DomHandler.hasClass(prevItem, 'p-orderlist-item') ? this.findPrevItem(prevItem) : prevItem;else return null;
|
|
}
|
|
}, {
|
|
key: "onReorder",
|
|
value: function onReorder(event) {
|
|
if (this.props.onChange) {
|
|
this.props.onChange({
|
|
event: event.originalEvent,
|
|
value: event.value
|
|
});
|
|
}
|
|
|
|
this.reorderDirection = event.direction;
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate() {
|
|
if (this.reorderDirection) {
|
|
this.updateListScroll();
|
|
this.reorderDirection = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateListScroll",
|
|
value: function updateListScroll() {
|
|
var listItems = DomHandler.find(this.subList.listElement, '.p-orderlist-item.p-highlight');
|
|
|
|
if (listItems && listItems.length) {
|
|
switch (this.reorderDirection) {
|
|
case 'up':
|
|
DomHandler.scrollInView(this.subList.listElement, listItems[0]);
|
|
break;
|
|
|
|
case 'top':
|
|
this.subList.listElement.scrollTop = 0;
|
|
break;
|
|
|
|
case 'down':
|
|
DomHandler.scrollInView(this.subList.listElement, listItems[listItems.length - 1]);
|
|
break;
|
|
|
|
case 'bottom':
|
|
this.subList.listElement.scrollTop = this.subList.listElement.scrollHeight;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this2 = this;
|
|
|
|
var className = classNames('p-orderlist p-component', this.props.className);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this2.element = el;
|
|
},
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, /*#__PURE__*/React.createElement(OrderListControls, {
|
|
value: this.props.value,
|
|
selection: this.state.selection,
|
|
onReorder: this.onReorder,
|
|
dataKey: this.props.dataKey
|
|
}), /*#__PURE__*/React.createElement(OrderListSubList, {
|
|
ref: function ref(el) {
|
|
return _this2.subList = el;
|
|
},
|
|
value: this.props.value,
|
|
selection: this.state.selection,
|
|
onItemClick: this.onItemClick,
|
|
onItemKeyDown: this.onItemKeyDown,
|
|
itemTemplate: this.props.itemTemplate,
|
|
header: this.props.header,
|
|
listStyle: this.props.listStyle,
|
|
dataKey: this.props.dataKey,
|
|
dragdrop: this.props.dragdrop,
|
|
onDragStart: this.onDragStart,
|
|
onDragEnter: this.onDragEnter,
|
|
onDragEnd: this.onDragEnd,
|
|
onDragLeave: this.onDragEnter,
|
|
onDrop: this.onDrop,
|
|
onChange: this.props.onChange,
|
|
tabIndex: this.props.tabIndex
|
|
}));
|
|
}
|
|
}]);
|
|
|
|
return OrderList;
|
|
}(Component);
|
|
|
|
_defineProperty(OrderList, "defaultProps", {
|
|
id: null,
|
|
value: null,
|
|
header: null,
|
|
style: null,
|
|
className: null,
|
|
listStyle: null,
|
|
dragdrop: false,
|
|
tabIndex: 0,
|
|
dataKey: null,
|
|
onChange: null,
|
|
itemTemplate: null
|
|
});
|
|
|
|
function _createSuper$S(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$S(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$S() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var OrganizationChartNode = /*#__PURE__*/function (_Component) {
|
|
_inherits(OrganizationChartNode, _Component);
|
|
|
|
var _super = _createSuper$S(OrganizationChartNode);
|
|
|
|
function OrganizationChartNode(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, OrganizationChartNode);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.node = _this.props.node;
|
|
_this.state = {
|
|
expanded: _this.node.expanded
|
|
};
|
|
return _this;
|
|
}
|
|
|
|
_createClass(OrganizationChartNode, [{
|
|
key: "getLeaf",
|
|
value: function getLeaf() {
|
|
return this.node.leaf === false ? false : !(this.node.children && this.node.children.length);
|
|
}
|
|
}, {
|
|
key: "getColspan",
|
|
value: function getColspan() {
|
|
return this.node.children && this.node.children.length ? this.node.children.length * 2 : null;
|
|
}
|
|
}, {
|
|
key: "onNodeClick",
|
|
value: function onNodeClick(event, node) {
|
|
this.props.onNodeClick(event, node);
|
|
}
|
|
}, {
|
|
key: "toggleNode",
|
|
value: function toggleNode(event, node) {
|
|
this.setState(function (prevState) {
|
|
return {
|
|
expanded: !prevState.expanded
|
|
};
|
|
});
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "isSelected",
|
|
value: function isSelected() {
|
|
return this.props.isSelected(this.node);
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this2 = this;
|
|
|
|
this.node = this.props.node;
|
|
var colspan = this.getColspan();
|
|
var nodeClassName = classNames('p-organizationchart-node-content', this.node.className, {
|
|
'p-organizationchart-selectable-node': this.props.selectionMode && this.node.selectable !== false,
|
|
'p-highlight': this.isSelected()
|
|
}),
|
|
nodeLabel = this.props.nodeTemplate && this.props.nodeTemplate(this.node) ? /*#__PURE__*/React.createElement("div", null, this.props.nodeTemplate(this.node)) : /*#__PURE__*/React.createElement("div", null, this.node.label),
|
|
toggleIcon = classNames('p-node-toggler-icon', {
|
|
'pi pi-chevron-down': this.state.expanded,
|
|
'pi pi-chevron-up': !this.state.expanded
|
|
}),
|
|
nodeContent = /*#__PURE__*/React.createElement("tr", null, /*#__PURE__*/React.createElement("td", {
|
|
colSpan: colspan
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: nodeClassName,
|
|
onClick: function onClick(e) {
|
|
return _this2.onNodeClick(e, _this2.node);
|
|
}
|
|
}, nodeLabel,
|
|
/* eslint-disable */
|
|
!this.getLeaf() && /*#__PURE__*/React.createElement("a", {
|
|
href: "#",
|
|
className: "p-node-toggler",
|
|
onClick: function onClick(e) {
|
|
return _this2.toggleNode(e, _this2.node);
|
|
}
|
|
}, /*#__PURE__*/React.createElement("i", {
|
|
className: toggleIcon
|
|
}))
|
|
/* eslint-enable */
|
|
)));
|
|
|
|
var _visibility = !this.getLeaf() && this.state.expanded ? 'inherit' : 'hidden',
|
|
linesDown = /*#__PURE__*/React.createElement("tr", {
|
|
style: {
|
|
visibility: _visibility
|
|
},
|
|
className: "p-organizationchart-lines"
|
|
}, /*#__PURE__*/React.createElement("td", {
|
|
colSpan: colspan
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-organizationchart-line-down"
|
|
}))),
|
|
nodeChildLength = this.node.children && this.node.children.length,
|
|
linesMiddle = /*#__PURE__*/React.createElement("tr", {
|
|
style: {
|
|
visibility: _visibility
|
|
},
|
|
className: "p-organizationchart-lines"
|
|
}, this.node.children && this.node.children.length === 1 && /*#__PURE__*/React.createElement("td", {
|
|
colSpan: this.getColspan()
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-organizationchart-line-down"
|
|
})), this.node.children && this.node.children.length > 1 && this.node.children.map(function (item, index) {
|
|
var leftClass = classNames('p-organizationchart-line-left', {
|
|
'p-organizationchart-line-top': index !== 0
|
|
}),
|
|
rightClass = classNames('p-organizationchart-line-right', {
|
|
'p-organizationchart-line-top': index !== nodeChildLength - 1
|
|
});
|
|
return [/*#__PURE__*/React.createElement("td", {
|
|
key: index + '_lineleft',
|
|
className: leftClass
|
|
}, "\xA0"), /*#__PURE__*/React.createElement("td", {
|
|
key: index + '_lineright',
|
|
className: rightClass
|
|
}, "\xA0")];
|
|
})),
|
|
childNodes = /*#__PURE__*/React.createElement("tr", {
|
|
style: {
|
|
visibility: _visibility
|
|
},
|
|
className: "p-organizationchart-nodes"
|
|
}, this.node.children && this.node.children.map(function (child, index) {
|
|
return /*#__PURE__*/React.createElement("td", {
|
|
key: index,
|
|
colSpan: "2"
|
|
}, /*#__PURE__*/React.createElement(OrganizationChartNode, {
|
|
node: child,
|
|
nodeTemplate: _this2.props.nodeTemplate,
|
|
selectionMode: _this2.props.selectionMode,
|
|
onNodeClick: _this2.props.onNodeClick,
|
|
isSelected: _this2.props.isSelected
|
|
}));
|
|
}));
|
|
|
|
return /*#__PURE__*/React.createElement("table", {
|
|
className: "p-organizationchart-table"
|
|
}, /*#__PURE__*/React.createElement("tbody", null, nodeContent, linesDown, linesMiddle, childNodes));
|
|
}
|
|
}]);
|
|
|
|
return OrganizationChartNode;
|
|
}(Component);
|
|
|
|
_defineProperty(OrganizationChartNode, "defaultProps", {
|
|
node: null,
|
|
nodeTemplate: null,
|
|
root: false,
|
|
first: false,
|
|
last: false,
|
|
selectionMode: null,
|
|
onNodeClick: null,
|
|
isSelected: null
|
|
});
|
|
|
|
var OrganizationChart = /*#__PURE__*/function (_Component2) {
|
|
_inherits(OrganizationChart, _Component2);
|
|
|
|
var _super2 = _createSuper$S(OrganizationChart);
|
|
|
|
function OrganizationChart(props) {
|
|
var _this3;
|
|
|
|
_classCallCheck(this, OrganizationChart);
|
|
|
|
_this3 = _super2.call(this, props);
|
|
_this3.root = _this3.props.value && _this3.props.value.length ? _this3.props.value[0] : null;
|
|
_this3.onNodeClick = _this3.onNodeClick.bind(_assertThisInitialized(_this3));
|
|
_this3.isSelected = _this3.isSelected.bind(_assertThisInitialized(_this3));
|
|
return _this3;
|
|
}
|
|
|
|
_createClass(OrganizationChart, [{
|
|
key: "onNodeClick",
|
|
value: function onNodeClick(event, node) {
|
|
if (this.props.selectionMode) {
|
|
var eventTarget = event.target;
|
|
|
|
if (eventTarget.className && (eventTarget.className.indexOf('p-node-toggler') !== -1 || eventTarget.className.indexOf('p-node-toggler-icon') !== -1)) {
|
|
return;
|
|
}
|
|
|
|
if (node.selectable === false) {
|
|
return;
|
|
}
|
|
|
|
var index = this.findIndexInSelection(node);
|
|
var selected = index >= 0;
|
|
var selection;
|
|
|
|
if (this.props.selectionMode === 'single') {
|
|
if (selected) {
|
|
selection = null;
|
|
|
|
if (this.props.onNodeUnselect) {
|
|
this.props.onNodeUnselect({
|
|
originalEvent: event,
|
|
node: node
|
|
});
|
|
}
|
|
} else {
|
|
selection = node;
|
|
|
|
if (this.props.onNodeSelect) {
|
|
this.props.onNodeSelect({
|
|
originalEvent: event,
|
|
node: node
|
|
});
|
|
}
|
|
}
|
|
} else if (this.props.selectionMode === 'multiple') {
|
|
if (selected) {
|
|
selection = this.props.selection.filter(function (val, i) {
|
|
return i !== index;
|
|
});
|
|
|
|
if (this.props.onNodeUnselect) {
|
|
this.props.onNodeUnselect({
|
|
originalEvent: event,
|
|
node: node
|
|
});
|
|
}
|
|
} else {
|
|
selection = [].concat(_toConsumableArray(this.props.selection || []), [node]);
|
|
|
|
if (this.props.onNodeSelect) {
|
|
this.props.onNodeSelect({
|
|
originalEvent: event,
|
|
node: node
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.props.onSelectionChange) {
|
|
this.props.onSelectionChange({
|
|
originalEvent: event,
|
|
data: selection
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "findIndexInSelection",
|
|
value: function findIndexInSelection(node) {
|
|
var index = -1;
|
|
|
|
if (this.props.selectionMode && this.props.selection) {
|
|
if (this.props.selectionMode === 'single') {
|
|
index = this.props.selection === node ? 0 : -1;
|
|
} else if (this.props.selectionMode === 'multiple') {
|
|
for (var i = 0; i < this.props.selection.length; i++) {
|
|
if (this.props.selection[i] === node) {
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return index;
|
|
}
|
|
}, {
|
|
key: "isSelected",
|
|
value: function isSelected(node) {
|
|
return this.findIndexInSelection(node) !== -1;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
this.root = this.props.value && this.props.value.length ? this.props.value[0] : null;
|
|
var className = classNames('p-organizationchart p-component', this.props.className);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
style: this.props.style,
|
|
className: className
|
|
}, /*#__PURE__*/React.createElement(OrganizationChartNode, {
|
|
node: this.root,
|
|
nodeTemplate: this.props.nodeTemplate,
|
|
selectionMode: this.props.selectionMode,
|
|
onNodeClick: this.onNodeClick,
|
|
isSelected: this.isSelected
|
|
}));
|
|
}
|
|
}]);
|
|
|
|
return OrganizationChart;
|
|
}(Component);
|
|
|
|
_defineProperty(OrganizationChart, "defaultProps", {
|
|
id: null,
|
|
value: null,
|
|
style: null,
|
|
className: null,
|
|
selectionMode: null,
|
|
selection: null,
|
|
nodeTemplate: null,
|
|
onSelectionChange: null,
|
|
onNodeSelect: null,
|
|
onNodeUnselect: null
|
|
});
|
|
|
|
function _createSuper$R(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$R(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$R() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var OverlayPanel = /*#__PURE__*/function (_Component) {
|
|
_inherits(OverlayPanel, _Component);
|
|
|
|
var _super = _createSuper$R(OverlayPanel);
|
|
|
|
function OverlayPanel(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, OverlayPanel);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
visible: false
|
|
};
|
|
_this.onCloseClick = _this.onCloseClick.bind(_assertThisInitialized(_this));
|
|
_this.onPanelClick = _this.onPanelClick.bind(_assertThisInitialized(_this));
|
|
_this.onEnter = _this.onEnter.bind(_assertThisInitialized(_this));
|
|
_this.onEntered = _this.onEntered.bind(_assertThisInitialized(_this));
|
|
_this.onExit = _this.onExit.bind(_assertThisInitialized(_this));
|
|
_this.onExited = _this.onExited.bind(_assertThisInitialized(_this));
|
|
_this.onContentClick = _this.onContentClick.bind(_assertThisInitialized(_this));
|
|
_this.attributeSelector = UniqueComponentId();
|
|
_this.overlayRef = /*#__PURE__*/React.createRef();
|
|
return _this;
|
|
}
|
|
|
|
_createClass(OverlayPanel, [{
|
|
key: "bindDocumentClickListener",
|
|
value: function bindDocumentClickListener() {
|
|
var _this2 = this;
|
|
|
|
if (!this.documentClickListener && this.props.dismissable) {
|
|
this.documentClickListener = function (event) {
|
|
if (!_this2.isPanelClicked && _this2.isOutsideClicked(event.target)) {
|
|
_this2.hide();
|
|
}
|
|
|
|
_this2.isPanelClicked = false;
|
|
};
|
|
|
|
document.addEventListener('click', this.documentClickListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentClickListener",
|
|
value: function unbindDocumentClickListener() {
|
|
if (this.documentClickListener) {
|
|
document.removeEventListener('click', this.documentClickListener);
|
|
this.documentClickListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindScrollListener",
|
|
value: function bindScrollListener() {
|
|
var _this3 = this;
|
|
|
|
if (!this.scrollHandler) {
|
|
this.scrollHandler = new ConnectedOverlayScrollHandler(this.target, function () {
|
|
if (_this3.state.visible) {
|
|
_this3.hide();
|
|
}
|
|
});
|
|
}
|
|
|
|
this.scrollHandler.bindScrollListener();
|
|
}
|
|
}, {
|
|
key: "unbindScrollListener",
|
|
value: function unbindScrollListener() {
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.unbindScrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindResizeListener",
|
|
value: function bindResizeListener() {
|
|
var _this4 = this;
|
|
|
|
if (!this.resizeListener) {
|
|
this.resizeListener = function () {
|
|
if (_this4.state.visible && !DomHandler.isTouchDevice()) {
|
|
_this4.hide();
|
|
}
|
|
};
|
|
|
|
window.addEventListener('resize', this.resizeListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindResizeListener",
|
|
value: function unbindResizeListener() {
|
|
if (this.resizeListener) {
|
|
window.removeEventListener('resize', this.resizeListener);
|
|
this.resizeListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "isOutsideClicked",
|
|
value: function isOutsideClicked(target) {
|
|
return this.overlayRef && this.overlayRef.current && !(this.overlayRef.current.isSameNode(target) || this.overlayRef.current.contains(target));
|
|
}
|
|
}, {
|
|
key: "hasTargetChanged",
|
|
value: function hasTargetChanged(event, target) {
|
|
return this.target != null && this.target !== (target || event.currentTarget || event.target);
|
|
}
|
|
}, {
|
|
key: "onCloseClick",
|
|
value: function onCloseClick(event) {
|
|
this.hide();
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onPanelClick",
|
|
value: function onPanelClick(event) {
|
|
this.isPanelClicked = true;
|
|
OverlayService.emit('overlay-click', {
|
|
originalEvent: event,
|
|
target: this.target
|
|
});
|
|
}
|
|
}, {
|
|
key: "onContentClick",
|
|
value: function onContentClick() {
|
|
this.isPanelClicked = true;
|
|
}
|
|
}, {
|
|
key: "toggle",
|
|
value: function toggle(event, target) {
|
|
var _this5 = this;
|
|
|
|
if (this.state.visible) {
|
|
this.hide();
|
|
|
|
if (this.hasTargetChanged(event, target)) {
|
|
this.target = target || event.currentTarget || event.target;
|
|
setTimeout(function () {
|
|
_this5.show(event, _this5.target);
|
|
}, 200);
|
|
}
|
|
} else {
|
|
this.show(event, target);
|
|
}
|
|
}
|
|
}, {
|
|
key: "show",
|
|
value: function show(event, target) {
|
|
var _this6 = this;
|
|
|
|
this.target = target || event.currentTarget || event.target;
|
|
|
|
if (this.state.visible) {
|
|
this.align();
|
|
} else {
|
|
this.setState({
|
|
visible: true
|
|
}, function () {
|
|
_this6.overlayEventListener = function (e) {
|
|
if (!_this6.isOutsideClicked(e.target)) {
|
|
_this6.isPanelClicked = true;
|
|
}
|
|
};
|
|
|
|
OverlayService.on('overlay-click', _this6.overlayEventListener);
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "hide",
|
|
value: function hide() {
|
|
var _this7 = this;
|
|
|
|
this.setState({
|
|
visible: false
|
|
}, function () {
|
|
OverlayService.off('overlay-click', _this7.overlayEventListener);
|
|
_this7.overlayEventListener = null;
|
|
});
|
|
}
|
|
}, {
|
|
key: "onEnter",
|
|
value: function onEnter() {
|
|
ZIndexUtils.set('overlay', this.overlayRef.current, PrimeReact.autoZIndex, PrimeReact.zIndex['overlay']);
|
|
this.overlayRef.current.setAttribute(this.attributeSelector, '');
|
|
this.align();
|
|
}
|
|
}, {
|
|
key: "onEntered",
|
|
value: function onEntered() {
|
|
this.bindDocumentClickListener();
|
|
this.bindScrollListener();
|
|
this.bindResizeListener();
|
|
this.props.onShow && this.props.onShow();
|
|
}
|
|
}, {
|
|
key: "onExit",
|
|
value: function onExit() {
|
|
this.unbindDocumentClickListener();
|
|
this.unbindScrollListener();
|
|
this.unbindResizeListener();
|
|
}
|
|
}, {
|
|
key: "onExited",
|
|
value: function onExited() {
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
this.props.onHide && this.props.onHide();
|
|
}
|
|
}, {
|
|
key: "align",
|
|
value: function align() {
|
|
if (this.target) {
|
|
DomHandler.absolutePosition(this.overlayRef.current, this.target);
|
|
var containerOffset = DomHandler.getOffset(this.overlayRef.current);
|
|
var targetOffset = DomHandler.getOffset(this.target);
|
|
var arrowLeft = 0;
|
|
|
|
if (containerOffset.left < targetOffset.left) {
|
|
arrowLeft = targetOffset.left - containerOffset.left;
|
|
}
|
|
|
|
this.overlayRef.current.style.setProperty('--overlayArrowLeft', "".concat(arrowLeft, "px"));
|
|
|
|
if (containerOffset.top < targetOffset.top) {
|
|
DomHandler.addClass(this.overlayRef.current, 'p-overlaypanel-flipped');
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "createStyle",
|
|
value: function createStyle() {
|
|
if (!this.styleElement) {
|
|
this.styleElement = DomHandler.createInlineStyle(PrimeReact.nonce);
|
|
var innerHTML = '';
|
|
|
|
for (var breakpoint in this.props.breakpoints) {
|
|
innerHTML += "\n @media screen and (max-width: ".concat(breakpoint, ") {\n .p-overlaypanel[").concat(this.attributeSelector, "] {\n width: ").concat(this.props.breakpoints[breakpoint], " !important;\n }\n }\n ");
|
|
}
|
|
|
|
this.styleElement.innerHTML = innerHTML;
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (this.props.breakpoints) {
|
|
this.createStyle();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.unbindDocumentClickListener();
|
|
this.unbindResizeListener();
|
|
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.destroy();
|
|
this.scrollHandler = null;
|
|
}
|
|
|
|
this.styleElement = DomHandler.removeInlineStyle(this.styleElement);
|
|
|
|
if (this.overlayEventListener) {
|
|
OverlayService.off('overlay-click', this.overlayEventListener);
|
|
this.overlayEventListener = null;
|
|
}
|
|
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
}
|
|
}, {
|
|
key: "renderCloseIcon",
|
|
value: function renderCloseIcon() {
|
|
if (this.props.showCloseIcon) {
|
|
return /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "p-overlaypanel-close p-link",
|
|
onClick: this.onCloseClick,
|
|
"aria-label": this.props.ariaCloseLabel
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-overlaypanel-close-icon pi pi-times"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
var className = classNames('p-overlaypanel p-component', this.props.className);
|
|
var closeIcon = this.renderCloseIcon();
|
|
return /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.overlayRef,
|
|
classNames: "p-overlaypanel",
|
|
"in": this.state.visible,
|
|
timeout: {
|
|
enter: 120,
|
|
exit: 100
|
|
},
|
|
options: this.props.transitionOptions,
|
|
unmountOnExit: true,
|
|
onEnter: this.onEnter,
|
|
onEntered: this.onEntered,
|
|
onExit: this.onExit,
|
|
onExited: this.onExited
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.overlayRef,
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style,
|
|
onClick: this.onPanelClick
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-overlaypanel-content",
|
|
onClick: this.onContentClick,
|
|
onMouseDown: this.onContentClick
|
|
}, this.props.children), closeIcon));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var element = this.renderElement();
|
|
return /*#__PURE__*/React.createElement(Portal, {
|
|
element: element,
|
|
appendTo: this.props.appendTo
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return OverlayPanel;
|
|
}(Component);
|
|
|
|
_defineProperty(OverlayPanel, "defaultProps", {
|
|
id: null,
|
|
dismissable: true,
|
|
showCloseIcon: false,
|
|
style: null,
|
|
className: null,
|
|
appendTo: null,
|
|
breakpoints: null,
|
|
ariaCloseLabel: 'close',
|
|
transitionOptions: null,
|
|
onShow: null,
|
|
onHide: null
|
|
});
|
|
|
|
function ownKeys$h(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$h(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$h(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$h(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$Q(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$Q(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$Q() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Panel = /*#__PURE__*/function (_Component) {
|
|
_inherits(Panel, _Component);
|
|
|
|
var _super = _createSuper$Q(Panel);
|
|
|
|
function Panel(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Panel);
|
|
|
|
_this = _super.call(this, props);
|
|
var state = {
|
|
id: _this.props.id
|
|
};
|
|
|
|
if (!_this.props.onToggle) {
|
|
state = _objectSpread$h(_objectSpread$h({}, state), {}, {
|
|
collapsed: _this.props.collapsed
|
|
});
|
|
}
|
|
|
|
_this.state = state;
|
|
_this.toggle = _this.toggle.bind(_assertThisInitialized(_this));
|
|
_this.contentRef = /*#__PURE__*/React.createRef();
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Panel, [{
|
|
key: "toggle",
|
|
value: function toggle(event) {
|
|
if (this.props.toggleable) {
|
|
var collapsed = this.props.onToggle ? this.props.collapsed : this.state.collapsed;
|
|
if (collapsed) this.expand(event);else this.collapse(event);
|
|
|
|
if (this.props.onToggle) {
|
|
this.props.onToggle({
|
|
originalEvent: event,
|
|
value: !collapsed
|
|
});
|
|
}
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "expand",
|
|
value: function expand(event) {
|
|
if (!this.props.onToggle) {
|
|
this.setState({
|
|
collapsed: false
|
|
});
|
|
}
|
|
|
|
if (this.props.onExpand) {
|
|
this.props.onExpand(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "collapse",
|
|
value: function collapse(event) {
|
|
if (!this.props.onToggle) {
|
|
this.setState({
|
|
collapsed: true
|
|
});
|
|
}
|
|
|
|
if (this.props.onCollapse) {
|
|
this.props.onCollapse(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "isCollapsed",
|
|
value: function isCollapsed() {
|
|
return this.props.toggleable ? this.props.onToggle ? this.props.collapsed : this.state.collapsed : false;
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (!this.state.id) {
|
|
this.setState({
|
|
id: UniqueComponentId()
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderToggleIcon",
|
|
value: function renderToggleIcon(collapsed) {
|
|
if (this.props.toggleable) {
|
|
var id = this.state.id + '_label';
|
|
var ariaControls = this.state.id + '_content';
|
|
var toggleIcon = collapsed ? this.props.expandIcon : this.props.collapseIcon;
|
|
return /*#__PURE__*/React.createElement("button", {
|
|
className: "p-panel-header-icon p-panel-toggler p-link",
|
|
onClick: this.toggle,
|
|
id: id,
|
|
"aria-controls": ariaControls,
|
|
"aria-expanded": !collapsed,
|
|
role: "tab"
|
|
}, IconUtils.getJSXIcon(toggleIcon, {
|
|
props: this.props,
|
|
collapsed: collapsed
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderHeader",
|
|
value: function renderHeader(collapsed) {
|
|
var header = ObjectUtils.getJSXElement(this.props.header, this.props);
|
|
var icons = ObjectUtils.getJSXElement(this.props.icons, this.props);
|
|
var togglerElement = this.renderToggleIcon(collapsed);
|
|
var titleElement = /*#__PURE__*/React.createElement("span", {
|
|
className: "p-panel-title",
|
|
id: this.state.id + '_header'
|
|
}, header);
|
|
var iconsElement = /*#__PURE__*/React.createElement("div", {
|
|
className: "p-panel-icons"
|
|
}, icons, togglerElement);
|
|
var content = /*#__PURE__*/React.createElement("div", {
|
|
className: "p-panel-header"
|
|
}, titleElement, iconsElement);
|
|
|
|
if (this.props.headerTemplate) {
|
|
var defaultContentOptions = {
|
|
className: 'p-panel-header',
|
|
titleClassName: 'p-panel-title',
|
|
iconsClassName: 'p-panel-icons',
|
|
togglerClassName: 'p-panel-header-icon p-panel-toggler p-link',
|
|
togglerIconClassName: collapsed ? this.props.expandIcon : this.props.collapseIcon,
|
|
onTogglerClick: this.toggle,
|
|
titleElement: titleElement,
|
|
iconsElement: iconsElement,
|
|
togglerElement: togglerElement,
|
|
element: content,
|
|
props: this.props,
|
|
collapsed: collapsed
|
|
};
|
|
return ObjectUtils.getJSXElement(this.props.headerTemplate, defaultContentOptions);
|
|
} else if (this.props.header || this.props.toggleable) {
|
|
return content;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent(collapsed) {
|
|
var id = this.state.id + '_content';
|
|
return /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.contentRef,
|
|
classNames: "p-toggleable-content",
|
|
timeout: {
|
|
enter: 1000,
|
|
exit: 450
|
|
},
|
|
"in": !collapsed,
|
|
unmountOnExit: true,
|
|
options: this.props.transitionOptions
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.contentRef,
|
|
className: "p-toggleable-content",
|
|
"aria-hidden": collapsed,
|
|
role: "region",
|
|
id: id,
|
|
"aria-labelledby": this.state.id + '_header'
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-panel-content"
|
|
}, this.props.children)));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-panel p-component', {
|
|
'p-panel-toggleable': this.props.toggleable
|
|
}, this.props.className);
|
|
var collapsed = this.isCollapsed();
|
|
var header = this.renderHeader(collapsed);
|
|
var content = this.renderContent(collapsed);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, header, content);
|
|
}
|
|
}]);
|
|
|
|
return Panel;
|
|
}(Component);
|
|
|
|
_defineProperty(Panel, "defaultProps", {
|
|
id: null,
|
|
header: null,
|
|
headerTemplate: null,
|
|
toggleable: null,
|
|
style: null,
|
|
className: null,
|
|
collapsed: null,
|
|
expandIcon: 'pi pi-plus',
|
|
collapseIcon: 'pi pi-minus',
|
|
icons: null,
|
|
transitionOptions: null,
|
|
onExpand: null,
|
|
onCollapse: null,
|
|
onToggle: null
|
|
});
|
|
|
|
function _createSuper$P(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$P(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$P() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
var PanelMenuSub = /*#__PURE__*/function (_Component) {
|
|
_inherits(PanelMenuSub, _Component);
|
|
|
|
var _super = _createSuper$P(PanelMenuSub);
|
|
|
|
function PanelMenuSub(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, PanelMenuSub);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
activeItem: _this.findActiveItem()
|
|
};
|
|
return _this;
|
|
}
|
|
|
|
_createClass(PanelMenuSub, [{
|
|
key: "onItemClick",
|
|
value: function onItemClick(event, item) {
|
|
if (item.disabled) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
if (!item.url) {
|
|
event.preventDefault();
|
|
}
|
|
|
|
if (item.command) {
|
|
item.command({
|
|
originalEvent: event,
|
|
item: item
|
|
});
|
|
}
|
|
|
|
var activeItem = this.state.activeItem;
|
|
var active = this.isItemActive(item);
|
|
|
|
if (active) {
|
|
item.expanded = false;
|
|
this.setState({
|
|
activeItem: this.props.multiple ? activeItem.filter(function (a_item) {
|
|
return a_item !== item;
|
|
}) : null
|
|
});
|
|
} else {
|
|
if (!this.props.multiple && activeItem) {
|
|
activeItem.expanded = false;
|
|
}
|
|
|
|
item.expanded = true;
|
|
this.setState({
|
|
activeItem: this.props.multiple ? [].concat(_toConsumableArray(activeItem || []), [item]) : item
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "findActiveItem",
|
|
value: function findActiveItem() {
|
|
if (this.props.model) {
|
|
if (this.props.multiple) {
|
|
return this.props.model.filter(function (item) {
|
|
return item.expanded;
|
|
});
|
|
} else {
|
|
var activeItem = null;
|
|
this.props.model.forEach(function (item) {
|
|
if (item.expanded) {
|
|
if (!activeItem) activeItem = item;else item.expanded = false;
|
|
}
|
|
});
|
|
return activeItem;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "isItemActive",
|
|
value: function isItemActive(item) {
|
|
return this.state.activeItem && (this.props.multiple ? this.state.activeItem.indexOf(item) > -1 : this.state.activeItem === item);
|
|
}
|
|
}, {
|
|
key: "renderSeparator",
|
|
value: function renderSeparator(index) {
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: 'separator_' + index,
|
|
className: "p-menu-separator"
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderSubmenu",
|
|
value: function renderSubmenu(item, active) {
|
|
var submenuWrapperClassName = classNames('p-toggleable-content', {
|
|
'p-toggleable-content-collapsed': !active
|
|
});
|
|
var submenuContentRef = /*#__PURE__*/React.createRef();
|
|
|
|
if (item.items) {
|
|
return /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: submenuContentRef,
|
|
classNames: "p-toggleable-content",
|
|
timeout: {
|
|
enter: 1000,
|
|
exit: 450
|
|
},
|
|
"in": active,
|
|
unmountOnExit: true
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: submenuContentRef,
|
|
className: submenuWrapperClassName
|
|
}, /*#__PURE__*/React.createElement(PanelMenuSub, {
|
|
model: item.items,
|
|
multiple: this.props.multiple
|
|
})));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderMenuitem",
|
|
value: function renderMenuitem(item, index) {
|
|
var _this2 = this;
|
|
|
|
var active = this.isItemActive(item);
|
|
var className = classNames('p-menuitem', item.className);
|
|
var linkClassName = classNames('p-menuitem-link', {
|
|
'p-disabled': item.disabled
|
|
});
|
|
var iconClassName = classNames('p-menuitem-icon', item.icon);
|
|
var submenuIconClassName = classNames('p-panelmenu-icon pi pi-fw', {
|
|
'pi-angle-right': !active,
|
|
'pi-angle-down': active
|
|
});
|
|
var icon = item.icon && /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
});
|
|
var label = item.label && /*#__PURE__*/React.createElement("span", {
|
|
className: "p-menuitem-text"
|
|
}, item.label);
|
|
var submenuIcon = item.items && /*#__PURE__*/React.createElement("span", {
|
|
className: submenuIconClassName
|
|
});
|
|
var submenu = this.renderSubmenu(item, active);
|
|
var content = /*#__PURE__*/React.createElement("a", {
|
|
href: item.url || '#',
|
|
className: linkClassName,
|
|
target: item.target,
|
|
onClick: function onClick(event) {
|
|
return _this2.onItemClick(event, item, index);
|
|
},
|
|
role: "menuitem",
|
|
"aria-disabled": item.disabled
|
|
}, submenuIcon, icon, label);
|
|
|
|
if (item.template) {
|
|
var defaultContentOptions = {
|
|
onClick: function onClick(event) {
|
|
return _this2.onItemClick(event, item, index);
|
|
},
|
|
className: linkClassName,
|
|
labelClassName: 'p-menuitem-text',
|
|
iconClassName: iconClassName,
|
|
submenuIconClassName: submenuIconClassName,
|
|
element: content,
|
|
props: this.props,
|
|
leaf: !item.items,
|
|
active: active
|
|
};
|
|
content = ObjectUtils.getJSXElement(item.template, item, defaultContentOptions);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: item.label + '_' + index,
|
|
className: className,
|
|
style: item.style,
|
|
role: "none"
|
|
}, content, submenu);
|
|
}
|
|
}, {
|
|
key: "renderItem",
|
|
value: function renderItem(item, index) {
|
|
if (item.separator) return this.renderSeparator(index);else return this.renderMenuitem(item, index);
|
|
}
|
|
}, {
|
|
key: "renderMenu",
|
|
value: function renderMenu() {
|
|
var _this3 = this;
|
|
|
|
if (this.props.model) {
|
|
return this.props.model.map(function (item, index) {
|
|
return _this3.renderItem(item, index);
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-submenu-list', this.props.className);
|
|
var menu = this.renderMenu();
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
className: className,
|
|
role: "tree"
|
|
}, menu);
|
|
}
|
|
}]);
|
|
|
|
return PanelMenuSub;
|
|
}(Component);
|
|
|
|
_defineProperty(PanelMenuSub, "defaultProps", {
|
|
model: null,
|
|
multiple: false
|
|
});
|
|
|
|
var PanelMenu = /*#__PURE__*/function (_Component2) {
|
|
_inherits(PanelMenu, _Component2);
|
|
|
|
var _super2 = _createSuper$P(PanelMenu);
|
|
|
|
function PanelMenu(props) {
|
|
var _this4;
|
|
|
|
_classCallCheck(this, PanelMenu);
|
|
|
|
_this4 = _super2.call(this, props);
|
|
_this4.state = {
|
|
id: props.id,
|
|
activeItem: _this4.findActiveItem()
|
|
};
|
|
return _this4;
|
|
}
|
|
|
|
_createClass(PanelMenu, [{
|
|
key: "onItemClick",
|
|
value: function onItemClick(event, item) {
|
|
if (item.disabled) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
if (!item.url) {
|
|
event.preventDefault();
|
|
}
|
|
|
|
if (item.command) {
|
|
item.command({
|
|
originalEvent: event,
|
|
item: item
|
|
});
|
|
}
|
|
|
|
var activeItem = this.state.activeItem;
|
|
var active = this.isItemActive(item);
|
|
|
|
if (active) {
|
|
item.expanded = false;
|
|
this.setState({
|
|
activeItem: this.props.multiple ? activeItem.filter(function (a_item) {
|
|
return a_item !== item;
|
|
}) : null
|
|
});
|
|
} else {
|
|
if (!this.props.multiple && activeItem) {
|
|
activeItem.expanded = false;
|
|
}
|
|
|
|
item.expanded = true;
|
|
this.setState({
|
|
activeItem: this.props.multiple ? [].concat(_toConsumableArray(activeItem || []), [item]) : item
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "findActiveItem",
|
|
value: function findActiveItem() {
|
|
if (this.props.model) {
|
|
if (this.props.multiple) {
|
|
return this.props.model.filter(function (item) {
|
|
return item.expanded;
|
|
});
|
|
} else {
|
|
var activeItem = null;
|
|
this.props.model.forEach(function (item) {
|
|
if (item.expanded) {
|
|
if (!activeItem) activeItem = item;else item.expanded = false;
|
|
}
|
|
});
|
|
return activeItem;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "isItemActive",
|
|
value: function isItemActive(item) {
|
|
return this.state.activeItem && (this.props.multiple ? this.state.activeItem.indexOf(item) > -1 : this.state.activeItem === item);
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (!this.state.id) {
|
|
this.setState({
|
|
id: UniqueComponentId()
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderPanel",
|
|
value: function renderPanel(item, index) {
|
|
var _this5 = this;
|
|
|
|
var active = this.isItemActive(item);
|
|
var className = classNames('p-panelmenu-panel', item.className);
|
|
var headerClassName = classNames('p-component p-panelmenu-header', {
|
|
'p-highlight': active,
|
|
'p-disabled': item.disabled
|
|
});
|
|
var submenuIconClassName = classNames('p-panelmenu-icon pi', {
|
|
'pi-chevron-right': !active,
|
|
' pi-chevron-down': active
|
|
});
|
|
var iconClassName = classNames('p-menuitem-icon', item.icon);
|
|
var submenuIcon = item.items && /*#__PURE__*/React.createElement("span", {
|
|
className: submenuIconClassName
|
|
});
|
|
var itemIcon = item.icon && /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
});
|
|
var label = item.label && /*#__PURE__*/React.createElement("span", {
|
|
className: "p-menuitem-text"
|
|
}, item.label);
|
|
var contentWrapperClassName = classNames('p-toggleable-content', {
|
|
'p-toggleable-content-collapsed': !active
|
|
});
|
|
var menuContentRef = /*#__PURE__*/React.createRef();
|
|
var content = /*#__PURE__*/React.createElement("a", {
|
|
href: item.url || '#',
|
|
className: "p-panelmenu-header-link",
|
|
onClick: function onClick(e) {
|
|
return _this5.onItemClick(e, item);
|
|
},
|
|
"aria-expanded": active,
|
|
id: this.state.id + '_header',
|
|
"aria-controls": this.state.id + 'content',
|
|
"aria-disabled": item.disabled
|
|
}, submenuIcon, itemIcon, label);
|
|
|
|
if (item.template) {
|
|
var defaultContentOptions = {
|
|
onClick: function onClick(event) {
|
|
return _this5.onItemClick(event, item);
|
|
},
|
|
className: 'p-panelmenu-header-link',
|
|
labelClassName: 'p-menuitem-text',
|
|
submenuIconClassName: submenuIconClassName,
|
|
iconClassName: iconClassName,
|
|
element: content,
|
|
props: this.props,
|
|
leaf: !item.items,
|
|
active: active
|
|
};
|
|
content = ObjectUtils.getJSXElement(item.template, item, defaultContentOptions);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
key: item.label + '_' + index,
|
|
className: className,
|
|
style: item.style
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: headerClassName,
|
|
style: item.style
|
|
}, content), /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: menuContentRef,
|
|
classNames: "p-toggleable-content",
|
|
timeout: {
|
|
enter: 1000,
|
|
exit: 450
|
|
},
|
|
"in": active,
|
|
unmountOnExit: true,
|
|
options: this.props.transitionOptions
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: menuContentRef,
|
|
className: contentWrapperClassName,
|
|
role: "region",
|
|
id: this.state.id + '_content',
|
|
"aria-labelledby": this.state.id + '_header'
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-panelmenu-content"
|
|
}, /*#__PURE__*/React.createElement(PanelMenuSub, {
|
|
model: item.items,
|
|
className: "p-panelmenu-root-submenu",
|
|
multiple: this.props.multiple
|
|
})))));
|
|
}
|
|
}, {
|
|
key: "renderPanels",
|
|
value: function renderPanels() {
|
|
var _this6 = this;
|
|
|
|
if (this.props.model) {
|
|
return this.props.model.map(function (item, index) {
|
|
return _this6.renderPanel(item, index);
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-panelmenu p-component', this.props.className);
|
|
var panels = this.renderPanels();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, panels);
|
|
}
|
|
}]);
|
|
|
|
return PanelMenu;
|
|
}(Component);
|
|
|
|
_defineProperty(PanelMenu, "defaultProps", {
|
|
id: null,
|
|
model: null,
|
|
style: null,
|
|
className: null,
|
|
multiple: false,
|
|
transitionOptions: null
|
|
});
|
|
|
|
function ownKeys$g(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$g(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$g(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$g(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$O(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$O(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$O() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Password = /*#__PURE__*/function (_Component) {
|
|
_inherits(Password, _Component);
|
|
|
|
var _super = _createSuper$O(Password);
|
|
|
|
function Password(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Password);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
overlayVisible: false,
|
|
meter: null,
|
|
infoText: _this.promptLabel(),
|
|
focused: false,
|
|
unmasked: false
|
|
};
|
|
_this.onFocus = _this.onFocus.bind(_assertThisInitialized(_this));
|
|
_this.onBlur = _this.onBlur.bind(_assertThisInitialized(_this));
|
|
_this.onKeyup = _this.onKeyup.bind(_assertThisInitialized(_this));
|
|
_this.onInput = _this.onInput.bind(_assertThisInitialized(_this));
|
|
_this.onMaskToggle = _this.onMaskToggle.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEnter = _this.onOverlayEnter.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEntered = _this.onOverlayEntered.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExit = _this.onOverlayExit.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExited = _this.onOverlayExited.bind(_assertThisInitialized(_this));
|
|
_this.onPanelClick = _this.onPanelClick.bind(_assertThisInitialized(_this));
|
|
_this.overlayRef = /*#__PURE__*/createRef();
|
|
_this.inputRef = /*#__PURE__*/createRef(_this.props.inputRef);
|
|
_this.mediumCheckRegExp = new RegExp(_this.props.mediumRegex);
|
|
_this.strongCheckRegExp = new RegExp(_this.props.strongRegex);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Password, [{
|
|
key: "promptLabel",
|
|
value: function promptLabel() {
|
|
return this.props.promptLabel || localeOption('passwordPrompt');
|
|
}
|
|
}, {
|
|
key: "weakLabel",
|
|
value: function weakLabel() {
|
|
return this.props.weakLabel || localeOption('weak');
|
|
}
|
|
}, {
|
|
key: "mediumLabel",
|
|
value: function mediumLabel() {
|
|
return this.props.mediumLabel || localeOption('medium');
|
|
}
|
|
}, {
|
|
key: "strongLabel",
|
|
value: function strongLabel() {
|
|
return this.props.strongLabel || localeOption('strong');
|
|
}
|
|
}, {
|
|
key: "isFilled",
|
|
value: function isFilled() {
|
|
return this.props.value != null && this.props.value.toString().length > 0 || this.props.defaultValue != null && this.props.defaultValue.toString().length > 0 || this.inputRef && this.inputRef.current && DomHandler.hasClass(this.inputRef.current, 'p-filled');
|
|
}
|
|
}, {
|
|
key: "getInputType",
|
|
value: function getInputType() {
|
|
return this.state.unmasked ? 'text' : 'password';
|
|
}
|
|
}, {
|
|
key: "updateLabels",
|
|
value: function updateLabels() {
|
|
if (this.state.meter) {
|
|
var label = null;
|
|
|
|
switch (this.state.meter.strength) {
|
|
case 'weak':
|
|
label = this.weakLabel();
|
|
break;
|
|
|
|
case 'medium':
|
|
label = this.mediumLabel();
|
|
break;
|
|
|
|
case 'strong':
|
|
label = this.strongLabel();
|
|
break;
|
|
}
|
|
|
|
if (label && this.state.infoText !== label) {
|
|
this.setState({
|
|
infoText: label
|
|
});
|
|
}
|
|
} else {
|
|
var promptLabel = this.promptLabel();
|
|
|
|
if (this.state.infoText !== promptLabel) {
|
|
this.setState({
|
|
infoText: promptLabel
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onPanelClick",
|
|
value: function onPanelClick(event) {
|
|
if (this.props.feedback) {
|
|
OverlayService.emit('overlay-click', {
|
|
originalEvent: event,
|
|
target: this.container
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onMaskToggle",
|
|
value: function onMaskToggle() {
|
|
this.setState(function (prevState) {
|
|
return {
|
|
unmasked: !prevState.unmasked
|
|
};
|
|
});
|
|
}
|
|
}, {
|
|
key: "showOverlay",
|
|
value: function showOverlay() {
|
|
this.updateLabels();
|
|
this.setState({
|
|
overlayVisible: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "hideOverlay",
|
|
value: function hideOverlay() {
|
|
this.setState({
|
|
overlayVisible: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "alignOverlay",
|
|
value: function alignOverlay() {
|
|
if (this.inputRef && this.inputRef.current) {
|
|
DomHandler.alignOverlay(this.overlayRef.current, this.inputRef.current.parentElement, this.props.appendTo || PrimeReact.appendTo);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onOverlayEnter",
|
|
value: function onOverlayEnter() {
|
|
ZIndexUtils.set('overlay', this.overlayRef.current, PrimeReact.autoZIndex, PrimeReact.zIndex['overlay']);
|
|
this.alignOverlay();
|
|
}
|
|
}, {
|
|
key: "onOverlayEntered",
|
|
value: function onOverlayEntered() {
|
|
this.bindScrollListener();
|
|
this.bindResizeListener();
|
|
this.props.onShow && this.props.onShow();
|
|
}
|
|
}, {
|
|
key: "onOverlayExit",
|
|
value: function onOverlayExit() {
|
|
this.unbindScrollListener();
|
|
this.unbindResizeListener();
|
|
}
|
|
}, {
|
|
key: "onOverlayExited",
|
|
value: function onOverlayExited() {
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
this.props.onHide && this.props.onHide();
|
|
}
|
|
}, {
|
|
key: "onFocus",
|
|
value: function onFocus(event) {
|
|
var _this2 = this;
|
|
|
|
event.persist();
|
|
this.setState({
|
|
focused: true
|
|
}, function () {
|
|
if (_this2.props.feedback) {
|
|
_this2.showOverlay();
|
|
}
|
|
|
|
if (_this2.props.onFocus) {
|
|
_this2.props.onFocus(event);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onBlur",
|
|
value: function onBlur(event) {
|
|
var _this3 = this;
|
|
|
|
event.persist();
|
|
this.setState({
|
|
focused: false
|
|
}, function () {
|
|
if (_this3.props.feedback) {
|
|
_this3.hideOverlay();
|
|
}
|
|
|
|
if (_this3.props.onBlur) {
|
|
_this3.props.onBlur(event);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onKeyup",
|
|
value: function onKeyup(e) {
|
|
var _this4 = this;
|
|
|
|
var keyCode = e.keyCode || e.which;
|
|
|
|
if (this.props.feedback) {
|
|
var value = e.target.value;
|
|
var label = null;
|
|
var meter = null;
|
|
|
|
switch (this.testStrength(value)) {
|
|
case 1:
|
|
label = this.weakLabel();
|
|
meter = {
|
|
strength: 'weak',
|
|
width: '33.33%'
|
|
};
|
|
break;
|
|
|
|
case 2:
|
|
label = this.mediumLabel();
|
|
meter = {
|
|
strength: 'medium',
|
|
width: '66.66%'
|
|
};
|
|
break;
|
|
|
|
case 3:
|
|
label = this.strongLabel();
|
|
meter = {
|
|
strength: 'strong',
|
|
width: '100%'
|
|
};
|
|
break;
|
|
|
|
default:
|
|
label = this.promptLabel();
|
|
meter = null;
|
|
break;
|
|
}
|
|
|
|
this.setState({
|
|
meter: meter,
|
|
infoText: label
|
|
}, function () {
|
|
if (!!keyCode && !_this4.state.overlayVisible) {
|
|
_this4.showOverlay();
|
|
}
|
|
});
|
|
}
|
|
|
|
if (this.props.onKeyUp) {
|
|
this.props.onKeyUp(e);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onInput",
|
|
value: function onInput(event, validatePattern) {
|
|
if (this.props.onInput) {
|
|
this.props.onInput(event, validatePattern);
|
|
}
|
|
|
|
if (!this.props.onChange) {
|
|
if (event.target.value.length > 0) DomHandler.addClass(this.container, 'p-inputwrapper-filled');else DomHandler.removeClass(this.container, 'p-inputwrapper-filled');
|
|
}
|
|
}
|
|
}, {
|
|
key: "testStrength",
|
|
value: function testStrength(str) {
|
|
var level = 0;
|
|
if (this.strongCheckRegExp.test(str)) level = 3;else if (this.mediumCheckRegExp.test(str)) level = 2;else if (str.length) level = 1;
|
|
return level;
|
|
}
|
|
}, {
|
|
key: "bindScrollListener",
|
|
value: function bindScrollListener() {
|
|
var _this5 = this;
|
|
|
|
if (!this.scrollHandler) {
|
|
this.scrollHandler = new ConnectedOverlayScrollHandler(this.inputEl, function () {
|
|
if (_this5.state.overlayVisible) {
|
|
_this5.hideOverlay();
|
|
}
|
|
});
|
|
}
|
|
|
|
this.scrollHandler.bindScrollListener();
|
|
}
|
|
}, {
|
|
key: "unbindScrollListener",
|
|
value: function unbindScrollListener() {
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.unbindScrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindResizeListener",
|
|
value: function bindResizeListener() {
|
|
var _this6 = this;
|
|
|
|
if (!this.resizeListener) {
|
|
this.resizeListener = function () {
|
|
if (_this6.state.overlayVisible && !DomHandler.isTouchDevice()) {
|
|
_this6.hideOverlay();
|
|
}
|
|
};
|
|
|
|
window.addEventListener('resize', this.resizeListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindResizeListener",
|
|
value: function unbindResizeListener() {
|
|
if (this.resizeListener) {
|
|
window.removeEventListener('resize', this.resizeListener);
|
|
this.resizeListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateInputRef",
|
|
value: function updateInputRef() {
|
|
var ref = this.props.inputRef;
|
|
|
|
if (ref) {
|
|
if (typeof ref === 'function') {
|
|
ref(this.inputRef.current);
|
|
} else {
|
|
ref.current = this.inputRef.current;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.updateInputRef();
|
|
|
|
if (this.props.tooltip) {
|
|
this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$g({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
}
|
|
|
|
if (prevProps.mediumRegex !== this.props.mediumRegex) {
|
|
this.mediumCheckRegExp = new RegExp(this.props.mediumRegex);
|
|
}
|
|
|
|
if (prevProps.strongRegex !== this.props.strongRegex) {
|
|
this.strongCheckRegExp = new RegExp(this.props.strongRegex);
|
|
}
|
|
|
|
if (!this.isFilled() && DomHandler.hasClass(this.container, 'p-inputwrapper-filled')) {
|
|
DomHandler.removeClass(this.container, 'p-inputwrapper-filled');
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.unbindResizeListener();
|
|
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.destroy();
|
|
this.scrollHandler = null;
|
|
}
|
|
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.inputEl,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderIcon",
|
|
value: function renderIcon() {
|
|
if (this.props.toggleMask) {
|
|
var iconClassName = this.state.unmasked ? 'pi pi-eye-slash' : 'pi pi-eye';
|
|
var content = /*#__PURE__*/React.createElement("i", {
|
|
className: iconClassName,
|
|
onClick: this.onMaskToggle
|
|
});
|
|
|
|
if (this.props.icon) {
|
|
var defaultIconOptions = {
|
|
onClick: this.onMaskToggle,
|
|
className: iconClassName,
|
|
element: content,
|
|
props: this.props
|
|
};
|
|
content = ObjectUtils.getJSXElement(this.props.icon, defaultIconOptions);
|
|
}
|
|
|
|
return content;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderPanel",
|
|
value: function renderPanel() {
|
|
var panelClassName = classNames('p-password-panel p-component', this.props.panelClassName);
|
|
|
|
var _ref = this.state.meter || {
|
|
strength: '',
|
|
width: '0%'
|
|
},
|
|
strength = _ref.strength,
|
|
width = _ref.width;
|
|
|
|
var header = ObjectUtils.getJSXElement(this.props.header, this.props);
|
|
var footer = ObjectUtils.getJSXElement(this.props.footer, this.props);
|
|
var content = this.props.content ? ObjectUtils.getJSXElement(this.props.content, this.props) : /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-password-meter"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-password-strength ".concat(strength),
|
|
style: {
|
|
width: width
|
|
}
|
|
})), /*#__PURE__*/React.createElement("div", {
|
|
className: "p-password-info"
|
|
}, this.state.infoText));
|
|
var panel = /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.overlayRef,
|
|
classNames: "p-connected-overlay",
|
|
"in": this.state.overlayVisible,
|
|
timeout: {
|
|
enter: 120,
|
|
exit: 100
|
|
},
|
|
options: this.props.transitionOptions,
|
|
unmountOnExit: true,
|
|
onEnter: this.onOverlayEnter,
|
|
onEntered: this.onOverlayEntered,
|
|
onExit: this.onOverlayExit,
|
|
onExited: this.onOverlayExited
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.overlayRef,
|
|
className: panelClassName,
|
|
style: this.props.panelStyle,
|
|
onClick: this.onPanelClick
|
|
}, header, content, footer));
|
|
return /*#__PURE__*/React.createElement(Portal, {
|
|
element: panel,
|
|
appendTo: this.props.appendTo
|
|
});
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this7 = this;
|
|
|
|
var containerClassName = classNames('p-password p-component p-inputwrapper', {
|
|
'p-inputwrapper-filled': this.isFilled(),
|
|
'p-inputwrapper-focus': this.state.focused,
|
|
'p-input-icon-right': this.props.toggleMask
|
|
}, this.props.className);
|
|
var inputClassName = classNames('p-password-input', this.props.inputClassName);
|
|
var type = this.getInputType();
|
|
var inputProps = ObjectUtils.findDiffKeys(this.props, Password.defaultProps);
|
|
var icon = this.renderIcon();
|
|
var panel = this.renderPanel();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this7.container = el;
|
|
},
|
|
id: this.props.id,
|
|
className: containerClassName,
|
|
style: this.props.style
|
|
}, /*#__PURE__*/React.createElement(InputText, _extends({
|
|
ref: this.inputRef,
|
|
id: this.props.inputId
|
|
}, inputProps, {
|
|
type: type,
|
|
className: inputClassName,
|
|
style: this.props.inputStyle,
|
|
onFocus: this.onFocus,
|
|
onBlur: this.onBlur,
|
|
onKeyUp: this.onKeyup,
|
|
onInput: this.onInput
|
|
})), icon, panel);
|
|
}
|
|
}]);
|
|
|
|
return Password;
|
|
}(Component);
|
|
|
|
_defineProperty(Password, "defaultProps", {
|
|
id: null,
|
|
inputId: null,
|
|
inputRef: null,
|
|
promptLabel: null,
|
|
weakLabel: null,
|
|
mediumLabel: null,
|
|
strongLabel: null,
|
|
mediumRegex: '^(((?=.*[a-z])(?=.*[A-Z]))|((?=.*[a-z])(?=.*[0-9]))|((?=.*[A-Z])(?=.*[0-9])))(?=.{6,})',
|
|
strongRegex: '^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.{8,})',
|
|
feedback: true,
|
|
toggleMask: false,
|
|
appendTo: null,
|
|
header: null,
|
|
content: null,
|
|
footer: null,
|
|
icon: null,
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
style: null,
|
|
className: null,
|
|
inputStyle: null,
|
|
inputClassName: null,
|
|
panelStyle: null,
|
|
panelClassName: null,
|
|
transitionOptions: null,
|
|
onInput: null,
|
|
onShow: null,
|
|
onHide: null
|
|
});
|
|
|
|
function _createSuper$N(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$N(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$N() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var PickListItem = /*#__PURE__*/function (_Component) {
|
|
_inherits(PickListItem, _Component);
|
|
|
|
var _super = _createSuper$N(PickListItem);
|
|
|
|
function PickListItem(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, PickListItem);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(PickListItem, [{
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
if (this.props.onClick) {
|
|
this.props.onClick({
|
|
originalEvent: event,
|
|
value: this.props.value
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event) {
|
|
if (this.props.onKeyDown) {
|
|
this.props.onKeyDown({
|
|
originalEvent: event,
|
|
value: this.props.value
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var content = this.props.template ? this.props.template(this.props.value) : this.props.value;
|
|
var className = classNames('p-picklist-item', {
|
|
'p-highlight': this.props.selected
|
|
}, this.props.className);
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
className: className,
|
|
onClick: this.onClick,
|
|
onKeyDown: this.onKeyDown,
|
|
tabIndex: this.props.tabIndex,
|
|
role: "option",
|
|
"aria-selected": this.props.selected
|
|
}, content, /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
}]);
|
|
|
|
return PickListItem;
|
|
}(Component);
|
|
|
|
_defineProperty(PickListItem, "defaultProps", {
|
|
value: null,
|
|
className: null,
|
|
template: null,
|
|
selected: false,
|
|
tabIndex: null,
|
|
onClick: null,
|
|
onKeyDown: null
|
|
});
|
|
|
|
function _createSuper$M(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$M(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$M() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
var PickListSubListComponent = /*#__PURE__*/function (_Component) {
|
|
_inherits(PickListSubListComponent, _Component);
|
|
|
|
var _super = _createSuper$M(PickListSubListComponent);
|
|
|
|
function PickListSubListComponent(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, PickListSubListComponent);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onItemClick = _this.onItemClick.bind(_assertThisInitialized(_this));
|
|
_this.onItemKeyDown = _this.onItemKeyDown.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(PickListSubListComponent, [{
|
|
key: "onItemClick",
|
|
value: function onItemClick(event) {
|
|
var originalEvent = event.originalEvent;
|
|
var item = event.value;
|
|
|
|
var selection = _toConsumableArray(this.props.selection);
|
|
|
|
var index = ObjectUtils.findIndexInList(item, selection, this.props.dataKey);
|
|
var selected = index !== -1;
|
|
var metaSelection = this.props.metaKeySelection;
|
|
|
|
if (metaSelection) {
|
|
var metaKey = originalEvent.metaKey || originalEvent.ctrlKey;
|
|
|
|
if (selected && metaKey) {
|
|
selection.splice(index, 1);
|
|
} else {
|
|
if (!metaKey) {
|
|
selection.length = 0;
|
|
}
|
|
|
|
selection.push(item);
|
|
}
|
|
} else {
|
|
if (selected) selection.splice(index, 1);else selection.push(item);
|
|
}
|
|
|
|
if (this.props.onSelectionChange) {
|
|
this.props.onSelectionChange({
|
|
event: originalEvent,
|
|
value: selection
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onItemKeyDown",
|
|
value: function onItemKeyDown(event) {
|
|
var listItem = event.originalEvent.currentTarget;
|
|
|
|
switch (event.originalEvent.which) {
|
|
//down
|
|
case 40:
|
|
var nextItem = this.findNextItem(listItem);
|
|
|
|
if (nextItem) {
|
|
nextItem.focus();
|
|
}
|
|
|
|
event.originalEvent.preventDefault();
|
|
break;
|
|
//up
|
|
|
|
case 38:
|
|
var prevItem = this.findPrevItem(listItem);
|
|
|
|
if (prevItem) {
|
|
prevItem.focus();
|
|
}
|
|
|
|
event.originalEvent.preventDefault();
|
|
break;
|
|
//enter
|
|
|
|
case 13:
|
|
this.onItemClick(event);
|
|
event.originalEvent.preventDefault();
|
|
break;
|
|
}
|
|
}
|
|
}, {
|
|
key: "findNextItem",
|
|
value: function findNextItem(item) {
|
|
var nextItem = item.nextElementSibling;
|
|
if (nextItem) return !DomHandler.hasClass(nextItem, 'p-picklist-item') ? this.findNextItem(nextItem) : nextItem;else return null;
|
|
}
|
|
}, {
|
|
key: "findPrevItem",
|
|
value: function findPrevItem(item) {
|
|
var prevItem = item.previousElementSibling;
|
|
if (prevItem) return !DomHandler.hasClass(prevItem, 'p-picklist-item') ? this.findPrevItem(prevItem) : prevItem;else return null;
|
|
}
|
|
}, {
|
|
key: "isSelected",
|
|
value: function isSelected(item) {
|
|
return ObjectUtils.findIndexInList(item, this.props.selection, this.props.dataKey) !== -1;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this2 = this;
|
|
|
|
var header = null;
|
|
var items = null;
|
|
var wrapperClassName = classNames('p-picklist-list-wrapper', this.props.className);
|
|
var listClassName = classNames('p-picklist-list', this.props.listClassName);
|
|
|
|
if (this.props.header) {
|
|
header = /*#__PURE__*/React.createElement("div", {
|
|
className: "p-picklist-header"
|
|
}, ObjectUtils.getJSXElement(this.props.header, this.props));
|
|
}
|
|
|
|
if (this.props.list) {
|
|
items = this.props.list.map(function (item, i) {
|
|
return /*#__PURE__*/React.createElement(PickListItem, {
|
|
key: JSON.stringify(item),
|
|
value: item,
|
|
template: _this2.props.itemTemplate,
|
|
selected: _this2.isSelected(item),
|
|
onClick: _this2.onItemClick,
|
|
onKeyDown: _this2.onItemKeyDown,
|
|
tabIndex: _this2.props.tabIndex
|
|
});
|
|
});
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: this.props.forwardRef,
|
|
className: wrapperClassName
|
|
}, header, /*#__PURE__*/React.createElement("ul", {
|
|
className: listClassName,
|
|
style: this.props.style,
|
|
role: "listbox",
|
|
"aria-multiselectable": true
|
|
}, items));
|
|
}
|
|
}]);
|
|
|
|
return PickListSubListComponent;
|
|
}(Component);
|
|
|
|
var PickListSubList = /*#__PURE__*/React.forwardRef(function (props, ref) {
|
|
return /*#__PURE__*/React.createElement(PickListSubListComponent, _extends({
|
|
forwardRef: ref
|
|
}, props));
|
|
});
|
|
|
|
function _createSuper$L(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$L(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$L() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var PickListControls = /*#__PURE__*/function (_Component) {
|
|
_inherits(PickListControls, _Component);
|
|
|
|
var _super = _createSuper$L(PickListControls);
|
|
|
|
function PickListControls(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, PickListControls);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.moveUp = _this.moveUp.bind(_assertThisInitialized(_this));
|
|
_this.moveTop = _this.moveTop.bind(_assertThisInitialized(_this));
|
|
_this.moveDown = _this.moveDown.bind(_assertThisInitialized(_this));
|
|
_this.moveBottom = _this.moveBottom.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(PickListControls, [{
|
|
key: "moveUp",
|
|
value: function moveUp(event) {
|
|
var selectedItems = this.props.selection;
|
|
|
|
if (selectedItems && selectedItems.length) {
|
|
var list = _toConsumableArray(this.props.list);
|
|
|
|
for (var i = 0; i < selectedItems.length; i++) {
|
|
var selectedItem = selectedItems[i];
|
|
var selectedItemIndex = ObjectUtils.findIndexInList(selectedItem, list, this.props.dataKey);
|
|
|
|
if (selectedItemIndex !== 0) {
|
|
var movedItem = list[selectedItemIndex];
|
|
var temp = list[selectedItemIndex - 1];
|
|
list[selectedItemIndex - 1] = movedItem;
|
|
list[selectedItemIndex] = temp;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (this.props.onReorder) {
|
|
this.props.onReorder({
|
|
originalEvent: event,
|
|
value: list,
|
|
direction: 'up'
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "moveTop",
|
|
value: function moveTop(event) {
|
|
var selectedItems = this.props.selection;
|
|
|
|
if (selectedItems && selectedItems.length) {
|
|
var list = _toConsumableArray(this.props.list);
|
|
|
|
for (var i = 0; i < selectedItems.length; i++) {
|
|
var selectedItem = selectedItems[i];
|
|
var selectedItemIndex = ObjectUtils.findIndexInList(selectedItem, list, this.props.dataKey);
|
|
|
|
if (selectedItemIndex !== 0) {
|
|
var movedItem = list.splice(selectedItemIndex, 1)[0];
|
|
list.unshift(movedItem);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (this.props.onReorder) {
|
|
this.props.onReorder({
|
|
originalEvent: event,
|
|
value: list,
|
|
direction: 'top'
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "moveDown",
|
|
value: function moveDown(event) {
|
|
var selectedItems = this.props.selection;
|
|
|
|
if (selectedItems && selectedItems.length) {
|
|
var list = _toConsumableArray(this.props.list);
|
|
|
|
for (var i = selectedItems.length - 1; i >= 0; i--) {
|
|
var selectedItem = selectedItems[i];
|
|
var selectedItemIndex = ObjectUtils.findIndexInList(selectedItem, list, this.props.dataKey);
|
|
|
|
if (selectedItemIndex !== list.length - 1) {
|
|
var movedItem = list[selectedItemIndex];
|
|
var temp = list[selectedItemIndex + 1];
|
|
list[selectedItemIndex + 1] = movedItem;
|
|
list[selectedItemIndex] = temp;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (this.props.onReorder) {
|
|
this.props.onReorder({
|
|
originalEvent: event,
|
|
value: list,
|
|
direction: 'down'
|
|
});
|
|
}
|
|
|
|
this.movedDown = true;
|
|
}
|
|
}
|
|
}, {
|
|
key: "moveBottom",
|
|
value: function moveBottom(event) {
|
|
var selectedItems = this.props.selection;
|
|
|
|
if (selectedItems && selectedItems.length) {
|
|
var list = _toConsumableArray(this.props.list);
|
|
|
|
for (var i = selectedItems.length - 1; i >= 0; i--) {
|
|
var selectedItem = selectedItems[i];
|
|
var selectedItemIndex = ObjectUtils.findIndexInList(selectedItem, list, this.props.dataKey);
|
|
|
|
if (selectedItemIndex !== list.length - 1) {
|
|
var movedItem = list.splice(selectedItemIndex, 1)[0];
|
|
list.push(movedItem);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (this.props.onReorder) {
|
|
this.props.onReorder({
|
|
originalEvent: event,
|
|
value: list,
|
|
direction: 'bottom'
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var moveDisabled = !this.props.selection.length;
|
|
var className = classNames('p-picklist-buttons', this.props.className);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: className
|
|
}, /*#__PURE__*/React.createElement(Button, {
|
|
disabled: moveDisabled,
|
|
type: "button",
|
|
icon: "pi pi-angle-up",
|
|
onClick: this.moveUp
|
|
}), /*#__PURE__*/React.createElement(Button, {
|
|
disabled: moveDisabled,
|
|
type: "button",
|
|
icon: "pi pi-angle-double-up",
|
|
onClick: this.moveTop
|
|
}), /*#__PURE__*/React.createElement(Button, {
|
|
disabled: moveDisabled,
|
|
type: "button",
|
|
icon: "pi pi-angle-down",
|
|
onClick: this.moveDown
|
|
}), /*#__PURE__*/React.createElement(Button, {
|
|
disabled: moveDisabled,
|
|
type: "button",
|
|
icon: "pi pi-angle-double-down",
|
|
onClick: this.moveBottom
|
|
}));
|
|
}
|
|
}]);
|
|
|
|
return PickListControls;
|
|
}(Component);
|
|
|
|
function _createSuper$K(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$K(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$K() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var PickListTransferControls = /*#__PURE__*/function (_Component) {
|
|
_inherits(PickListTransferControls, _Component);
|
|
|
|
var _super = _createSuper$K(PickListTransferControls);
|
|
|
|
function PickListTransferControls(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, PickListTransferControls);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.moveRight = _this.moveRight.bind(_assertThisInitialized(_this));
|
|
_this.moveAllRight = _this.moveAllRight.bind(_assertThisInitialized(_this));
|
|
_this.moveLeft = _this.moveLeft.bind(_assertThisInitialized(_this));
|
|
_this.moveAllLeft = _this.moveAllLeft.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(PickListTransferControls, [{
|
|
key: "moveRight",
|
|
value: function moveRight(event) {
|
|
var selection = this.props.sourceSelection;
|
|
|
|
if (ObjectUtils.isNotEmpty(selection)) {
|
|
var targetList = _toConsumableArray(this.props.target);
|
|
|
|
var sourceList = _toConsumableArray(this.props.source);
|
|
|
|
for (var i = 0; i < selection.length; i++) {
|
|
var selectedItem = selection[i];
|
|
|
|
if (ObjectUtils.findIndexInList(selectedItem, targetList, this.props.dataKey) === -1) {
|
|
targetList.push(sourceList.splice(ObjectUtils.findIndexInList(selectedItem, sourceList, this.props.dataKey), 1)[0]);
|
|
}
|
|
}
|
|
|
|
if (this.props.onTransfer) {
|
|
this.props.onTransfer({
|
|
originalEvent: event,
|
|
source: sourceList,
|
|
target: targetList,
|
|
direction: 'toTarget'
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "moveAllRight",
|
|
value: function moveAllRight(event) {
|
|
if (this.props.source) {
|
|
var targetList = [].concat(_toConsumableArray(this.props.target), _toConsumableArray(this.props.source));
|
|
var sourceList = [];
|
|
|
|
if (this.props.onTransfer) {
|
|
this.props.onTransfer({
|
|
originalEvent: event,
|
|
source: sourceList,
|
|
target: targetList,
|
|
direction: 'allToTarget'
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "moveLeft",
|
|
value: function moveLeft(event) {
|
|
var selection = this.props.targetSelection;
|
|
|
|
if (ObjectUtils.isNotEmpty(selection)) {
|
|
var targetList = _toConsumableArray(this.props.target);
|
|
|
|
var sourceList = _toConsumableArray(this.props.source);
|
|
|
|
for (var i = 0; i < selection.length; i++) {
|
|
var selectedItem = selection[i];
|
|
|
|
if (ObjectUtils.findIndexInList(selectedItem, sourceList, this.props.dataKey) === -1) {
|
|
sourceList.push(targetList.splice(ObjectUtils.findIndexInList(selectedItem, targetList, this.props.dataKey), 1)[0]);
|
|
}
|
|
}
|
|
|
|
if (this.props.onTransfer) {
|
|
this.props.onTransfer({
|
|
originalEvent: event,
|
|
source: sourceList,
|
|
target: targetList,
|
|
direction: 'toSource'
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "moveAllLeft",
|
|
value: function moveAllLeft(event) {
|
|
if (this.props.source) {
|
|
var sourceList = [].concat(_toConsumableArray(this.props.source), _toConsumableArray(this.props.target));
|
|
var targetList = [];
|
|
|
|
if (this.props.onTransfer) {
|
|
this.props.onTransfer({
|
|
originalEvent: event,
|
|
source: sourceList,
|
|
target: targetList,
|
|
direction: 'allToSource'
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var moveRightDisabled = ObjectUtils.isEmpty(this.props.sourceSelection);
|
|
var moveLeftDisabled = ObjectUtils.isEmpty(this.props.targetSelection);
|
|
var moveAllRightDisabled = ObjectUtils.isEmpty(this.props.source);
|
|
var moveAllLeftDisabled = ObjectUtils.isEmpty(this.props.target);
|
|
var className = classNames('p-picklist-buttons p-picklist-transfer-buttons', this.props.className);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: className
|
|
}, /*#__PURE__*/React.createElement(Button, {
|
|
disabled: moveRightDisabled,
|
|
type: "button",
|
|
icon: "pi pi-angle-right",
|
|
onClick: this.moveRight
|
|
}), /*#__PURE__*/React.createElement(Button, {
|
|
disabled: moveAllRightDisabled,
|
|
type: "button",
|
|
icon: "pi pi-angle-double-right",
|
|
onClick: this.moveAllRight
|
|
}), /*#__PURE__*/React.createElement(Button, {
|
|
disabled: moveLeftDisabled,
|
|
type: "button",
|
|
icon: "pi pi-angle-left",
|
|
onClick: this.moveLeft
|
|
}), /*#__PURE__*/React.createElement(Button, {
|
|
disabled: moveAllLeftDisabled,
|
|
type: "button",
|
|
icon: "pi pi-angle-double-left",
|
|
onClick: this.moveAllLeft
|
|
}));
|
|
}
|
|
}]);
|
|
|
|
return PickListTransferControls;
|
|
}(Component);
|
|
|
|
function _createSuper$J(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$J(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$J() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var PickList = /*#__PURE__*/function (_Component) {
|
|
_inherits(PickList, _Component);
|
|
|
|
var _super = _createSuper$J(PickList);
|
|
|
|
function PickList(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, PickList);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {};
|
|
|
|
if (!_this.props.onSourceSelectionChange) {
|
|
_this.state.sourceSelection = [];
|
|
}
|
|
|
|
if (!_this.props.onTargetSelectionChange) {
|
|
_this.state.targetSelection = [];
|
|
}
|
|
|
|
_this.onSourceReorder = _this.onSourceReorder.bind(_assertThisInitialized(_this));
|
|
_this.onTargetReorder = _this.onTargetReorder.bind(_assertThisInitialized(_this));
|
|
_this.onTransfer = _this.onTransfer.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(PickList, [{
|
|
key: "getSourceSelection",
|
|
value: function getSourceSelection() {
|
|
return this.props.onSourceSelectionChange ? this.props.sourceSelection : this.state.sourceSelection;
|
|
}
|
|
}, {
|
|
key: "getTargetSelection",
|
|
value: function getTargetSelection() {
|
|
return this.props.onTargetSelectionChange ? this.props.targetSelection : this.state.targetSelection;
|
|
}
|
|
}, {
|
|
key: "onSourceReorder",
|
|
value: function onSourceReorder(event) {
|
|
this.handleChange(event, event.value, this.props.target);
|
|
this.reorderedListElement = this.sourceListElement;
|
|
this.reorderDirection = event.direction;
|
|
}
|
|
}, {
|
|
key: "onTargetReorder",
|
|
value: function onTargetReorder(event) {
|
|
this.handleChange(event, this.props.source, event.value);
|
|
this.reorderedListElement = this.targetListElement;
|
|
this.reorderDirection = event.direction;
|
|
}
|
|
}, {
|
|
key: "handleScrollPosition",
|
|
value: function handleScrollPosition(listElement, direction) {
|
|
if (listElement) {
|
|
var listContainer = DomHandler.findSingle(listElement, '.p-picklist-list');
|
|
|
|
switch (direction) {
|
|
case 'up':
|
|
this.scrollInView(listContainer, -1);
|
|
break;
|
|
|
|
case 'top':
|
|
listContainer.scrollTop = 0;
|
|
break;
|
|
|
|
case 'down':
|
|
this.scrollInView(listContainer, 1);
|
|
break;
|
|
|
|
case 'bottom':
|
|
listContainer.scrollTop = listContainer.scrollHeight;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "handleChange",
|
|
value: function handleChange(event, source, target) {
|
|
if (this.props.onChange) {
|
|
this.props.onChange({
|
|
originalEvent: event.originalEvent,
|
|
source: source,
|
|
target: target
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onTransfer",
|
|
value: function onTransfer(event) {
|
|
var originalEvent = event.originalEvent,
|
|
source = event.source,
|
|
target = event.target,
|
|
direction = event.direction;
|
|
|
|
switch (direction) {
|
|
case 'toTarget':
|
|
if (this.props.onMoveToTarget) {
|
|
this.props.onMoveToTarget({
|
|
originalEvent: originalEvent,
|
|
value: this.getSourceSelection()
|
|
});
|
|
}
|
|
|
|
break;
|
|
|
|
case 'allToTarget':
|
|
if (this.props.onMoveAllToTarget) {
|
|
this.props.onMoveAllToTarget({
|
|
originalEvent: originalEvent,
|
|
value: this.props.source
|
|
});
|
|
}
|
|
|
|
break;
|
|
|
|
case 'toSource':
|
|
if (this.props.onMoveToSource) {
|
|
this.props.onMoveToSource({
|
|
originalEvent: originalEvent,
|
|
value: this.getTargetSelection()
|
|
});
|
|
}
|
|
|
|
break;
|
|
|
|
case 'allToSource':
|
|
if (this.props.onMoveAllToSource) {
|
|
this.props.onMoveAllToSource({
|
|
originalEvent: originalEvent,
|
|
value: this.props.target
|
|
});
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
this.onSelectionChange({
|
|
originalEvent: originalEvent,
|
|
value: []
|
|
}, 'sourceSelection', this.props.onSourceSelectionChange);
|
|
this.onSelectionChange({
|
|
originalEvent: originalEvent,
|
|
value: []
|
|
}, 'targetSelection', this.props.onTargetSelectionChange);
|
|
this.handleChange(event, source, target);
|
|
}
|
|
}, {
|
|
key: "scrollInView",
|
|
value: function scrollInView(listContainer) {
|
|
var direction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
|
|
var selectedItems = listContainer.getElementsByClassName('p-highlight');
|
|
|
|
if (ObjectUtils.isNotEmpty(selectedItems)) {
|
|
DomHandler.scrollInView(listContainer, direction === -1 ? selectedItems[0] : selectedItems[selectedItems.length - 1]);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onSelectionChange",
|
|
value: function onSelectionChange(e, stateKey, callback) {
|
|
if (callback) {
|
|
callback(e);
|
|
} else {
|
|
this.setState(_defineProperty({}, stateKey, e.value));
|
|
}
|
|
|
|
if (ObjectUtils.isNotEmpty(this.state.sourceSelection) && stateKey === 'targetSelection') {
|
|
this.setState({
|
|
sourceSelection: []
|
|
});
|
|
} else if (ObjectUtils.isNotEmpty(this.state.targetSelection) && stateKey === 'sourceSelection') {
|
|
this.setState({
|
|
targetSelection: []
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate() {
|
|
if (this.reorderedListElement) {
|
|
this.handleScrollPosition(this.reorderedListElement, this.reorderDirection);
|
|
this.reorderedListElement = null;
|
|
this.reorderDirection = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this2 = this;
|
|
|
|
var className = classNames('p-picklist p-component', this.props.className);
|
|
var sourceSelection = this.getSourceSelection();
|
|
var targetSelection = this.getTargetSelection();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, this.props.showSourceControls && /*#__PURE__*/React.createElement(PickListControls, {
|
|
list: this.props.source,
|
|
selection: sourceSelection,
|
|
onReorder: this.onSourceReorder,
|
|
className: "p-picklist-source-controls",
|
|
dataKey: this.props.dataKey
|
|
}), /*#__PURE__*/React.createElement(PickListSubList, {
|
|
ref: function ref(el) {
|
|
return _this2.sourceListElement = el;
|
|
},
|
|
list: this.props.source,
|
|
selection: sourceSelection,
|
|
onSelectionChange: function onSelectionChange(e) {
|
|
return _this2.onSelectionChange(e, 'sourceSelection', _this2.props.onSourceSelectionChange);
|
|
},
|
|
itemTemplate: this.props.itemTemplate,
|
|
header: this.props.sourceHeader,
|
|
style: this.props.sourceStyle,
|
|
className: "p-picklist-source-wrapper",
|
|
listClassName: "p-picklist-source",
|
|
metaKeySelection: this.props.metaKeySelection,
|
|
tabIndex: this.props.tabIndex,
|
|
dataKey: this.props.dataKey
|
|
}), /*#__PURE__*/React.createElement(PickListTransferControls, {
|
|
onTransfer: this.onTransfer,
|
|
source: this.props.source,
|
|
target: this.props.target,
|
|
sourceSelection: sourceSelection,
|
|
targetSelection: targetSelection,
|
|
dataKey: this.props.dataKey
|
|
}), /*#__PURE__*/React.createElement(PickListSubList, {
|
|
ref: function ref(el) {
|
|
return _this2.targetListElement = el;
|
|
},
|
|
list: this.props.target,
|
|
selection: targetSelection,
|
|
onSelectionChange: function onSelectionChange(e) {
|
|
return _this2.onSelectionChange(e, 'targetSelection', _this2.props.onTargetSelectionChange);
|
|
},
|
|
itemTemplate: this.props.itemTemplate,
|
|
header: this.props.targetHeader,
|
|
style: this.props.targetStyle,
|
|
className: "p-picklist-target-wrapper",
|
|
listClassName: "p-picklist-target",
|
|
metaKeySelection: this.props.metaKeySelection,
|
|
tabIndex: this.props.tabIndex,
|
|
dataKey: this.props.dataKey
|
|
}), this.props.showTargetControls && /*#__PURE__*/React.createElement(PickListControls, {
|
|
list: this.props.target,
|
|
selection: targetSelection,
|
|
onReorder: this.onTargetReorder,
|
|
className: "p-picklist-target-controls",
|
|
dataKey: this.props.dataKey
|
|
}));
|
|
}
|
|
}]);
|
|
|
|
return PickList;
|
|
}(Component);
|
|
|
|
_defineProperty(PickList, "defaultProps", {
|
|
id: null,
|
|
source: null,
|
|
target: null,
|
|
sourceHeader: null,
|
|
targetHeader: null,
|
|
style: null,
|
|
className: null,
|
|
sourceStyle: null,
|
|
targetStyle: null,
|
|
sourceSelection: null,
|
|
targetSelection: null,
|
|
showSourceControls: true,
|
|
showTargetControls: true,
|
|
metaKeySelection: true,
|
|
tabIndex: 0,
|
|
dataKey: null,
|
|
itemTemplate: null,
|
|
onChange: null,
|
|
onMoveToSource: null,
|
|
onMoveAllToSource: null,
|
|
onMoveToTarget: null,
|
|
onMoveAllToTarget: null,
|
|
onSourceSelectionChange: null,
|
|
onTargetSelectionChange: null
|
|
});
|
|
|
|
function _createSuper$I(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$I(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$I() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var ProgressSpinner = /*#__PURE__*/function (_Component) {
|
|
_inherits(ProgressSpinner, _Component);
|
|
|
|
var _super = _createSuper$I(ProgressSpinner);
|
|
|
|
function ProgressSpinner() {
|
|
_classCallCheck(this, ProgressSpinner);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(ProgressSpinner, [{
|
|
key: "render",
|
|
value: function render() {
|
|
var spinnerClass = classNames('p-progress-spinner', this.props.className);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
style: this.props.style,
|
|
className: spinnerClass,
|
|
role: "alert",
|
|
"aria-busy": true
|
|
}, /*#__PURE__*/React.createElement("svg", {
|
|
className: "p-progress-spinner-svg",
|
|
viewBox: "25 25 50 50",
|
|
style: {
|
|
animationDuration: this.props.animationDuration
|
|
}
|
|
}, /*#__PURE__*/React.createElement("circle", {
|
|
className: "p-progress-spinner-circle",
|
|
cx: "50",
|
|
cy: "50",
|
|
r: "20",
|
|
fill: this.props.fill,
|
|
strokeWidth: this.props.strokeWidth,
|
|
strokeMiterlimit: "10"
|
|
})));
|
|
}
|
|
}]);
|
|
|
|
return ProgressSpinner;
|
|
}(Component);
|
|
|
|
_defineProperty(ProgressSpinner, "defaultProps", {
|
|
id: null,
|
|
style: null,
|
|
className: null,
|
|
strokeWidth: "2",
|
|
fill: "none",
|
|
animationDuration: "2s"
|
|
});
|
|
|
|
function ownKeys$f(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$f(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$f(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$f(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$H(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$H(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$H() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var RadioButton = /*#__PURE__*/function (_Component) {
|
|
_inherits(RadioButton, _Component);
|
|
|
|
var _super = _createSuper$H(RadioButton);
|
|
|
|
function RadioButton(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, RadioButton);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {};
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onFocus = _this.onFocus.bind(_assertThisInitialized(_this));
|
|
_this.onBlur = _this.onBlur.bind(_assertThisInitialized(_this));
|
|
_this.inputRef = /*#__PURE__*/createRef(_this.props.inputRef);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(RadioButton, [{
|
|
key: "select",
|
|
value: function select(e) {
|
|
this.inputRef.current.checked = true;
|
|
this.onClick(e);
|
|
}
|
|
}, {
|
|
key: "onClick",
|
|
value: function onClick(e) {
|
|
if (!this.props.disabled && this.props.onChange) {
|
|
this.props.onChange({
|
|
originalEvent: e,
|
|
value: this.props.value,
|
|
checked: !this.props.checked,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: this.props.value,
|
|
checked: !this.props.checked
|
|
}
|
|
});
|
|
this.inputRef.current.checked = !this.props.checked;
|
|
this.inputRef.current.focus();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onFocus",
|
|
value: function onFocus() {
|
|
this.setState({
|
|
focused: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "onBlur",
|
|
value: function onBlur() {
|
|
this.setState({
|
|
focused: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "updateInputRef",
|
|
value: function updateInputRef() {
|
|
var ref = this.props.inputRef;
|
|
|
|
if (ref) {
|
|
if (typeof ref === 'function') {
|
|
ref(this.inputRef.current);
|
|
} else {
|
|
ref.current = this.inputRef.current;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.updateInputRef();
|
|
|
|
if (this.props.tooltip) {
|
|
this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$f({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.element,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this2 = this;
|
|
|
|
if (this.inputRef && this.inputRef.current) {
|
|
this.inputRef.current.checked = this.props.checked;
|
|
}
|
|
|
|
var containerClass = classNames('p-radiobutton p-component', {
|
|
'p-radiobutton-checked': this.props.checked,
|
|
'p-radiobutton-disabled': this.props.disabled,
|
|
'p-radiobutton-focused': this.state.focused
|
|
}, this.props.className);
|
|
var boxClass = classNames('p-radiobutton-box', {
|
|
'p-highlight': this.props.checked,
|
|
'p-disabled': this.props.disabled,
|
|
'p-focus': this.state.focused
|
|
});
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this2.element = el;
|
|
},
|
|
id: this.props.id,
|
|
className: containerClass,
|
|
style: this.props.style,
|
|
onClick: this.onClick
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-hidden-accessible"
|
|
}, /*#__PURE__*/React.createElement("input", {
|
|
ref: this.inputRef,
|
|
id: this.props.inputId,
|
|
type: "radio",
|
|
"aria-labelledby": this.props.ariaLabelledBy,
|
|
name: this.props.name,
|
|
defaultChecked: this.props.checked,
|
|
onFocus: this.onFocus,
|
|
onBlur: this.onBlur,
|
|
disabled: this.props.disabled,
|
|
required: this.props.required,
|
|
tabIndex: this.props.tabIndex
|
|
})), /*#__PURE__*/React.createElement("div", {
|
|
className: boxClass,
|
|
ref: function ref(el) {
|
|
_this2.box = el;
|
|
},
|
|
role: "radio",
|
|
"aria-checked": this.props.checked
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-radiobutton-icon"
|
|
})));
|
|
}
|
|
}]);
|
|
|
|
return RadioButton;
|
|
}(Component);
|
|
|
|
_defineProperty(RadioButton, "defaultProps", {
|
|
id: null,
|
|
inputRef: null,
|
|
inputId: null,
|
|
name: null,
|
|
value: null,
|
|
checked: false,
|
|
style: null,
|
|
className: null,
|
|
disabled: false,
|
|
required: false,
|
|
tabIndex: null,
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
ariaLabelledBy: null,
|
|
onChange: null
|
|
});
|
|
|
|
function ownKeys$e(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$e(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$e(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$e(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$G(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$G(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$G() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Rating = /*#__PURE__*/function (_Component) {
|
|
_inherits(Rating, _Component);
|
|
|
|
var _super = _createSuper$G(Rating);
|
|
|
|
function Rating(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Rating);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.clear = _this.clear.bind(_assertThisInitialized(_this));
|
|
_this.onStarKeyDown = _this.onStarKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onCancelKeyDown = _this.onCancelKeyDown.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Rating, [{
|
|
key: "rate",
|
|
value: function rate(event, i) {
|
|
if (!this.props.readOnly && !this.props.disabled && this.props.onChange) {
|
|
this.props.onChange({
|
|
originalEvent: event,
|
|
value: i,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: i
|
|
}
|
|
});
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "clear",
|
|
value: function clear(event) {
|
|
if (!this.props.readOnly && !this.props.disabled && this.props.onChange) {
|
|
this.props.onChange({
|
|
originalEvent: event,
|
|
value: null,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: null
|
|
}
|
|
});
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "shouldComponentUpdate",
|
|
value: function shouldComponentUpdate(nextProps, nextState) {
|
|
if (nextProps.value === this.props.value && nextProps.disabled === this.props.disabled) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}, {
|
|
key: "onStarKeyDown",
|
|
value: function onStarKeyDown(event, value) {
|
|
if (event.key === 'Enter') {
|
|
this.rate(event, value);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onCancelKeyDown",
|
|
value: function onCancelKeyDown(event) {
|
|
if (event.key === 'Enter') {
|
|
this.clear(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "getFocusIndex",
|
|
value: function getFocusIndex() {
|
|
return this.props.disabled || this.props.readOnly ? null : 0;
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (this.props.tooltip) {
|
|
this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$e({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.element,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderStars",
|
|
value: function renderStars() {
|
|
var _this2 = this;
|
|
|
|
var starsArray = [];
|
|
|
|
for (var i = 0; i < this.props.stars; i++) {
|
|
starsArray[i] = i + 1;
|
|
}
|
|
|
|
var stars = starsArray.map(function (value) {
|
|
var iconClass = classNames('p-rating-icon', {
|
|
'pi pi-star': !_this2.props.value || value > _this2.props.value,
|
|
'pi pi-star-fill': value <= _this2.props.value
|
|
});
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: iconClass,
|
|
onClick: function onClick(e) {
|
|
return _this2.rate(e, value);
|
|
},
|
|
key: value,
|
|
tabIndex: _this2.getFocusIndex(),
|
|
onKeyDown: function onKeyDown(e) {
|
|
return _this2.onStarKeyDown(e, value);
|
|
}
|
|
});
|
|
});
|
|
return stars;
|
|
}
|
|
}, {
|
|
key: "renderCancelIcon",
|
|
value: function renderCancelIcon() {
|
|
if (this.props.cancel) {
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: "p-rating-icon p-rating-cancel pi pi-ban",
|
|
onClick: this.clear,
|
|
tabIndex: this.getFocusIndex(),
|
|
onKeyDown: this.onCancelKeyDown
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this3 = this;
|
|
|
|
var className = classNames('p-rating', {
|
|
'p-disabled': this.props.disabled,
|
|
'p-rating-readonly': this.props.readOnly
|
|
}, this.props.className);
|
|
var cancelIcon = this.renderCancelIcon();
|
|
var stars = this.renderStars();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this3.element = el;
|
|
},
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, cancelIcon, stars);
|
|
}
|
|
}]);
|
|
|
|
return Rating;
|
|
}(Component);
|
|
|
|
_defineProperty(Rating, "defaultProps", {
|
|
id: null,
|
|
value: null,
|
|
disabled: false,
|
|
readOnly: false,
|
|
stars: 5,
|
|
cancel: true,
|
|
style: null,
|
|
className: null,
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
onChange: null
|
|
});
|
|
|
|
function _createSuper$F(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$F(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$F() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Row = /*#__PURE__*/function (_Component) {
|
|
_inherits(Row, _Component);
|
|
|
|
var _super = _createSuper$F(Row);
|
|
|
|
function Row() {
|
|
_classCallCheck(this, Row);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(Row, [{
|
|
key: "render",
|
|
value: function render() {
|
|
return /*#__PURE__*/React.createElement("tr", null, this.props.children);
|
|
}
|
|
}]);
|
|
|
|
return Row;
|
|
}(Component);
|
|
|
|
_defineProperty(Row, "defaultProps", {
|
|
style: null,
|
|
className: null
|
|
});
|
|
|
|
function _createSuper$E(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$E(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$E() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var ScrollPanel = /*#__PURE__*/function (_Component) {
|
|
_inherits(ScrollPanel, _Component);
|
|
|
|
var _super = _createSuper$E(ScrollPanel);
|
|
|
|
function ScrollPanel(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, ScrollPanel);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.moveBar = _this.moveBar.bind(_assertThisInitialized(_this));
|
|
_this.onXBarMouseDown = _this.onXBarMouseDown.bind(_assertThisInitialized(_this));
|
|
_this.onYBarMouseDown = _this.onYBarMouseDown.bind(_assertThisInitialized(_this));
|
|
_this.onDocumentMouseMove = _this.onDocumentMouseMove.bind(_assertThisInitialized(_this));
|
|
_this.onDocumentMouseUp = _this.onDocumentMouseUp.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(ScrollPanel, [{
|
|
key: "calculateContainerHeight",
|
|
value: function calculateContainerHeight() {
|
|
var containerStyles = getComputedStyle(this.container),
|
|
xBarStyles = getComputedStyle(this.xBar),
|
|
pureContainerHeight = DomHandler.getHeight(this.container) - parseInt(xBarStyles['height'], 10);
|
|
|
|
if (containerStyles['max-height'] !== "none" && pureContainerHeight === 0) {
|
|
if (this.content.offsetHeight + parseInt(xBarStyles['height'], 10) > parseInt(containerStyles['max-height'], 10)) {
|
|
this.container.style.height = containerStyles['max-height'];
|
|
} else {
|
|
this.container.style.height = this.content.offsetHeight + parseFloat(containerStyles.paddingTop) + parseFloat(containerStyles.paddingBottom) + parseFloat(containerStyles.borderTopWidth) + parseFloat(containerStyles.borderBottomWidth) + "px";
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "moveBar",
|
|
value: function moveBar() {
|
|
var _this2 = this;
|
|
|
|
/* horizontal scroll */
|
|
var totalWidth = this.content.scrollWidth;
|
|
var ownWidth = this.content.clientWidth;
|
|
var bottom = (this.container.clientHeight - this.xBar.clientHeight) * -1;
|
|
this.scrollXRatio = ownWidth / totalWidth;
|
|
/* vertical scroll */
|
|
|
|
var totalHeight = this.content.scrollHeight;
|
|
var ownHeight = this.content.clientHeight;
|
|
var right = (this.container.clientWidth - this.yBar.clientWidth) * -1;
|
|
this.scrollYRatio = ownHeight / totalHeight;
|
|
this.frame = this.requestAnimationFrame(function () {
|
|
if (_this2.scrollXRatio >= 1) {
|
|
DomHandler.addClass(_this2.xBar, 'p-scrollpanel-hidden');
|
|
} else {
|
|
DomHandler.removeClass(_this2.xBar, 'p-scrollpanel-hidden');
|
|
_this2.xBar.style.cssText = 'width:' + Math.max(_this2.scrollXRatio * 100, 10) + '%; left:' + _this2.content.scrollLeft / totalWidth * 100 + '%;bottom:' + bottom + 'px;';
|
|
}
|
|
|
|
if (_this2.scrollYRatio >= 1) {
|
|
DomHandler.addClass(_this2.yBar, 'p-scrollpanel-hidden');
|
|
} else {
|
|
DomHandler.removeClass(_this2.yBar, 'p-scrollpanel-hidden');
|
|
_this2.yBar.style.cssText = 'height:' + Math.max(_this2.scrollYRatio * 100, 10) + '%; top: calc(' + _this2.content.scrollTop / totalHeight * 100 + '% - ' + _this2.xBar.clientHeight + 'px);right:' + right + 'px;';
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onYBarMouseDown",
|
|
value: function onYBarMouseDown(e) {
|
|
this.isYBarClicked = true;
|
|
this.lastPageY = e.pageY;
|
|
DomHandler.addClass(this.yBar, 'p-scrollpanel-grabbed');
|
|
DomHandler.addClass(document.body, 'p-scrollpanel-grabbed');
|
|
document.addEventListener('mousemove', this.onDocumentMouseMove);
|
|
document.addEventListener('mouseup', this.onDocumentMouseUp);
|
|
e.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onXBarMouseDown",
|
|
value: function onXBarMouseDown(e) {
|
|
this.isXBarClicked = true;
|
|
this.lastPageX = e.pageX;
|
|
DomHandler.addClass(this.xBar, 'p-scrollpanel-grabbed');
|
|
DomHandler.addClass(document.body, 'p-scrollpanel-grabbed');
|
|
document.addEventListener('mousemove', this.onDocumentMouseMove);
|
|
document.addEventListener('mouseup', this.onDocumentMouseUp);
|
|
e.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onDocumentMouseMove",
|
|
value: function onDocumentMouseMove(e) {
|
|
if (this.isXBarClicked) {
|
|
this.onMouseMoveForXBar(e);
|
|
} else if (this.isYBarClicked) {
|
|
this.onMouseMoveForYBar(e);
|
|
} else {
|
|
this.onMouseMoveForXBar(e);
|
|
this.onMouseMoveForYBar(e);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onMouseMoveForXBar",
|
|
value: function onMouseMoveForXBar(e) {
|
|
var _this3 = this;
|
|
|
|
var deltaX = e.pageX - this.lastPageX;
|
|
this.lastPageX = e.pageX;
|
|
this.frame = this.requestAnimationFrame(function () {
|
|
_this3.content.scrollLeft += deltaX / _this3.scrollXRatio;
|
|
});
|
|
}
|
|
}, {
|
|
key: "onMouseMoveForYBar",
|
|
value: function onMouseMoveForYBar(e) {
|
|
var _this4 = this;
|
|
|
|
var deltaY = e.pageY - this.lastPageY;
|
|
this.lastPageY = e.pageY;
|
|
this.frame = this.requestAnimationFrame(function () {
|
|
_this4.content.scrollTop += deltaY / _this4.scrollYRatio;
|
|
});
|
|
}
|
|
}, {
|
|
key: "onDocumentMouseUp",
|
|
value: function onDocumentMouseUp(e) {
|
|
DomHandler.removeClass(this.yBar, 'p-scrollpanel-grabbed');
|
|
DomHandler.removeClass(this.xBar, 'p-scrollpanel-grabbed');
|
|
DomHandler.removeClass(document.body, 'p-scrollpanel-grabbed');
|
|
document.removeEventListener('mousemove', this.onDocumentMouseMove);
|
|
document.removeEventListener('mouseup', this.onDocumentMouseUp);
|
|
this.isXBarClicked = false;
|
|
this.isYBarClicked = false;
|
|
}
|
|
}, {
|
|
key: "requestAnimationFrame",
|
|
value: function requestAnimationFrame(f) {
|
|
var frame = window.requestAnimationFrame || this.timeoutFrame;
|
|
return frame(f);
|
|
}
|
|
}, {
|
|
key: "refresh",
|
|
value: function refresh() {
|
|
this.moveBar();
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.moveBar();
|
|
this.moveBar = this.moveBar.bind(this);
|
|
window.addEventListener('resize', this.moveBar);
|
|
this.calculateContainerHeight();
|
|
this.initialized = true;
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.initialized) {
|
|
window.removeEventListener('resize', this.moveBar);
|
|
}
|
|
|
|
if (this.frame) {
|
|
window.cancelAnimationFrame(this.frame);
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this5 = this;
|
|
|
|
var className = classNames('p-scrollpanel p-component', this.props.className);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this5.container = el;
|
|
},
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-scrollpanel-wrapper"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this5.content = el;
|
|
},
|
|
className: "p-scrollpanel-content",
|
|
onScroll: this.moveBar,
|
|
onMouseEnter: this.moveBar
|
|
}, this.props.children)), /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this5.xBar = el;
|
|
},
|
|
className: "p-scrollpanel-bar p-scrollpanel-bar-x",
|
|
onMouseDown: this.onXBarMouseDown
|
|
}), /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this5.yBar = el;
|
|
},
|
|
className: "p-scrollpanel-bar p-scrollpanel-bar-y",
|
|
onMouseDown: this.onYBarMouseDown
|
|
}));
|
|
}
|
|
}]);
|
|
|
|
return ScrollPanel;
|
|
}(Component);
|
|
|
|
_defineProperty(ScrollPanel, "defaultProps", {
|
|
id: null,
|
|
style: null,
|
|
className: null
|
|
});
|
|
|
|
function _createSuper$D(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$D(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$D() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var ScrollTop = /*#__PURE__*/function (_Component) {
|
|
_inherits(ScrollTop, _Component);
|
|
|
|
var _super = _createSuper$D(ScrollTop);
|
|
|
|
function ScrollTop(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, ScrollTop);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
visible: false
|
|
};
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onEnter = _this.onEnter.bind(_assertThisInitialized(_this));
|
|
_this.onEntered = _this.onEntered.bind(_assertThisInitialized(_this));
|
|
_this.onExited = _this.onExited.bind(_assertThisInitialized(_this));
|
|
_this.scrollElementRef = /*#__PURE__*/React.createRef();
|
|
return _this;
|
|
}
|
|
|
|
_createClass(ScrollTop, [{
|
|
key: "onClick",
|
|
value: function onClick() {
|
|
var scrollElement = this.props.target === 'window' ? window : this.helper.parentElement;
|
|
scrollElement.scroll({
|
|
top: 0,
|
|
behavior: this.props.behavior
|
|
});
|
|
}
|
|
}, {
|
|
key: "checkVisibility",
|
|
value: function checkVisibility(scrollY) {
|
|
this.setState({
|
|
visible: scrollY > this.props.threshold
|
|
});
|
|
}
|
|
}, {
|
|
key: "bindParentScrollListener",
|
|
value: function bindParentScrollListener() {
|
|
var _this2 = this;
|
|
|
|
this.scrollListener = function () {
|
|
_this2.checkVisibility(_this2.helper.parentElement.scrollTop);
|
|
};
|
|
|
|
this.helper.parentElement.addEventListener('scroll', this.scrollListener);
|
|
}
|
|
}, {
|
|
key: "bindDocumentScrollListener",
|
|
value: function bindDocumentScrollListener() {
|
|
var _this3 = this;
|
|
|
|
this.scrollListener = function () {
|
|
_this3.checkVisibility(DomHandler.getWindowScrollTop());
|
|
};
|
|
|
|
window.addEventListener('scroll', this.scrollListener);
|
|
}
|
|
}, {
|
|
key: "unbindParentScrollListener",
|
|
value: function unbindParentScrollListener() {
|
|
if (this.scrollListener) {
|
|
this.helper.parentElement.removeEventListener('scroll', this.scrollListener);
|
|
this.scrollListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentScrollListener",
|
|
value: function unbindDocumentScrollListener() {
|
|
if (this.scrollListener) {
|
|
window.removeEventListener('scroll', this.scrollListener);
|
|
this.scrollListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "onEnter",
|
|
value: function onEnter() {
|
|
ZIndexUtils.set('overlay', this.scrollElementRef.current, PrimeReact.autoZIndex, PrimeReact.zIndex['overlay']);
|
|
}
|
|
}, {
|
|
key: "onEntered",
|
|
value: function onEntered() {
|
|
this.props.onShow && this.props.onShow();
|
|
}
|
|
}, {
|
|
key: "onExited",
|
|
value: function onExited() {
|
|
ZIndexUtils.clear(this.scrollElementRef.current);
|
|
this.props.onHide && this.props.onHide();
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (this.props.target === 'window') this.bindDocumentScrollListener();else if (this.props.target === 'parent') this.bindParentScrollListener();
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.props.target === 'window') this.unbindDocumentScrollListener();else if (this.props.target === 'parent') this.unbindParentScrollListener();
|
|
ZIndexUtils.clear(this.scrollElementRef.current);
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this4 = this;
|
|
|
|
var className = classNames('p-scrolltop p-link p-component', {
|
|
'p-scrolltop-sticky': this.props.target !== 'window'
|
|
}, this.props.className);
|
|
var isTargetParent = this.props.target === 'parent';
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.scrollElementRef,
|
|
classNames: "p-scrolltop",
|
|
"in": this.state.visible,
|
|
timeout: {
|
|
enter: 150,
|
|
exit: 150
|
|
},
|
|
options: this.props.transitionOptions,
|
|
unmountOnExit: true,
|
|
onEnter: this.onEnter,
|
|
onEntered: this.onEntered,
|
|
onExited: this.onExited
|
|
}, /*#__PURE__*/React.createElement("button", {
|
|
ref: this.scrollElementRef,
|
|
type: "button",
|
|
className: className,
|
|
style: this.props.style,
|
|
onClick: this.onClick
|
|
}, IconUtils.getJSXIcon(this.props.icon, {
|
|
className: 'p-scrolltop-icon'
|
|
}, {
|
|
props: this.props
|
|
}), /*#__PURE__*/React.createElement(Ripple, null))), isTargetParent && /*#__PURE__*/React.createElement("span", {
|
|
ref: function ref(el) {
|
|
return _this4.helper = el;
|
|
},
|
|
className: "p-scrolltop-helper"
|
|
}));
|
|
}
|
|
}]);
|
|
|
|
return ScrollTop;
|
|
}(Component);
|
|
|
|
_defineProperty(ScrollTop, "defaultProps", {
|
|
target: 'window',
|
|
threshold: 400,
|
|
icon: 'pi pi-chevron-up',
|
|
behavior: 'smooth',
|
|
className: null,
|
|
style: null,
|
|
transitionOptions: null,
|
|
onShow: null,
|
|
onHide: null
|
|
});
|
|
|
|
function _createSuper$C(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$C(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$C() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var SelectButtonItem = /*#__PURE__*/function (_Component) {
|
|
_inherits(SelectButtonItem, _Component);
|
|
|
|
var _super = _createSuper$C(SelectButtonItem);
|
|
|
|
function SelectButtonItem(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, SelectButtonItem);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
focused: false
|
|
};
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onFocus = _this.onFocus.bind(_assertThisInitialized(_this));
|
|
_this.onBlur = _this.onBlur.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(SelectButtonItem, [{
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
if (this.props.onClick) {
|
|
this.props.onClick({
|
|
originalEvent: event,
|
|
option: this.props.option
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onFocus",
|
|
value: function onFocus() {
|
|
this.setState({
|
|
focused: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "onBlur",
|
|
value: function onBlur() {
|
|
this.setState({
|
|
focused: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event) {
|
|
var keyCode = event.which;
|
|
|
|
if (keyCode === 32 || keyCode === 13) {
|
|
//space and enter
|
|
this.onClick(event);
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
if (this.props.template) {
|
|
return this.props.template(this.props.option);
|
|
} else {
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: "p-button-label p-c"
|
|
}, this.props.label);
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-button p-component', {
|
|
'p-highlight': this.props.selected,
|
|
'p-disabled': this.props.disabled,
|
|
'p-focus': this.state.focused
|
|
}, this.props.className);
|
|
var content = this.renderContent();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: className,
|
|
role: "button",
|
|
"aria-label": this.props.label,
|
|
"aria-pressed": this.props.selected,
|
|
"aria-labelledby": this.props.ariaLabelledBy,
|
|
onClick: this.onClick,
|
|
onKeyDown: this.onKeyDown,
|
|
tabIndex: this.props.tabIndex,
|
|
onFocus: this.onFocus,
|
|
onBlur: this.onBlur
|
|
}, content, !this.props.disabled && /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
}]);
|
|
|
|
return SelectButtonItem;
|
|
}(Component);
|
|
|
|
_defineProperty(SelectButtonItem, "defaultProps", {
|
|
option: null,
|
|
label: null,
|
|
className: null,
|
|
selected: null,
|
|
tabIndex: null,
|
|
ariaLabelledBy: null,
|
|
template: null,
|
|
onClick: null
|
|
});
|
|
|
|
function ownKeys$d(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$d(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$d(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$d(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createForOfIteratorHelper$7(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$7(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$7(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$7(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$7(o, minLen); }
|
|
|
|
function _arrayLikeToArray$7(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 _createSuper$B(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$B(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$B() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var SelectButton = /*#__PURE__*/function (_Component) {
|
|
_inherits(SelectButton, _Component);
|
|
|
|
var _super = _createSuper$B(SelectButton);
|
|
|
|
function SelectButton(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, SelectButton);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onOptionClick = _this.onOptionClick.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(SelectButton, [{
|
|
key: "onOptionClick",
|
|
value: function onOptionClick(event) {
|
|
var _this2 = this;
|
|
|
|
if (this.props.disabled || this.isOptionDisabled(event.option)) {
|
|
return;
|
|
}
|
|
|
|
var selected = this.isSelected(event.option);
|
|
|
|
if (selected && !this.props.unselectable) {
|
|
return;
|
|
}
|
|
|
|
var optionValue = this.getOptionValue(event.option);
|
|
var newValue;
|
|
|
|
if (this.props.multiple) {
|
|
var currentValue = this.props.value ? _toConsumableArray(this.props.value) : [];
|
|
if (selected) newValue = currentValue.filter(function (val) {
|
|
return !ObjectUtils.equals(val, optionValue, _this2.props.dataKey);
|
|
});else newValue = [].concat(_toConsumableArray(currentValue), [optionValue]);
|
|
} else {
|
|
if (selected) newValue = null;else newValue = optionValue;
|
|
}
|
|
|
|
if (this.props.onChange) {
|
|
this.props.onChange({
|
|
originalEvent: event.originalEvent,
|
|
value: newValue,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: newValue
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "getOptionLabel",
|
|
value: function getOptionLabel(option) {
|
|
return this.props.optionLabel ? ObjectUtils.resolveFieldData(option, this.props.optionLabel) : option && option['label'] !== undefined ? option['label'] : option;
|
|
}
|
|
}, {
|
|
key: "getOptionValue",
|
|
value: function getOptionValue(option) {
|
|
return this.props.optionValue ? ObjectUtils.resolveFieldData(option, this.props.optionValue) : option && option['value'] !== undefined ? option['value'] : option;
|
|
}
|
|
}, {
|
|
key: "isOptionDisabled",
|
|
value: function isOptionDisabled(option) {
|
|
if (this.props.optionDisabled) {
|
|
return ObjectUtils.isFunction(this.props.optionDisabled) ? this.props.optionDisabled(option) : ObjectUtils.resolveFieldData(option, this.props.optionDisabled);
|
|
}
|
|
|
|
return option && option['disabled'] !== undefined ? option['disabled'] : false;
|
|
}
|
|
}, {
|
|
key: "isSelected",
|
|
value: function isSelected(option) {
|
|
var selected = false;
|
|
var optionValue = this.getOptionValue(option);
|
|
|
|
if (this.props.multiple) {
|
|
if (this.props.value && this.props.value.length) {
|
|
var _iterator = _createForOfIteratorHelper$7(this.props.value),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var val = _step.value;
|
|
|
|
if (ObjectUtils.equals(val, optionValue, this.props.dataKey)) {
|
|
selected = true;
|
|
break;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
}
|
|
} else {
|
|
selected = ObjectUtils.equals(this.props.value, optionValue, this.props.dataKey);
|
|
}
|
|
|
|
return selected;
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (this.props.tooltip) {
|
|
this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$d({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.element,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderItems",
|
|
value: function renderItems() {
|
|
var _this3 = this;
|
|
|
|
if (this.props.options && this.props.options.length) {
|
|
return this.props.options.map(function (option, index) {
|
|
var isDisabled = _this3.props.disabled || _this3.isOptionDisabled(option);
|
|
|
|
var optionLabel = _this3.getOptionLabel(option);
|
|
|
|
var tabIndex = isDisabled ? null : 0;
|
|
return /*#__PURE__*/React.createElement(SelectButtonItem, {
|
|
key: "".concat(optionLabel, "_").concat(index),
|
|
label: optionLabel,
|
|
className: option.className,
|
|
option: option,
|
|
onClick: _this3.onOptionClick,
|
|
template: _this3.props.itemTemplate,
|
|
selected: _this3.isSelected(option),
|
|
tabIndex: tabIndex,
|
|
disabled: isDisabled,
|
|
ariaLabelledBy: _this3.props.ariaLabelledBy
|
|
});
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this4 = this;
|
|
|
|
var className = classNames('p-selectbutton p-buttonset p-component', this.props.className);
|
|
var items = this.renderItems();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
ref: function ref(el) {
|
|
return _this4.element = el;
|
|
},
|
|
className: className,
|
|
style: this.props.style,
|
|
role: "group"
|
|
}, items);
|
|
}
|
|
}]);
|
|
|
|
return SelectButton;
|
|
}(Component);
|
|
|
|
_defineProperty(SelectButton, "defaultProps", {
|
|
id: null,
|
|
value: null,
|
|
options: null,
|
|
optionLabel: null,
|
|
optionValue: null,
|
|
optionDisabled: null,
|
|
tabIndex: null,
|
|
multiple: false,
|
|
unselectable: true,
|
|
disabled: false,
|
|
style: null,
|
|
className: null,
|
|
dataKey: null,
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
ariaLabelledBy: null,
|
|
itemTemplate: null,
|
|
onChange: null
|
|
});
|
|
|
|
function _createSuper$A(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$A(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$A() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Sidebar = /*#__PURE__*/function (_Component) {
|
|
_inherits(Sidebar, _Component);
|
|
|
|
var _super = _createSuper$A(Sidebar);
|
|
|
|
function Sidebar(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Sidebar);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
maskVisible: false,
|
|
visible: false
|
|
};
|
|
_this.onMaskClick = _this.onMaskClick.bind(_assertThisInitialized(_this));
|
|
_this.onClose = _this.onClose.bind(_assertThisInitialized(_this));
|
|
_this.onEntered = _this.onEntered.bind(_assertThisInitialized(_this));
|
|
_this.onExiting = _this.onExiting.bind(_assertThisInitialized(_this));
|
|
_this.onExited = _this.onExited.bind(_assertThisInitialized(_this));
|
|
_this.sidebarRef = /*#__PURE__*/React.createRef();
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Sidebar, [{
|
|
key: "getPositionClass",
|
|
value: function getPositionClass() {
|
|
var _this2 = this;
|
|
|
|
var positions = ['left', 'right', 'top', 'bottom'];
|
|
var pos = positions.find(function (item) {
|
|
return item === _this2.props.position;
|
|
});
|
|
return pos ? "p-sidebar-".concat(pos) : '';
|
|
}
|
|
}, {
|
|
key: "focus",
|
|
value: function focus() {
|
|
var activeElement = document.activeElement;
|
|
var isActiveElementInDialog = activeElement && this.sidebarRef && this.sidebarRef.current.contains(activeElement);
|
|
|
|
if (!isActiveElementInDialog && this.props.showCloseIcon) {
|
|
this.closeIcon.focus();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onMaskClick",
|
|
value: function onMaskClick(event) {
|
|
if (this.props.dismissable && this.props.modal && this.mask === event.target) {
|
|
this.onClose(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onClose",
|
|
value: function onClose(event) {
|
|
this.props.onHide();
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onEntered",
|
|
value: function onEntered() {
|
|
if (this.props.onShow) {
|
|
this.props.onShow();
|
|
}
|
|
|
|
this.focus();
|
|
this.enableDocumentSettings();
|
|
}
|
|
}, {
|
|
key: "onExiting",
|
|
value: function onExiting() {
|
|
if (this.props.modal) {
|
|
DomHandler.addClass(this.mask, 'p-component-overlay-leave');
|
|
}
|
|
}
|
|
}, {
|
|
key: "onExited",
|
|
value: function onExited() {
|
|
ZIndexUtils.clear(this.mask);
|
|
this.setState({
|
|
maskVisible: false
|
|
});
|
|
this.disableDocumentSettings();
|
|
}
|
|
}, {
|
|
key: "enableDocumentSettings",
|
|
value: function enableDocumentSettings() {
|
|
this.bindGlobalListeners();
|
|
|
|
if (this.props.blockScroll) {
|
|
DomHandler.addClass(document.body, 'p-overflow-hidden');
|
|
}
|
|
}
|
|
}, {
|
|
key: "disableDocumentSettings",
|
|
value: function disableDocumentSettings() {
|
|
this.unbindGlobalListeners();
|
|
|
|
if (this.props.blockScroll) {
|
|
DomHandler.removeClass(document.body, 'p-overflow-hidden');
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindGlobalListeners",
|
|
value: function bindGlobalListeners() {
|
|
if (this.props.closeOnEscape) {
|
|
this.bindDocumentEscapeListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindGlobalListeners",
|
|
value: function unbindGlobalListeners() {
|
|
this.unbindDocumentEscapeListener();
|
|
}
|
|
}, {
|
|
key: "bindDocumentEscapeListener",
|
|
value: function bindDocumentEscapeListener() {
|
|
var _this3 = this;
|
|
|
|
this.documentEscapeListener = function (event) {
|
|
if (event.which === 27) {
|
|
if (ZIndexUtils.get(_this3.mask) === ZIndexUtils.getCurrent('modal', PrimeReact.autoZIndex)) {
|
|
_this3.onClose(event);
|
|
}
|
|
}
|
|
};
|
|
|
|
document.addEventListener('keydown', this.documentEscapeListener);
|
|
}
|
|
}, {
|
|
key: "unbindDocumentEscapeListener",
|
|
value: function unbindDocumentEscapeListener() {
|
|
if (this.documentEscapeListener) {
|
|
document.removeEventListener('keydown', this.documentEscapeListener);
|
|
this.documentEscapeListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
var _this4 = this;
|
|
|
|
if (this.props.visible) {
|
|
this.setState({
|
|
maskVisible: true,
|
|
visible: true
|
|
}, function () {
|
|
ZIndexUtils.set('modal', _this4.mask, PrimeReact.autoZIndex, _this4.props.baseZIndex || PrimeReact.zIndex['modal']);
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps, prevState) {
|
|
var _this5 = this;
|
|
|
|
if (this.props.visible && !this.state.maskVisible) {
|
|
this.setState({
|
|
maskVisible: true
|
|
}, function () {
|
|
ZIndexUtils.set('modal', _this5.mask, PrimeReact.autoZIndex, _this5.props.baseZIndex || PrimeReact.zIndex['modal']);
|
|
});
|
|
}
|
|
|
|
if (this.props.visible !== this.state.visible && this.state.maskVisible) {
|
|
this.setState({
|
|
visible: this.props.visible
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.disableDocumentSettings();
|
|
ZIndexUtils.clear(this.mask);
|
|
}
|
|
}, {
|
|
key: "renderCloseIcon",
|
|
value: function renderCloseIcon() {
|
|
var _this6 = this;
|
|
|
|
if (this.props.showCloseIcon) {
|
|
return /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
ref: function ref(el) {
|
|
return _this6.closeIcon = el;
|
|
},
|
|
className: "p-sidebar-close p-sidebar-icon p-link",
|
|
onClick: this.onClose,
|
|
"aria-label": this.props.ariaCloseLabel
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-sidebar-close-icon pi pi-times"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderIcons",
|
|
value: function renderIcons() {
|
|
if (this.props.icons) {
|
|
return ObjectUtils.getJSXElement(this.props.icons, this.props);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
var _this7 = this;
|
|
|
|
var className = classNames('p-sidebar p-component', this.props.className);
|
|
var maskClassName = classNames('p-sidebar-mask', {
|
|
'p-component-overlay p-component-overlay-enter': this.props.modal,
|
|
'p-sidebar-mask-scrollblocker': this.props.blockScroll,
|
|
'p-sidebar-visible': this.state.maskVisible,
|
|
'p-sidebar-full': this.props.fullScreen
|
|
}, this.props.maskClassName, this.getPositionClass());
|
|
var closeIcon = this.renderCloseIcon();
|
|
var icons = this.renderIcons();
|
|
var transitionTimeout = {
|
|
enter: this.props.fullScreen ? 150 : 300,
|
|
exit: this.props.fullScreen ? 150 : 300
|
|
};
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this7.mask = el;
|
|
},
|
|
style: this.props.maskStyle,
|
|
className: maskClassName,
|
|
onClick: this.onMaskClick
|
|
}, /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.sidebarRef,
|
|
classNames: "p-sidebar",
|
|
"in": this.state.visible,
|
|
timeout: transitionTimeout,
|
|
options: this.props.transitionOptions,
|
|
unmountOnExit: true,
|
|
onEntered: this.onEntered,
|
|
onExiting: this.onExiting,
|
|
onExited: this.onExited
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.sidebarRef,
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style,
|
|
role: "complementary"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-sidebar-header"
|
|
}, icons, closeIcon), /*#__PURE__*/React.createElement("div", {
|
|
className: "p-sidebar-content"
|
|
}, this.props.children))));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
if (this.state.maskVisible) {
|
|
var element = this.renderElement();
|
|
return /*#__PURE__*/React.createElement(Portal, {
|
|
element: element,
|
|
appendTo: this.props.appendTo,
|
|
visible: true
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}]);
|
|
|
|
return Sidebar;
|
|
}(Component);
|
|
|
|
_defineProperty(Sidebar, "defaultProps", {
|
|
id: null,
|
|
style: null,
|
|
className: null,
|
|
maskStyle: null,
|
|
maskClassName: null,
|
|
visible: false,
|
|
position: 'left',
|
|
fullScreen: false,
|
|
blockScroll: false,
|
|
baseZIndex: 0,
|
|
dismissable: true,
|
|
showCloseIcon: true,
|
|
ariaCloseLabel: 'close',
|
|
closeOnEscape: true,
|
|
icons: null,
|
|
modal: true,
|
|
appendTo: null,
|
|
transitionOptions: null,
|
|
onShow: null,
|
|
onHide: null
|
|
});
|
|
|
|
function _createSuper$z(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$z(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$z() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Skeleton = /*#__PURE__*/function (_Component) {
|
|
_inherits(Skeleton, _Component);
|
|
|
|
var _super = _createSuper$z(Skeleton);
|
|
|
|
function Skeleton() {
|
|
_classCallCheck(this, Skeleton);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(Skeleton, [{
|
|
key: "skeletonStyle",
|
|
value: function skeletonStyle() {
|
|
if (this.props.size) return {
|
|
width: this.props.size,
|
|
height: this.props.size,
|
|
borderRadius: this.props.borderRadius
|
|
};else return {
|
|
width: this.props.width,
|
|
height: this.props.height,
|
|
borderRadius: this.props.borderRadius
|
|
};
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var skeletonClassName = classNames('p-skeleton p-component', {
|
|
'p-skeleton-circle': this.props.shape === 'circle',
|
|
'p-skeleton-none': this.props.animation === 'none'
|
|
}, this.props.className);
|
|
var style = this.skeletonStyle();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
style: style,
|
|
className: skeletonClassName
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return Skeleton;
|
|
}(Component);
|
|
|
|
_defineProperty(Skeleton, "defaultProps", {
|
|
shape: 'rectangle',
|
|
size: null,
|
|
width: '100%',
|
|
height: '1rem',
|
|
borderRadius: null,
|
|
animation: 'wave',
|
|
style: null,
|
|
className: null
|
|
});
|
|
|
|
function _createSuper$y(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$y(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$y() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var SlideMenuSub = /*#__PURE__*/function (_Component) {
|
|
_inherits(SlideMenuSub, _Component);
|
|
|
|
var _super = _createSuper$y(SlideMenuSub);
|
|
|
|
function SlideMenuSub(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, SlideMenuSub);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
activeItem: null
|
|
};
|
|
return _this;
|
|
}
|
|
|
|
_createClass(SlideMenuSub, [{
|
|
key: "onItemClick",
|
|
value: function onItemClick(event, item) {
|
|
if (item.disabled) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
if (!item.url) {
|
|
event.preventDefault();
|
|
}
|
|
|
|
if (item.command) {
|
|
item.command({
|
|
originalEvent: event,
|
|
item: item
|
|
});
|
|
}
|
|
|
|
if (item.items) {
|
|
this.setState({
|
|
activeItem: item
|
|
});
|
|
this.props.onForward();
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderSeparator",
|
|
value: function renderSeparator(index) {
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: 'separator_' + index,
|
|
className: "p-menu-separator"
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderSubmenu",
|
|
value: function renderSubmenu(item) {
|
|
if (item.items) {
|
|
return /*#__PURE__*/React.createElement(SlideMenuSub, {
|
|
model: item.items,
|
|
index: this.props.index + 1,
|
|
menuWidth: this.props.menuWidth,
|
|
effectDuration: this.props.effectDuration,
|
|
onForward: this.props.onForward,
|
|
parentActive: item === this.state.activeItem
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderMenuitem",
|
|
value: function renderMenuitem(item, index) {
|
|
var _this2 = this;
|
|
|
|
var active = this.state.activeItem === item;
|
|
var className = classNames('p-menuitem', {
|
|
'p-menuitem-active': active,
|
|
'p-disabled': item.disabled
|
|
}, item.className);
|
|
var iconClassName = classNames('p-menuitem-icon', item.icon);
|
|
var submenuIconClassName = 'p-submenu-icon pi pi-fw pi-angle-right';
|
|
var icon = item.icon && /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
});
|
|
var label = item.label && /*#__PURE__*/React.createElement("span", {
|
|
className: "p-menuitem-text"
|
|
}, item.label);
|
|
var submenuIcon = item.items && /*#__PURE__*/React.createElement("span", {
|
|
className: submenuIconClassName
|
|
});
|
|
var submenu = this.renderSubmenu(item);
|
|
var content = /*#__PURE__*/React.createElement("a", {
|
|
href: item.url || '#',
|
|
className: "p-menuitem-link",
|
|
target: item.target,
|
|
onClick: function onClick(event) {
|
|
return _this2.onItemClick(event, item, index);
|
|
},
|
|
"aria-disabled": item.disabled
|
|
}, icon, label, submenuIcon);
|
|
|
|
if (item.template) {
|
|
var defaultContentOptions = {
|
|
onClick: function onClick(event) {
|
|
return _this2.onItemClick(event, item, index);
|
|
},
|
|
className: 'p-menuitem-link',
|
|
labelClassName: 'p-menuitem-text',
|
|
iconClassName: iconClassName,
|
|
submenuIconClassName: submenuIconClassName,
|
|
element: content,
|
|
props: this.props,
|
|
active: active
|
|
};
|
|
content = ObjectUtils.getJSXElement(item.template, item, defaultContentOptions);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: item.label + '_' + index,
|
|
className: className,
|
|
style: item.style
|
|
}, content, submenu);
|
|
}
|
|
}, {
|
|
key: "renderItem",
|
|
value: function renderItem(item, index) {
|
|
if (item.separator) return this.renderSeparator(index);else return this.renderMenuitem(item, index);
|
|
}
|
|
}, {
|
|
key: "renderItems",
|
|
value: function renderItems() {
|
|
var _this3 = this;
|
|
|
|
if (this.props.model) {
|
|
return this.props.model.map(function (item, index) {
|
|
return _this3.renderItem(item, index);
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames({
|
|
'p-slidemenu-rootlist': this.props.root,
|
|
'p-submenu-list': !this.props.root,
|
|
'p-active-submenu': this.props.parentActive
|
|
});
|
|
var style = {
|
|
width: this.props.menuWidth + 'px',
|
|
left: this.props.root ? -1 * this.props.level * this.props.menuWidth + 'px' : this.props.menuWidth + 'px',
|
|
transitionProperty: this.props.root ? 'left' : 'none',
|
|
transitionDuration: this.props.effectDuration + 'ms',
|
|
transitionTimingFunction: this.props.easing
|
|
};
|
|
var items = this.renderItems();
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
className: className,
|
|
style: style
|
|
}, items);
|
|
}
|
|
}]);
|
|
|
|
return SlideMenuSub;
|
|
}(Component);
|
|
|
|
_defineProperty(SlideMenuSub, "defaultProps", {
|
|
model: null,
|
|
level: 0,
|
|
easing: 'ease-out',
|
|
effectDuration: 250,
|
|
menuWidth: 190,
|
|
parentActive: false,
|
|
onForward: null
|
|
});
|
|
|
|
var SlideMenu = /*#__PURE__*/function (_Component2) {
|
|
_inherits(SlideMenu, _Component2);
|
|
|
|
var _super2 = _createSuper$y(SlideMenu);
|
|
|
|
function SlideMenu(props) {
|
|
var _this4;
|
|
|
|
_classCallCheck(this, SlideMenu);
|
|
|
|
_this4 = _super2.call(this, props);
|
|
_this4.state = {
|
|
level: 0,
|
|
visible: false
|
|
};
|
|
_this4.navigateBack = _this4.navigateBack.bind(_assertThisInitialized(_this4));
|
|
_this4.navigateForward = _this4.navigateForward.bind(_assertThisInitialized(_this4));
|
|
_this4.onEnter = _this4.onEnter.bind(_assertThisInitialized(_this4));
|
|
_this4.onEntered = _this4.onEntered.bind(_assertThisInitialized(_this4));
|
|
_this4.onExit = _this4.onExit.bind(_assertThisInitialized(_this4));
|
|
_this4.onExited = _this4.onExited.bind(_assertThisInitialized(_this4));
|
|
_this4.onPanelClick = _this4.onPanelClick.bind(_assertThisInitialized(_this4));
|
|
_this4.menuRef = /*#__PURE__*/React.createRef();
|
|
return _this4;
|
|
}
|
|
|
|
_createClass(SlideMenu, [{
|
|
key: "onPanelClick",
|
|
value: function onPanelClick(event) {
|
|
if (this.props.popup) {
|
|
OverlayService.emit('overlay-click', {
|
|
originalEvent: event,
|
|
target: this.target
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "navigateForward",
|
|
value: function navigateForward() {
|
|
this.setState({
|
|
level: this.state.level + 1
|
|
});
|
|
}
|
|
}, {
|
|
key: "navigateBack",
|
|
value: function navigateBack() {
|
|
this.setState({
|
|
level: this.state.level - 1
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderBackward",
|
|
value: function renderBackward() {
|
|
var _this5 = this;
|
|
|
|
var className = classNames('p-slidemenu-backward', {
|
|
'p-hidden': this.state.level === 0
|
|
});
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this5.backward = el;
|
|
},
|
|
className: className,
|
|
onClick: this.navigateBack
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-slidemenu-backward-icon pi pi-fw pi-chevron-left"
|
|
}), /*#__PURE__*/React.createElement("span", null, this.props.backLabel));
|
|
}
|
|
}, {
|
|
key: "toggle",
|
|
value: function toggle(event) {
|
|
if (this.props.popup) {
|
|
if (this.state.visible) this.hide(event);else this.show(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "show",
|
|
value: function show(event) {
|
|
var _this6 = this;
|
|
|
|
this.target = event.currentTarget;
|
|
var currentEvent = event;
|
|
this.setState({
|
|
visible: true
|
|
}, function () {
|
|
if (_this6.props.onShow) {
|
|
_this6.props.onShow(currentEvent);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "hide",
|
|
value: function hide(event) {
|
|
var _this7 = this;
|
|
|
|
var currentEvent = event;
|
|
this.setState({
|
|
visible: false
|
|
}, function () {
|
|
if (_this7.props.onHide) {
|
|
_this7.props.onHide(currentEvent);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onEnter",
|
|
value: function onEnter() {
|
|
if (this.props.autoZIndex) {
|
|
ZIndexUtils.set('menu', this.menuRef.current, PrimeReact.autoZIndex, this.props.baseZIndex || PrimeReact.zIndex['menu']);
|
|
}
|
|
|
|
DomHandler.absolutePosition(this.menuRef.current, this.target);
|
|
}
|
|
}, {
|
|
key: "onEntered",
|
|
value: function onEntered() {
|
|
this.bindDocumentClickListener();
|
|
this.bindDocumentResizeListener();
|
|
this.bindScrollListener();
|
|
}
|
|
}, {
|
|
key: "onExit",
|
|
value: function onExit() {
|
|
this.target = null;
|
|
this.unbindDocumentClickListener();
|
|
this.unbindDocumentResizeListener();
|
|
this.unbindScrollListener();
|
|
}
|
|
}, {
|
|
key: "onExited",
|
|
value: function onExited() {
|
|
ZIndexUtils.clear(this.menuRef.current);
|
|
this.setState({
|
|
level: 0
|
|
});
|
|
}
|
|
}, {
|
|
key: "bindDocumentClickListener",
|
|
value: function bindDocumentClickListener() {
|
|
var _this8 = this;
|
|
|
|
if (!this.documentClickListener) {
|
|
this.documentClickListener = function (event) {
|
|
if (_this8.state.visible && _this8.isOutsideClicked(event)) {
|
|
_this8.hide(event);
|
|
}
|
|
};
|
|
|
|
document.addEventListener('click', this.documentClickListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "isOutsideClicked",
|
|
value: function isOutsideClicked(event) {
|
|
return this.menuRef && this.menuRef.current && !(this.menuRef.current.isSameNode(event.target) || this.menuRef.current.contains(event.target));
|
|
}
|
|
}, {
|
|
key: "bindDocumentResizeListener",
|
|
value: function bindDocumentResizeListener() {
|
|
var _this9 = this;
|
|
|
|
if (!this.documentResizeListener) {
|
|
this.documentResizeListener = function (event) {
|
|
if (_this9.state.visible && !DomHandler.isTouchDevice()) {
|
|
_this9.hide(event);
|
|
}
|
|
};
|
|
|
|
window.addEventListener('resize', this.documentResizeListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentClickListener",
|
|
value: function unbindDocumentClickListener() {
|
|
if (this.documentClickListener) {
|
|
document.removeEventListener('click', this.documentClickListener);
|
|
this.documentClickListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentResizeListener",
|
|
value: function unbindDocumentResizeListener() {
|
|
if (this.documentResizeListener) {
|
|
window.removeEventListener('resize', this.documentResizeListener);
|
|
this.documentResizeListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindScrollListener",
|
|
value: function bindScrollListener() {
|
|
var _this10 = this;
|
|
|
|
if (!this.scrollHandler) {
|
|
this.scrollHandler = new ConnectedOverlayScrollHandler(this.target, function (event) {
|
|
if (_this10.state.visible) {
|
|
_this10.hide(event);
|
|
}
|
|
});
|
|
}
|
|
|
|
this.scrollHandler.bindScrollListener();
|
|
}
|
|
}, {
|
|
key: "unbindScrollListener",
|
|
value: function unbindScrollListener() {
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.unbindScrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps, prevState) {
|
|
if (this.props.model !== prevProps.model) {
|
|
this.setState({
|
|
level: 0
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.unbindDocumentClickListener();
|
|
this.unbindDocumentResizeListener();
|
|
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.destroy();
|
|
this.scrollHandler = null;
|
|
}
|
|
|
|
ZIndexUtils.clear(this.menuRef.current);
|
|
}
|
|
}, {
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
var _this11 = this;
|
|
|
|
var className = classNames('p-slidemenu p-component', {
|
|
'p-slidemenu-overlay': this.props.popup
|
|
}, this.props.className);
|
|
var backward = this.renderBackward();
|
|
return /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.menuRef,
|
|
classNames: "p-connected-overlay",
|
|
"in": !this.props.popup || this.state.visible,
|
|
timeout: {
|
|
enter: 120,
|
|
exit: 100
|
|
},
|
|
options: this.props.transitionOptions,
|
|
unmountOnExit: true,
|
|
onEnter: this.onEnter,
|
|
onEntered: this.onEntered,
|
|
onExit: this.onExit,
|
|
onExited: this.onExited
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.menuRef,
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style,
|
|
onClick: this.onPanelClick
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-slidemenu-wrapper",
|
|
style: {
|
|
height: this.props.viewportHeight + 'px'
|
|
}
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-slidemenu-content",
|
|
ref: function ref(el) {
|
|
return _this11.slideMenuContent = el;
|
|
}
|
|
}, /*#__PURE__*/React.createElement(SlideMenuSub, {
|
|
model: this.props.model,
|
|
root: true,
|
|
index: 0,
|
|
menuWidth: this.props.menuWidth,
|
|
effectDuration: this.props.effectDuration,
|
|
level: this.state.level,
|
|
parentActive: this.state.level === 0,
|
|
onForward: this.navigateForward
|
|
})), backward)));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var element = this.renderElement();
|
|
return this.props.popup ? /*#__PURE__*/React.createElement(Portal, {
|
|
element: element,
|
|
appendTo: this.props.appendTo
|
|
}) : element;
|
|
}
|
|
}]);
|
|
|
|
return SlideMenu;
|
|
}(Component);
|
|
|
|
_defineProperty(SlideMenu, "defaultProps", {
|
|
id: null,
|
|
model: null,
|
|
popup: false,
|
|
style: null,
|
|
className: null,
|
|
easing: 'ease-out',
|
|
effectDuration: 250,
|
|
backLabel: 'Back',
|
|
menuWidth: 190,
|
|
viewportHeight: 175,
|
|
autoZIndex: true,
|
|
baseZIndex: 0,
|
|
appendTo: null,
|
|
transitionOptions: null,
|
|
onShow: null,
|
|
onHide: null
|
|
});
|
|
|
|
function _createSuper$x(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$x(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$x() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Slider = /*#__PURE__*/function (_Component) {
|
|
_inherits(Slider, _Component);
|
|
|
|
var _super = _createSuper$x(Slider);
|
|
|
|
function Slider(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Slider);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onBarClick = _this.onBarClick.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.handleIndex = 0;
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Slider, [{
|
|
key: "value",
|
|
get: function get() {
|
|
return this.props.range ? this.props.value || [0, 100] : this.props.value || 0;
|
|
}
|
|
}, {
|
|
key: "spin",
|
|
value: function spin(event, dir) {
|
|
var value = this.props.range ? this.value[this.handleIndex] : this.value;
|
|
var step = (this.props.step || 1) * dir;
|
|
this.updateValue(event, value + step);
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onDragStart",
|
|
value: function onDragStart(event, index) {
|
|
if (this.props.disabled) {
|
|
return;
|
|
}
|
|
|
|
this.dragging = true;
|
|
this.updateDomData();
|
|
this.sliderHandleClick = true;
|
|
this.handleIndex = index; //event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onMouseDown",
|
|
value: function onMouseDown(event, index) {
|
|
this.bindDragListeners();
|
|
this.onDragStart(event, index);
|
|
}
|
|
}, {
|
|
key: "onTouchStart",
|
|
value: function onTouchStart(event, index) {
|
|
this.bindTouchListeners();
|
|
this.onDragStart(event, index);
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event, index) {
|
|
if (this.props.disabled) {
|
|
return;
|
|
}
|
|
|
|
this.handleIndex = index;
|
|
var key = event.key;
|
|
|
|
if (key === 'ArrowRight' || key === 'ArrowUp') {
|
|
this.spin(event, 1);
|
|
} else if (key === 'ArrowLeft' || key === 'ArrowDown') {
|
|
this.spin(event, -1);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onBarClick",
|
|
value: function onBarClick(event) {
|
|
if (this.props.disabled) {
|
|
return;
|
|
}
|
|
|
|
if (!this.sliderHandleClick) {
|
|
this.updateDomData();
|
|
var value = this.setValue(event);
|
|
|
|
if (this.props.onSlideEnd) {
|
|
this.props.onSlideEnd({
|
|
originalEvent: event,
|
|
value: value
|
|
});
|
|
}
|
|
}
|
|
|
|
this.sliderHandleClick = false;
|
|
}
|
|
}, {
|
|
key: "onDrag",
|
|
value: function onDrag(event) {
|
|
if (this.dragging) {
|
|
this.setValue(event);
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDragEnd",
|
|
value: function onDragEnd(event) {
|
|
if (this.dragging) {
|
|
this.dragging = false;
|
|
|
|
if (this.props.onSlideEnd) {
|
|
this.props.onSlideEnd({
|
|
originalEvent: event,
|
|
value: this.props.value
|
|
});
|
|
}
|
|
|
|
this.unbindDragListeners();
|
|
this.unbindTouchListeners();
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindDragListeners",
|
|
value: function bindDragListeners() {
|
|
if (!this.dragListener) {
|
|
this.dragListener = this.onDrag.bind(this);
|
|
document.addEventListener('mousemove', this.dragListener);
|
|
}
|
|
|
|
if (!this.dragEndListener) {
|
|
this.dragEndListener = this.onDragEnd.bind(this);
|
|
document.addEventListener('mouseup', this.dragEndListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDragListeners",
|
|
value: function unbindDragListeners() {
|
|
if (this.dragListener) {
|
|
document.removeEventListener('mousemove', this.dragListener);
|
|
this.dragListener = null;
|
|
}
|
|
|
|
if (this.dragEndListener) {
|
|
document.removeEventListener('mouseup', this.dragEndListener);
|
|
this.dragEndListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindTouchListeners",
|
|
value: function bindTouchListeners() {
|
|
if (!this.dragListener) {
|
|
this.dragListener = this.onDrag.bind(this);
|
|
document.addEventListener('touchmove', this.dragListener);
|
|
}
|
|
|
|
if (!this.dragEndListener) {
|
|
this.dragEndListener = this.onDragEnd.bind(this);
|
|
document.addEventListener('touchend', this.dragEndListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindTouchListeners",
|
|
value: function unbindTouchListeners() {
|
|
if (this.dragListener) {
|
|
document.removeEventListener('touchmove', this.dragListener);
|
|
this.dragListener = null;
|
|
}
|
|
|
|
if (this.dragEndListener) {
|
|
document.removeEventListener('touchend', this.dragEndListener);
|
|
this.dragEndListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateDomData",
|
|
value: function updateDomData() {
|
|
var rect = this.el.getBoundingClientRect();
|
|
this.initX = rect.left + DomHandler.getWindowScrollLeft();
|
|
this.initY = rect.top + DomHandler.getWindowScrollTop();
|
|
this.barWidth = this.el.offsetWidth;
|
|
this.barHeight = this.el.offsetHeight;
|
|
}
|
|
}, {
|
|
key: "setValue",
|
|
value: function setValue(event) {
|
|
var handleValue;
|
|
var pageX = event.touches ? event.touches[0].pageX : event.pageX;
|
|
var pageY = event.touches ? event.touches[0].pageY : event.pageY;
|
|
if (this.props.orientation === 'horizontal') handleValue = (pageX - this.initX) * 100 / this.barWidth;else handleValue = (this.initY + this.barHeight - pageY) * 100 / this.barHeight;
|
|
var newValue = (this.props.max - this.props.min) * (handleValue / 100) + this.props.min;
|
|
|
|
if (this.props.step) {
|
|
var oldValue = this.props.range ? this.value[this.handleIndex] : this.value;
|
|
var diff = newValue - oldValue;
|
|
if (diff < 0) newValue = oldValue + Math.ceil(newValue / this.props.step - oldValue / this.props.step) * this.props.step;else if (diff > 0) newValue = oldValue + Math.floor(newValue / this.props.step - oldValue / this.props.step) * this.props.step;
|
|
} else {
|
|
newValue = Math.floor(newValue);
|
|
}
|
|
|
|
return this.updateValue(event, newValue);
|
|
}
|
|
}, {
|
|
key: "updateValue",
|
|
value: function updateValue(event, value) {
|
|
var parsedValue = parseFloat(value.toFixed(10));
|
|
var newValue = parsedValue;
|
|
|
|
if (this.props.range) {
|
|
if (this.handleIndex === 0) {
|
|
if (parsedValue < this.props.min) parsedValue = this.props.min;else if (parsedValue > this.value[1]) parsedValue = this.value[1];
|
|
} else {
|
|
if (parsedValue > this.props.max) parsedValue = this.props.max;else if (parsedValue < this.value[0]) parsedValue = this.value[0];
|
|
}
|
|
|
|
newValue = _toConsumableArray(this.value);
|
|
newValue[this.handleIndex] = parsedValue;
|
|
|
|
if (this.props.onChange) {
|
|
this.props.onChange({
|
|
originalEvent: event,
|
|
value: newValue
|
|
});
|
|
}
|
|
} else {
|
|
if (parsedValue < this.props.min) parsedValue = this.props.min;else if (parsedValue > this.props.max) parsedValue = this.props.max;
|
|
newValue = parsedValue;
|
|
|
|
if (this.props.onChange) {
|
|
this.props.onChange({
|
|
originalEvent: event,
|
|
value: newValue
|
|
});
|
|
}
|
|
}
|
|
|
|
return newValue;
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.unbindDragListeners();
|
|
this.unbindTouchListeners();
|
|
}
|
|
}, {
|
|
key: "renderHandle",
|
|
value: function renderHandle(leftValue, bottomValue, index) {
|
|
var _this2 = this;
|
|
|
|
var handleClassName = classNames('p-slider-handle', {
|
|
'p-slider-handle-start': index === 0,
|
|
'p-slider-handle-end': index === 1,
|
|
'p-slider-handle-active': this.handleIndex === index
|
|
});
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
onMouseDown: function onMouseDown(event) {
|
|
return _this2.onMouseDown(event, index);
|
|
},
|
|
onTouchStart: function onTouchStart(event) {
|
|
return _this2.onTouchStart(event, index);
|
|
},
|
|
onKeyDown: function onKeyDown(event) {
|
|
return _this2.onKeyDown(event, index);
|
|
},
|
|
tabIndex: this.props.tabIndex,
|
|
className: handleClassName,
|
|
style: {
|
|
transition: this.dragging ? 'none' : null,
|
|
left: leftValue !== null && leftValue + '%',
|
|
bottom: bottomValue && bottomValue + '%'
|
|
},
|
|
role: "slider",
|
|
"aria-valuemin": this.props.min,
|
|
"aria-valuemax": this.props.max,
|
|
"aria-valuenow": leftValue || bottomValue,
|
|
"aria-labelledby": this.props.ariaLabelledBy
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderRangeSlider",
|
|
value: function renderRangeSlider() {
|
|
var values = this.value;
|
|
var horizontal = this.props.orientation === 'horizontal';
|
|
var handleValueStart = (values[0] < this.props.min ? 0 : values[0] - this.props.min) * 100 / (this.props.max - this.props.min);
|
|
var handleValueEnd = (values[1] > this.props.max ? 100 : values[1] - this.props.min) * 100 / (this.props.max - this.props.min);
|
|
var rangeStartHandle = horizontal ? this.renderHandle(handleValueStart, null, 0) : this.renderHandle(null, handleValueStart, 0);
|
|
var rangeEndHandle = horizontal ? this.renderHandle(handleValueEnd, null, 1) : this.renderHandle(null, handleValueEnd, 1);
|
|
var rangeStyle = horizontal ? {
|
|
left: handleValueStart + '%',
|
|
width: handleValueEnd - handleValueStart + '%'
|
|
} : {
|
|
bottom: handleValueStart + '%',
|
|
height: handleValueEnd - handleValueStart + '%'
|
|
};
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-slider-range",
|
|
style: rangeStyle
|
|
}), rangeStartHandle, rangeEndHandle);
|
|
}
|
|
}, {
|
|
key: "renderSingleSlider",
|
|
value: function renderSingleSlider() {
|
|
var value = this.value;
|
|
var handleValue;
|
|
if (value < this.props.min) handleValue = 0;else if (value > this.props.max) handleValue = 100;else handleValue = (value - this.props.min) * 100 / (this.props.max - this.props.min);
|
|
var rangeStyle = this.props.orientation === 'horizontal' ? {
|
|
width: handleValue + '%'
|
|
} : {
|
|
height: handleValue + '%'
|
|
};
|
|
var handle = this.props.orientation === 'horizontal' ? this.renderHandle(handleValue, null, null) : this.renderHandle(null, handleValue, null);
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-slider-range",
|
|
style: rangeStyle
|
|
}), handle);
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this3 = this;
|
|
|
|
var className = classNames('p-slider p-component', this.props.className, {
|
|
'p-disabled': this.props.disabled,
|
|
'p-slider-horizontal': this.props.orientation === 'horizontal',
|
|
'p-slider-vertical': this.props.orientation === 'vertical'
|
|
});
|
|
var content = this.props.range ? this.renderRangeSlider() : this.renderSingleSlider();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
ref: function ref(el) {
|
|
return _this3.el = el;
|
|
},
|
|
style: this.props.style,
|
|
className: className,
|
|
onClick: this.onBarClick
|
|
}, content);
|
|
}
|
|
}]);
|
|
|
|
return Slider;
|
|
}(Component);
|
|
|
|
_defineProperty(Slider, "defaultProps", {
|
|
id: null,
|
|
value: null,
|
|
min: 0,
|
|
max: 100,
|
|
orientation: 'horizontal',
|
|
step: null,
|
|
range: false,
|
|
style: null,
|
|
className: null,
|
|
disabled: false,
|
|
tabIndex: 0,
|
|
ariaLabelledBy: null,
|
|
onChange: null,
|
|
onSlideEnd: null
|
|
});
|
|
|
|
function _createSuper$w(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$w(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$w() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var SplitButtonItem = /*#__PURE__*/function (_Component) {
|
|
_inherits(SplitButtonItem, _Component);
|
|
|
|
var _super = _createSuper$w(SplitButtonItem);
|
|
|
|
function SplitButtonItem(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, SplitButtonItem);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(SplitButtonItem, [{
|
|
key: "onClick",
|
|
value: function onClick(e) {
|
|
if (this.props.menuitem.command) {
|
|
this.props.menuitem.command({
|
|
originalEvent: e,
|
|
item: this.props.menuitem
|
|
});
|
|
}
|
|
|
|
if (this.props.onItemClick) {
|
|
this.props.onItemClick(e);
|
|
}
|
|
|
|
e.preventDefault();
|
|
}
|
|
}, {
|
|
key: "renderSeparator",
|
|
value: function renderSeparator() {
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
className: "p-menu-separator",
|
|
role: "separator"
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderMenuitem",
|
|
value: function renderMenuitem() {
|
|
var _this2 = this;
|
|
|
|
var _this$props$menuitem = this.props.menuitem,
|
|
disabled = _this$props$menuitem.disabled,
|
|
icon = _this$props$menuitem.icon,
|
|
label = _this$props$menuitem.label,
|
|
template = _this$props$menuitem.template,
|
|
url = _this$props$menuitem.url,
|
|
target = _this$props$menuitem.target;
|
|
var className = classNames('p-menuitem-link', {
|
|
'p-disabled': disabled
|
|
});
|
|
var iconClassName = classNames('p-menuitem-icon', icon);
|
|
icon = icon && /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
});
|
|
label = label && /*#__PURE__*/React.createElement("span", {
|
|
className: "p-menuitem-text"
|
|
}, label);
|
|
var content = /*#__PURE__*/React.createElement("a", {
|
|
href: url || '#',
|
|
role: "menuitem",
|
|
className: className,
|
|
target: target,
|
|
onClick: this.onClick
|
|
}, icon, label);
|
|
|
|
if (template) {
|
|
var defaultContentOptions = {
|
|
onClick: function onClick(event) {
|
|
return _this2.onClick(event);
|
|
},
|
|
className: className,
|
|
labelClassName: 'p-menuitem-text',
|
|
iconClassName: iconClassName,
|
|
element: content,
|
|
props: this.props
|
|
};
|
|
content = ObjectUtils.getJSXElement(template, this.props.menuitem, defaultContentOptions);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
className: "p-menuitem",
|
|
role: "none"
|
|
}, content);
|
|
}
|
|
}, {
|
|
key: "renderItem",
|
|
value: function renderItem() {
|
|
if (this.props.menuitem.separator) {
|
|
return this.renderSeparator();
|
|
}
|
|
|
|
return this.renderMenuitem();
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var item = this.renderItem();
|
|
return item;
|
|
}
|
|
}]);
|
|
|
|
return SplitButtonItem;
|
|
}(Component);
|
|
|
|
_defineProperty(SplitButtonItem, "defaultProps", {
|
|
menuitem: null,
|
|
onItemClick: null
|
|
});
|
|
|
|
function _createSuper$v(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$v(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$v() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
var SplitButtonPanelComponent = /*#__PURE__*/function (_Component) {
|
|
_inherits(SplitButtonPanelComponent, _Component);
|
|
|
|
var _super = _createSuper$v(SplitButtonPanelComponent);
|
|
|
|
function SplitButtonPanelComponent() {
|
|
_classCallCheck(this, SplitButtonPanelComponent);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(SplitButtonPanelComponent, [{
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
var className = classNames('p-menu p-menu-overlay p-component', this.props.menuClassName);
|
|
return /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.props.forwardRef,
|
|
classNames: "p-connected-overlay",
|
|
"in": this.props["in"],
|
|
timeout: {
|
|
enter: 120,
|
|
exit: 100
|
|
},
|
|
options: this.props.transitionOptions,
|
|
unmountOnExit: true,
|
|
onEnter: this.props.onEnter,
|
|
onEntered: this.props.onEntered,
|
|
onExit: this.props.onExit,
|
|
onExited: this.props.onExited
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.props.forwardRef,
|
|
className: className,
|
|
style: this.props.menuStyle,
|
|
id: this.props.id,
|
|
onClick: this.onClick
|
|
}, /*#__PURE__*/React.createElement("ul", {
|
|
className: "p-menu-list p-reset",
|
|
role: "menu"
|
|
}, this.props.children)));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var element = this.renderElement();
|
|
return /*#__PURE__*/React.createElement(Portal, {
|
|
element: element,
|
|
appendTo: this.props.appendTo
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return SplitButtonPanelComponent;
|
|
}(Component);
|
|
|
|
_defineProperty(SplitButtonPanelComponent, "defaultProps", {
|
|
appendTo: null,
|
|
menuStyle: null,
|
|
menuClassName: null,
|
|
id: null,
|
|
onClick: null
|
|
});
|
|
|
|
var SplitButtonPanel = /*#__PURE__*/React.forwardRef(function (props, ref) {
|
|
return /*#__PURE__*/React.createElement(SplitButtonPanelComponent, _extends({
|
|
forwardRef: ref
|
|
}, props));
|
|
});
|
|
|
|
function ownKeys$c(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$c(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$c(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$c(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$u(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$u(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$u() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var SplitButton = /*#__PURE__*/function (_Component) {
|
|
_inherits(SplitButton, _Component);
|
|
|
|
var _super = _createSuper$u(SplitButton);
|
|
|
|
function SplitButton(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, SplitButton);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
id: props.id,
|
|
overlayVisible: false
|
|
};
|
|
_this.onDropdownButtonClick = _this.onDropdownButtonClick.bind(_assertThisInitialized(_this));
|
|
_this.onItemClick = _this.onItemClick.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEnter = _this.onOverlayEnter.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEntered = _this.onOverlayEntered.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExit = _this.onOverlayExit.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExited = _this.onOverlayExited.bind(_assertThisInitialized(_this));
|
|
_this.onPanelClick = _this.onPanelClick.bind(_assertThisInitialized(_this));
|
|
_this.overlayRef = /*#__PURE__*/React.createRef();
|
|
return _this;
|
|
}
|
|
|
|
_createClass(SplitButton, [{
|
|
key: "onPanelClick",
|
|
value: function onPanelClick(event) {
|
|
OverlayService.emit('overlay-click', {
|
|
originalEvent: event,
|
|
target: this.container
|
|
});
|
|
}
|
|
}, {
|
|
key: "onDropdownButtonClick",
|
|
value: function onDropdownButtonClick() {
|
|
if (this.state.overlayVisible) this.hide();else this.show();
|
|
}
|
|
}, {
|
|
key: "onItemClick",
|
|
value: function onItemClick() {
|
|
this.hide();
|
|
}
|
|
}, {
|
|
key: "show",
|
|
value: function show() {
|
|
this.setState({
|
|
overlayVisible: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "hide",
|
|
value: function hide() {
|
|
this.setState({
|
|
overlayVisible: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "onOverlayEnter",
|
|
value: function onOverlayEnter() {
|
|
ZIndexUtils.set('overlay', this.overlayRef.current, PrimeReact.autoZIndex, PrimeReact.zIndex['overlay']);
|
|
this.alignOverlay();
|
|
}
|
|
}, {
|
|
key: "onOverlayEntered",
|
|
value: function onOverlayEntered() {
|
|
this.bindDocumentClickListener();
|
|
this.bindScrollListener();
|
|
this.bindResizeListener();
|
|
this.props.onShow && this.props.onShow();
|
|
}
|
|
}, {
|
|
key: "onOverlayExit",
|
|
value: function onOverlayExit() {
|
|
this.unbindDocumentClickListener();
|
|
this.unbindScrollListener();
|
|
this.unbindResizeListener();
|
|
}
|
|
}, {
|
|
key: "onOverlayExited",
|
|
value: function onOverlayExited() {
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
this.props.onHide && this.props.onHide();
|
|
}
|
|
}, {
|
|
key: "alignOverlay",
|
|
value: function alignOverlay() {
|
|
DomHandler.alignOverlay(this.overlayRef.current, this.defaultButton.parentElement, this.props.appendTo || PrimeReact.appendTo);
|
|
}
|
|
}, {
|
|
key: "bindDocumentClickListener",
|
|
value: function bindDocumentClickListener() {
|
|
var _this2 = this;
|
|
|
|
if (!this.documentClickListener) {
|
|
this.documentClickListener = function (event) {
|
|
if (_this2.state.overlayVisible && _this2.isOutsideClicked(event)) {
|
|
_this2.hide();
|
|
}
|
|
};
|
|
|
|
document.addEventListener('click', this.documentClickListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindScrollListener",
|
|
value: function bindScrollListener() {
|
|
var _this3 = this;
|
|
|
|
if (!this.scrollHandler) {
|
|
this.scrollHandler = new ConnectedOverlayScrollHandler(this.container, function () {
|
|
if (_this3.state.overlayVisible) {
|
|
_this3.hide();
|
|
}
|
|
});
|
|
}
|
|
|
|
this.scrollHandler.bindScrollListener();
|
|
}
|
|
}, {
|
|
key: "unbindScrollListener",
|
|
value: function unbindScrollListener() {
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.unbindScrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindResizeListener",
|
|
value: function bindResizeListener() {
|
|
var _this4 = this;
|
|
|
|
if (!this.resizeListener) {
|
|
this.resizeListener = function () {
|
|
if (_this4.state.overlayVisible && !DomHandler.isTouchDevice()) {
|
|
_this4.hide();
|
|
}
|
|
};
|
|
|
|
window.addEventListener('resize', this.resizeListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindResizeListener",
|
|
value: function unbindResizeListener() {
|
|
if (this.resizeListener) {
|
|
window.removeEventListener('resize', this.resizeListener);
|
|
this.resizeListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "isOutsideClicked",
|
|
value: function isOutsideClicked(event) {
|
|
return this.container && this.overlayRef && this.overlayRef.current && !this.overlayRef.current.contains(event.target);
|
|
}
|
|
}, {
|
|
key: "unbindDocumentClickListener",
|
|
value: function unbindDocumentClickListener() {
|
|
if (this.documentClickListener) {
|
|
document.removeEventListener('click', this.documentClickListener);
|
|
this.documentClickListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (!this.state.id) {
|
|
this.setState({
|
|
id: UniqueComponentId()
|
|
});
|
|
}
|
|
|
|
if (this.props.tooltip) {
|
|
this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$c({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.unbindDocumentClickListener();
|
|
this.unbindResizeListener();
|
|
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.destroy();
|
|
this.scrollHandler = null;
|
|
}
|
|
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.container,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderItems",
|
|
value: function renderItems() {
|
|
var _this5 = this;
|
|
|
|
if (this.props.model) {
|
|
return this.props.model.map(function (menuitem, index) {
|
|
return /*#__PURE__*/React.createElement(SplitButtonItem, {
|
|
menuitem: menuitem,
|
|
key: index,
|
|
onItemClick: _this5.onItemClick
|
|
});
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this6 = this;
|
|
|
|
var className = classNames('p-splitbutton p-component', this.props.className, {
|
|
'p-disabled': this.props.disabled
|
|
});
|
|
var buttonClassName = classNames('p-splitbutton-defaultbutton', this.props.buttonClassName);
|
|
var menuButtonClassName = classNames('p-splitbutton-menubutton', this.props.menuButtonClassName);
|
|
var items = this.renderItems();
|
|
var buttonContent = this.props.buttonTemplate ? ObjectUtils.getJSXElement(this.props.buttonTemplate, this.props) : null;
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.state.id,
|
|
className: className,
|
|
style: this.props.style,
|
|
ref: function ref(el) {
|
|
return _this6.container = el;
|
|
}
|
|
}, /*#__PURE__*/React.createElement(Button, {
|
|
ref: function ref(el) {
|
|
return _this6.defaultButton = el;
|
|
},
|
|
type: "button",
|
|
className: buttonClassName,
|
|
icon: this.props.icon,
|
|
label: this.props.label,
|
|
onClick: this.props.onClick,
|
|
disabled: this.props.disabled,
|
|
tabIndex: this.props.tabIndex
|
|
}, buttonContent), /*#__PURE__*/React.createElement(Button, {
|
|
type: "button",
|
|
className: menuButtonClassName,
|
|
icon: this.props.dropdownIcon,
|
|
onClick: this.onDropdownButtonClick,
|
|
disabled: this.props.disabled,
|
|
"aria-expanded": this.state.overlayVisible,
|
|
"aria-haspopup": true,
|
|
"aria-owns": this.state.id + '_overlay'
|
|
}), /*#__PURE__*/React.createElement(SplitButtonPanel, {
|
|
ref: this.overlayRef,
|
|
appendTo: this.props.appendTo,
|
|
id: this.state.id + '_overlay',
|
|
menuStyle: this.props.menuStyle,
|
|
menuClassName: this.props.menuClassName,
|
|
onClick: this.onPanelClick,
|
|
"in": this.state.overlayVisible,
|
|
onEnter: this.onOverlayEnter,
|
|
onEntered: this.onOverlayEntered,
|
|
onExit: this.onOverlayExit,
|
|
onExited: this.onOverlayExited,
|
|
transitionOptions: this.props.transitionOptions
|
|
}, items));
|
|
}
|
|
}]);
|
|
|
|
return SplitButton;
|
|
}(Component);
|
|
|
|
_defineProperty(SplitButton, "defaultProps", {
|
|
id: null,
|
|
label: null,
|
|
icon: null,
|
|
model: null,
|
|
disabled: null,
|
|
style: null,
|
|
className: null,
|
|
buttonClassName: null,
|
|
menuStyle: null,
|
|
menuClassName: null,
|
|
menuButtonClassName: null,
|
|
tabIndex: null,
|
|
appendTo: null,
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
buttonTemplate: null,
|
|
transitionOptions: null,
|
|
dropdownIcon: 'pi pi-chevron-down',
|
|
onClick: null,
|
|
onShow: null,
|
|
onHide: null
|
|
});
|
|
|
|
function _createSuper$t(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$t(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$t() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var SplitterPanel = /*#__PURE__*/function (_Component) {
|
|
_inherits(SplitterPanel, _Component);
|
|
|
|
var _super = _createSuper$t(SplitterPanel);
|
|
|
|
function SplitterPanel() {
|
|
_classCallCheck(this, SplitterPanel);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
return _createClass(SplitterPanel);
|
|
}(Component);
|
|
|
|
_defineProperty(SplitterPanel, "defaultProps", {
|
|
size: null,
|
|
minSize: null,
|
|
style: null,
|
|
className: null
|
|
});
|
|
|
|
var Splitter = /*#__PURE__*/function (_Component2) {
|
|
_inherits(Splitter, _Component2);
|
|
|
|
var _super2 = _createSuper$t(Splitter);
|
|
|
|
function Splitter() {
|
|
_classCallCheck(this, Splitter);
|
|
|
|
return _super2.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(Splitter, [{
|
|
key: "bindMouseListeners",
|
|
value: function bindMouseListeners() {
|
|
var _this = this;
|
|
|
|
if (!this.mouseMoveListener) {
|
|
this.mouseMoveListener = function (event) {
|
|
return _this.onResize(event);
|
|
};
|
|
|
|
document.addEventListener('mousemove', this.mouseMoveListener);
|
|
}
|
|
|
|
if (!this.mouseUpListener) {
|
|
this.mouseUpListener = function (event) {
|
|
_this.onResizeEnd(event);
|
|
|
|
_this.unbindMouseListeners();
|
|
};
|
|
|
|
document.addEventListener('mouseup', this.mouseUpListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "validateResize",
|
|
value: function validateResize(newPrevPanelSize, newNextPanelSize) {
|
|
if (this.props.children[this.prevPanelIndex].props && this.props.children[this.prevPanelIndex].props.minSize && this.props.children[this.prevPanelIndex].props.minSize > newPrevPanelSize) {
|
|
return false;
|
|
}
|
|
|
|
if (this.props.children[this.prevPanelIndex + 1].props && this.props.children[this.prevPanelIndex + 1].props.minSize && this.props.children[this.prevPanelIndex + 1].props.minSize > newNextPanelSize) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}, {
|
|
key: "unbindMouseListeners",
|
|
value: function unbindMouseListeners() {
|
|
if (this.mouseMoveListener) {
|
|
document.removeEventListener('mousemove', this.mouseMoveListener);
|
|
this.mouseMoveListener = null;
|
|
}
|
|
|
|
if (this.mouseUpListener) {
|
|
document.removeEventListener('mouseup', this.mouseUpListener);
|
|
this.mouseUpListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "clear",
|
|
value: function clear() {
|
|
this.dragging = false;
|
|
this.size = null;
|
|
this.startPos = null;
|
|
this.prevPanelElement = null;
|
|
this.nextPanelElement = null;
|
|
this.prevPanelSize = null;
|
|
this.nextPanelSize = null;
|
|
this.gutterElement = null;
|
|
this.prevPanelIndex = null;
|
|
}
|
|
}, {
|
|
key: "isStateful",
|
|
value: function isStateful() {
|
|
return this.props.stateKey != null;
|
|
}
|
|
}, {
|
|
key: "getStorage",
|
|
value: function getStorage() {
|
|
switch (this.props.stateStorage) {
|
|
case 'local':
|
|
return window.localStorage;
|
|
|
|
case 'session':
|
|
return window.sessionStorage;
|
|
|
|
default:
|
|
throw new Error(this.props.stateStorage + ' is not a valid value for the state storage, supported values are "local" and "session".');
|
|
}
|
|
}
|
|
}, {
|
|
key: "saveState",
|
|
value: function saveState() {
|
|
this.getStorage().setItem(this.props.stateKey, JSON.stringify(this.panelSizes));
|
|
}
|
|
}, {
|
|
key: "restoreState",
|
|
value: function restoreState() {
|
|
var _this2 = this;
|
|
|
|
var storage = this.getStorage();
|
|
var stateString = storage.getItem(this.props.stateKey);
|
|
|
|
if (stateString) {
|
|
this.panelSizes = JSON.parse(stateString);
|
|
|
|
var children = _toConsumableArray(this.container.children).filter(function (child) {
|
|
return DomHandler.hasClass(child, 'p-splitter-panel');
|
|
});
|
|
|
|
children.forEach(function (child, i) {
|
|
child.style.flexBasis = 'calc(' + _this2.panelSizes[i] + '% - ' + (_this2.props.children.length - 1) * _this2.props.gutterSize + 'px)';
|
|
});
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "onResizeStart",
|
|
value: function onResizeStart(event, index) {
|
|
var pageX = event.type === 'touchstart' ? event.touches[0].pageX : event.pageX;
|
|
var pageY = event.type === 'touchstart' ? event.touches[0].pageY : event.pageY;
|
|
this.gutterElement = event.currentTarget;
|
|
this.size = this.props.layout === 'horizontal' ? DomHandler.getWidth(this.container) : DomHandler.getHeight(this.container);
|
|
this.dragging = true;
|
|
this.startPos = this.props.layout === 'horizontal' ? pageX : pageY;
|
|
this.prevPanelElement = this.gutterElement.previousElementSibling;
|
|
this.nextPanelElement = this.gutterElement.nextElementSibling;
|
|
this.prevPanelSize = 100 * (this.props.layout === 'horizontal' ? DomHandler.getOuterWidth(this.prevPanelElement, true) : DomHandler.getOuterHeight(this.prevPanelElement, true)) / this.size;
|
|
this.nextPanelSize = 100 * (this.props.layout === 'horizontal' ? DomHandler.getOuterWidth(this.nextPanelElement, true) : DomHandler.getOuterHeight(this.nextPanelElement, true)) / this.size;
|
|
this.prevPanelIndex = index;
|
|
DomHandler.addClass(this.gutterElement, 'p-splitter-gutter-resizing');
|
|
DomHandler.addClass(this.container, 'p-splitter-resizing');
|
|
}
|
|
}, {
|
|
key: "onResize",
|
|
value: function onResize(event) {
|
|
var newPos;
|
|
var pageX = event.type === 'touchmove' ? event.touches[0].pageX : event.pageX;
|
|
var pageY = event.type === 'touchmove' ? event.touches[0].pageY : event.pageY;
|
|
if (this.props.layout === 'horizontal') newPos = pageX * 100 / this.size - this.startPos * 100 / this.size;else newPos = pageY * 100 / this.size - this.startPos * 100 / this.size;
|
|
var newPrevPanelSize = this.prevPanelSize + newPos;
|
|
var newNextPanelSize = this.nextPanelSize - newPos;
|
|
|
|
if (this.validateResize(newPrevPanelSize, newNextPanelSize)) {
|
|
this.prevPanelElement.style.flexBasis = 'calc(' + newPrevPanelSize + '% - ' + (this.props.children.length - 1) * this.props.gutterSize + 'px)';
|
|
this.nextPanelElement.style.flexBasis = 'calc(' + newNextPanelSize + '% - ' + (this.props.children.length - 1) * this.props.gutterSize + 'px)';
|
|
this.panelSizes[this.prevPanelIndex] = newPrevPanelSize;
|
|
this.panelSizes[this.prevPanelIndex + 1] = newNextPanelSize;
|
|
}
|
|
}
|
|
}, {
|
|
key: "onResizeEnd",
|
|
value: function onResizeEnd(event) {
|
|
if (this.isStateful()) {
|
|
this.saveState();
|
|
}
|
|
|
|
if (this.props.onResizeEnd) {
|
|
this.props.onResizeEnd({
|
|
originalEvent: event,
|
|
sizes: this.panelSizes
|
|
});
|
|
}
|
|
|
|
DomHandler.removeClass(this.gutterElement, 'p-splitter-gutter-resizing');
|
|
DomHandler.removeClass(this.container, 'p-splitter-resizing');
|
|
this.clear();
|
|
}
|
|
}, {
|
|
key: "onGutterMouseDown",
|
|
value: function onGutterMouseDown(event, index) {
|
|
this.onResizeStart(event, index);
|
|
this.bindMouseListeners();
|
|
}
|
|
}, {
|
|
key: "onGutterTouchStart",
|
|
value: function onGutterTouchStart(event, index) {
|
|
this.onResizeStart(event, index);
|
|
this.windowTouchMoveListener = this.onGutterTouchMove.bind(this);
|
|
this.windowTouchEndListener = this.onGutterTouchEnd.bind(this);
|
|
window.addEventListener('touchmove', this.windowTouchMoveListener, {
|
|
passive: false,
|
|
cancelable: false
|
|
});
|
|
window.addEventListener('touchend', this.windowTouchEndListener);
|
|
}
|
|
}, {
|
|
key: "onGutterTouchMove",
|
|
value: function onGutterTouchMove(event) {
|
|
this.onResize(event);
|
|
}
|
|
}, {
|
|
key: "onGutterTouchEnd",
|
|
value: function onGutterTouchEnd(event) {
|
|
this.onResizeEnd(event);
|
|
window.removeEventListener('touchmove', this.windowTouchMoveListener);
|
|
window.removeEventListener('touchend', this.windowTouchEndListener);
|
|
this.windowTouchMoveListener = null;
|
|
this.windowTouchEndListener = null;
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
var _this3 = this;
|
|
|
|
if (this.panelElement) {
|
|
if (this.panelElement.childNodes && ObjectUtils.isNotEmpty(DomHandler.find(this.panelElement, '.p-splitter'))) {
|
|
DomHandler.addClass(this.panelElement, 'p-splitter-panel-nested');
|
|
}
|
|
}
|
|
|
|
if (this.props.children && this.props.children.length) {
|
|
var initialized = false;
|
|
|
|
if (this.isStateful()) {
|
|
initialized = this.restoreState();
|
|
}
|
|
|
|
if (!initialized) {
|
|
var children = _toConsumableArray(this.container.children).filter(function (child) {
|
|
return DomHandler.hasClass(child, 'p-splitter-panel');
|
|
});
|
|
|
|
var _panelSizes = [];
|
|
this.props.children.map(function (panel, i) {
|
|
var panelInitialSize = panel.props && panel.props.size ? panel.props.size : null;
|
|
var panelSize = panelInitialSize || 100 / _this3.props.children.length;
|
|
_panelSizes[i] = panelSize;
|
|
children[i].style.flexBasis = 'calc(' + panelSize + '% - ' + (_this3.props.children.length - 1) * _this3.props.gutterSize + 'px)';
|
|
return _panelSizes;
|
|
});
|
|
this.panelSizes = _panelSizes;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderPanel",
|
|
value: function renderPanel(panel, index) {
|
|
var _this4 = this;
|
|
|
|
var panelClassName = classNames('p-splitter-panel', panel.props.className);
|
|
var gutterStyle = this.props.layout === 'horizontal' ? {
|
|
width: this.props.gutterSize + 'px'
|
|
} : {
|
|
height: this.props.gutterSize + 'px'
|
|
};
|
|
var gutter = index !== this.props.children.length - 1 && /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this4.gutterElement = el;
|
|
},
|
|
className: 'p-splitter-gutter',
|
|
style: gutterStyle,
|
|
onMouseDown: function onMouseDown(event) {
|
|
return _this4.onGutterMouseDown(event, index);
|
|
},
|
|
onTouchStart: function onTouchStart(event) {
|
|
return _this4.onGutterTouchStart(event, index);
|
|
},
|
|
onTouchMove: function onTouchMove(event) {
|
|
return _this4.onGutterTouchMove(event);
|
|
},
|
|
onTouchEnd: function onTouchEnd(event) {
|
|
return _this4.onGutterTouchEnd(event);
|
|
}
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-splitter-gutter-handle"
|
|
}));
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this4.panelElement = el;
|
|
},
|
|
key: index,
|
|
className: panelClassName,
|
|
style: panel.props.style
|
|
}, panel.props.children), gutter);
|
|
}
|
|
}, {
|
|
key: "renderPanels",
|
|
value: function renderPanels() {
|
|
var _this5 = this;
|
|
|
|
return React.Children.map(this.props.children, function (panel, index) {
|
|
return _this5.renderPanel(panel, index);
|
|
});
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this6 = this;
|
|
|
|
var className = classNames("p-splitter p-component p-splitter-".concat(this.props.layout), this.props.className);
|
|
var panels = this.renderPanels();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this6.container = el;
|
|
},
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, panels);
|
|
}
|
|
}]);
|
|
|
|
return Splitter;
|
|
}(Component);
|
|
|
|
_defineProperty(Splitter, "defaultProps", {
|
|
id: null,
|
|
className: null,
|
|
style: null,
|
|
layout: 'horizontal',
|
|
gutterSize: 4,
|
|
stateKey: null,
|
|
stateStorage: 'session',
|
|
onResizeEnd: null
|
|
});
|
|
|
|
function _createSuper$s(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$s(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$s() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Steps = /*#__PURE__*/function (_Component) {
|
|
_inherits(Steps, _Component);
|
|
|
|
var _super = _createSuper$s(Steps);
|
|
|
|
function Steps() {
|
|
_classCallCheck(this, Steps);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(Steps, [{
|
|
key: "itemClick",
|
|
value: function itemClick(event, item, index) {
|
|
if (this.props.readOnly || item.disabled) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
if (this.props.onSelect) {
|
|
this.props.onSelect({
|
|
originalEvent: event,
|
|
item: item,
|
|
index: index
|
|
});
|
|
}
|
|
|
|
if (!item.url) {
|
|
event.preventDefault();
|
|
}
|
|
|
|
if (item.command) {
|
|
item.command({
|
|
originalEvent: event,
|
|
item: item,
|
|
index: index
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderItem",
|
|
value: function renderItem(item, index) {
|
|
var _this = this;
|
|
|
|
var active = index === this.props.activeIndex;
|
|
var disabled = item.disabled || index !== this.props.activeIndex && this.props.readOnly;
|
|
var className = classNames('p-steps-item', item.className, {
|
|
'p-highlight p-steps-current': active,
|
|
'p-disabled': disabled
|
|
});
|
|
var label = item.label && /*#__PURE__*/React.createElement("span", {
|
|
className: "p-steps-title"
|
|
}, item.label);
|
|
var tabIndex = disabled ? -1 : '';
|
|
var content = /*#__PURE__*/React.createElement("a", {
|
|
href: item.url || '#',
|
|
className: "p-menuitem-link",
|
|
role: "presentation",
|
|
target: item.target,
|
|
onClick: function onClick(event) {
|
|
return _this.itemClick(event, item, index);
|
|
},
|
|
tabIndex: tabIndex,
|
|
"aria-disabled": disabled
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-steps-number"
|
|
}, index + 1), label);
|
|
|
|
if (item.template) {
|
|
var defaultContentOptions = {
|
|
onClick: function onClick(event) {
|
|
return _this.itemClick(event, item, index);
|
|
},
|
|
className: 'p-menuitem-link',
|
|
labelClassName: 'p-steps-title',
|
|
numberClassName: 'p-steps-number',
|
|
element: content,
|
|
props: this.props,
|
|
tabIndex: tabIndex,
|
|
active: active,
|
|
disabled: disabled
|
|
};
|
|
content = ObjectUtils.getJSXElement(item.template, item, defaultContentOptions);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: item.label + '_' + index,
|
|
className: className,
|
|
style: item.style,
|
|
role: "tab",
|
|
"aria-selected": active,
|
|
"aria-expanded": active
|
|
}, content);
|
|
}
|
|
}, {
|
|
key: "renderItems",
|
|
value: function renderItems() {
|
|
var _this2 = this;
|
|
|
|
if (this.props.model) {
|
|
var items = this.props.model.map(function (item, index) {
|
|
return _this2.renderItem(item, index);
|
|
});
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
role: "tablist"
|
|
}, items);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-steps p-component', this.props.className, {
|
|
'p-readonly': this.props.readOnly
|
|
});
|
|
var items = this.renderItems();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, items);
|
|
}
|
|
}]);
|
|
|
|
return Steps;
|
|
}(Component);
|
|
|
|
_defineProperty(Steps, "defaultProps", {
|
|
id: null,
|
|
model: null,
|
|
activeIndex: 0,
|
|
readOnly: true,
|
|
style: null,
|
|
className: null,
|
|
onSelect: null
|
|
});
|
|
|
|
function _createSuper$r(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$r(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$r() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var TabMenu = /*#__PURE__*/function (_Component) {
|
|
_inherits(TabMenu, _Component);
|
|
|
|
var _super = _createSuper$r(TabMenu);
|
|
|
|
function TabMenu(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, TabMenu);
|
|
|
|
_this = _super.call(this, props);
|
|
|
|
if (!_this.props.onTabChange) {
|
|
_this.state = {
|
|
activeIndex: props.activeIndex
|
|
};
|
|
}
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(TabMenu, [{
|
|
key: "itemClick",
|
|
value: function itemClick(event, item, index) {
|
|
if (item.disabled) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
if (!item.url) {
|
|
event.preventDefault();
|
|
}
|
|
|
|
if (item.command) {
|
|
item.command({
|
|
originalEvent: event,
|
|
item: item
|
|
});
|
|
}
|
|
|
|
if (this.props.onTabChange) {
|
|
this.props.onTabChange({
|
|
originalEvent: event,
|
|
value: item,
|
|
index: index
|
|
});
|
|
} else {
|
|
this.setState({
|
|
activeIndex: index
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "getActiveIndex",
|
|
value: function getActiveIndex() {
|
|
return this.props.onTabChange ? this.props.activeIndex : this.state.activeIndex;
|
|
}
|
|
}, {
|
|
key: "isSelected",
|
|
value: function isSelected(index) {
|
|
return index === (this.getActiveIndex() || 0);
|
|
}
|
|
}, {
|
|
key: "updateInkBar",
|
|
value: function updateInkBar() {
|
|
var activeIndex = this.getActiveIndex();
|
|
var tabHeader = this["tab_".concat(activeIndex)];
|
|
this.inkbar.style.width = DomHandler.getWidth(tabHeader) + 'px';
|
|
this.inkbar.style.left = DomHandler.getOffset(tabHeader).left - DomHandler.getOffset(this.nav).left + 'px';
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.updateInkBar();
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate() {
|
|
this.updateInkBar();
|
|
}
|
|
}, {
|
|
key: "renderMenuItem",
|
|
value: function renderMenuItem(item, index) {
|
|
var _this2 = this;
|
|
|
|
var active = this.isSelected(index);
|
|
var className = classNames('p-tabmenuitem', {
|
|
'p-highlight': active,
|
|
'p-disabled': item.disabled
|
|
}, item.className);
|
|
var iconClassName = classNames('p-menuitem-icon', item.icon);
|
|
var icon = item.icon && /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
});
|
|
var label = item.label && /*#__PURE__*/React.createElement("span", {
|
|
className: "p-menuitem-text"
|
|
}, item.label);
|
|
var content = /*#__PURE__*/React.createElement("a", {
|
|
href: item.url || '#',
|
|
className: "p-menuitem-link",
|
|
target: item.target,
|
|
onClick: function onClick(event) {
|
|
return _this2.itemClick(event, item, index);
|
|
},
|
|
role: "presentation"
|
|
}, icon, label, /*#__PURE__*/React.createElement(Ripple, null));
|
|
|
|
if (item.template) {
|
|
var defaultContentOptions = {
|
|
onClick: function onClick(event) {
|
|
return _this2.itemClick(event, item);
|
|
},
|
|
className: 'p-menuitem-link',
|
|
labelClassName: 'p-menuitem-text',
|
|
iconClassName: iconClassName,
|
|
element: content,
|
|
props: this.props,
|
|
active: active,
|
|
index: index
|
|
};
|
|
content = ObjectUtils.getJSXElement(item.template, item, defaultContentOptions);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
ref: function ref(el) {
|
|
return _this2["tab_".concat(index)] = el;
|
|
},
|
|
key: item.label + '_' + index,
|
|
className: className,
|
|
style: item.style,
|
|
role: "tab",
|
|
"aria-selected": active,
|
|
"aria-expanded": active,
|
|
"aria-disabled": item.disabled
|
|
}, content);
|
|
}
|
|
}, {
|
|
key: "renderItems",
|
|
value: function renderItems() {
|
|
var _this3 = this;
|
|
|
|
return this.props.model.map(function (item, index) {
|
|
return _this3.renderMenuItem(item, index);
|
|
});
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this4 = this;
|
|
|
|
if (this.props.model) {
|
|
var className = classNames('p-tabmenu p-component', this.props.className);
|
|
var items = this.renderItems();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, /*#__PURE__*/React.createElement("ul", {
|
|
ref: function ref(el) {
|
|
return _this4.nav = el;
|
|
},
|
|
className: "p-tabmenu-nav p-reset",
|
|
role: "tablist"
|
|
}, items, /*#__PURE__*/React.createElement("li", {
|
|
ref: function ref(el) {
|
|
return _this4.inkbar = el;
|
|
},
|
|
className: "p-tabmenu-ink-bar"
|
|
})));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}]);
|
|
|
|
return TabMenu;
|
|
}(Component);
|
|
|
|
_defineProperty(TabMenu, "defaultProps", {
|
|
id: null,
|
|
model: null,
|
|
activeIndex: 0,
|
|
style: null,
|
|
className: null,
|
|
onTabChange: null
|
|
});
|
|
|
|
function ownKeys$b(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$b(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$b(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$b(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$q(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$q(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$q() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var TabPanel = /*#__PURE__*/function (_Component) {
|
|
_inherits(TabPanel, _Component);
|
|
|
|
var _super = _createSuper$q(TabPanel);
|
|
|
|
function TabPanel() {
|
|
_classCallCheck(this, TabPanel);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
return _createClass(TabPanel);
|
|
}(Component);
|
|
|
|
_defineProperty(TabPanel, "defaultProps", {
|
|
header: null,
|
|
headerTemplate: null,
|
|
leftIcon: null,
|
|
rightIcon: null,
|
|
closable: false,
|
|
disabled: false,
|
|
style: null,
|
|
className: null,
|
|
headerStyle: null,
|
|
headerClassName: null,
|
|
contentStyle: null,
|
|
contentClassName: null
|
|
});
|
|
|
|
var TabView = /*#__PURE__*/function (_Component2) {
|
|
_inherits(TabView, _Component2);
|
|
|
|
var _super2 = _createSuper$q(TabView);
|
|
|
|
function TabView(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, TabView);
|
|
|
|
_this = _super2.call(this, props);
|
|
var state = {
|
|
id: props.id,
|
|
backwardIsDisabled: true,
|
|
forwardIsDisabled: false,
|
|
hiddenTabs: []
|
|
};
|
|
|
|
if (!_this.props.onTabChange) {
|
|
state = _objectSpread$b(_objectSpread$b({}, state), {}, {
|
|
activeIndex: props.activeIndex
|
|
});
|
|
}
|
|
|
|
_this.state = state;
|
|
_this.navBackward = _this.navBackward.bind(_assertThisInitialized(_this));
|
|
_this.navForward = _this.navForward.bind(_assertThisInitialized(_this));
|
|
_this.onScroll = _this.onScroll.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(TabView, [{
|
|
key: "getActiveIndex",
|
|
value: function getActiveIndex() {
|
|
return this.props.onTabChange ? this.props.activeIndex : this.state.activeIndex;
|
|
}
|
|
}, {
|
|
key: "isSelected",
|
|
value: function isSelected(index) {
|
|
return index === this.getActiveIndex();
|
|
}
|
|
}, {
|
|
key: "shouldTabRender",
|
|
value: function shouldTabRender(tab, index) {
|
|
return tab && tab.type === TabPanel && this.state.hiddenTabs.every(function (_i) {
|
|
return _i !== index;
|
|
});
|
|
}
|
|
}, {
|
|
key: "findVisibleActiveTab",
|
|
value: function findVisibleActiveTab(i) {
|
|
var _this2 = this;
|
|
|
|
var tabsInfo = React.Children.map(this.props.children, function (tab, index) {
|
|
if (_this2.shouldTabRender(tab, index)) {
|
|
return {
|
|
tab: tab,
|
|
index: index
|
|
};
|
|
}
|
|
});
|
|
return tabsInfo.find(function (_ref) {
|
|
var tab = _ref.tab,
|
|
index = _ref.index;
|
|
return !tab.props.disabled && index >= i;
|
|
}) || tabsInfo.reverse().find(function (_ref2) {
|
|
var tab = _ref2.tab,
|
|
index = _ref2.index;
|
|
return !tab.props.disabled && i > index;
|
|
});
|
|
}
|
|
}, {
|
|
key: "onTabHeaderClose",
|
|
value: function onTabHeaderClose(event, index) {
|
|
var _this3 = this;
|
|
|
|
var hiddenTabs = [].concat(_toConsumableArray(this.state.hiddenTabs), [index]);
|
|
this.setState({
|
|
hiddenTabs: hiddenTabs
|
|
}, function () {
|
|
var tabInfo = _this3.findVisibleActiveTab(index);
|
|
|
|
tabInfo && _this3.onTabHeaderClick(event, tabInfo.tab, tabInfo.index);
|
|
});
|
|
|
|
if (this.props.onTabClose) {
|
|
this.props.onTabClose({
|
|
originalEvent: event,
|
|
index: index
|
|
});
|
|
}
|
|
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onTabHeaderClick",
|
|
value: function onTabHeaderClick(event, tab, index) {
|
|
if (!tab.props.disabled) {
|
|
if (this.props.onTabChange) {
|
|
this.props.onTabChange({
|
|
originalEvent: event,
|
|
index: index
|
|
});
|
|
} else {
|
|
this.setState({
|
|
activeIndex: index
|
|
});
|
|
}
|
|
}
|
|
|
|
this.updateScrollBar(index);
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event, tab, index) {
|
|
if (event.code === 'Enter') {
|
|
this.onTabHeaderClick(event, tab, index);
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateInkBar",
|
|
value: function updateInkBar() {
|
|
var activeIndex = this.getActiveIndex();
|
|
var tabHeader = this["tab_".concat(activeIndex)];
|
|
this.inkbar.style.width = DomHandler.getWidth(tabHeader) + 'px';
|
|
this.inkbar.style.left = DomHandler.getOffset(tabHeader).left - DomHandler.getOffset(this.nav).left + 'px';
|
|
}
|
|
}, {
|
|
key: "updateScrollBar",
|
|
value: function updateScrollBar(index) {
|
|
var tabHeader = this["tab_".concat(index)];
|
|
|
|
if (tabHeader) {
|
|
tabHeader.scrollIntoView({
|
|
block: 'nearest'
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateButtonState",
|
|
value: function updateButtonState() {
|
|
var content = this.content;
|
|
var scrollLeft = content.scrollLeft,
|
|
scrollWidth = content.scrollWidth;
|
|
var width = DomHandler.getWidth(content);
|
|
this.setState({
|
|
backwardIsDisabled: scrollLeft === 0
|
|
});
|
|
this.setState({
|
|
forwardIsDisabled: scrollLeft === scrollWidth - width
|
|
});
|
|
}
|
|
}, {
|
|
key: "onScroll",
|
|
value: function onScroll(event) {
|
|
this.props.scrollable && this.updateButtonState();
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: "getVisibleButtonWidths",
|
|
value: function getVisibleButtonWidths() {
|
|
var prevBtn = this.prevBtn;
|
|
var nextBtn = this.nextBtn;
|
|
return [prevBtn, nextBtn].reduce(function (acc, el) {
|
|
return el ? acc + DomHandler.getWidth(el) : acc;
|
|
}, 0);
|
|
}
|
|
}, {
|
|
key: "navBackward",
|
|
value: function navBackward() {
|
|
var content = this.content;
|
|
var width = DomHandler.getWidth(content) - this.getVisibleButtonWidths();
|
|
var pos = content.scrollLeft - width;
|
|
content.scrollLeft = pos <= 0 ? 0 : pos;
|
|
}
|
|
}, {
|
|
key: "navForward",
|
|
value: function navForward() {
|
|
var content = this.content;
|
|
var width = DomHandler.getWidth(content) - this.getVisibleButtonWidths();
|
|
var pos = content.scrollLeft + width;
|
|
var lastPos = content.scrollWidth - width;
|
|
content.scrollLeft = pos >= lastPos ? lastPos : pos;
|
|
}
|
|
}, {
|
|
key: "reset",
|
|
value: function reset() {
|
|
var state = {
|
|
backwardIsDisabled: true,
|
|
forwardIsDisabled: false,
|
|
hiddenTabs: []
|
|
};
|
|
|
|
if (this.props.onTabChange) {
|
|
this.props.onTabChange({
|
|
index: this.props.activeIndex
|
|
});
|
|
} else {
|
|
state = _objectSpread$b(_objectSpread$b({}, state), {}, {
|
|
activeIndex: this.props.activeIndex
|
|
});
|
|
}
|
|
|
|
this.setState(state);
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (!this.state.id) {
|
|
this.setState({
|
|
id: UniqueComponentId()
|
|
});
|
|
}
|
|
|
|
this.updateInkBar();
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
this.updateInkBar();
|
|
|
|
if (prevProps.activeIndex !== this.props.activeIndex) {
|
|
this.updateScrollBar(this.props.activeIndex);
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderTabHeader",
|
|
value: function renderTabHeader(tab, index) {
|
|
var _this4 = this;
|
|
|
|
var selected = this.isSelected(index);
|
|
|
|
var style = _objectSpread$b(_objectSpread$b({}, tab.props.headerStyle || {}), tab.props.style || {});
|
|
|
|
var className = classNames('p-unselectable-text', {
|
|
'p-tabview-selected p-highlight': selected,
|
|
'p-disabled': tab.props.disabled
|
|
}, tab.props.headerClassName, tab.props.className);
|
|
var id = this.state.id + '_header_' + index;
|
|
var ariaControls = this.state.id + '_content_' + index;
|
|
var tabIndex = tab.props.disabled ? null : 0;
|
|
var leftIconElement = tab.props.leftIcon && /*#__PURE__*/React.createElement("i", {
|
|
className: tab.props.leftIcon
|
|
});
|
|
var titleElement = /*#__PURE__*/React.createElement("span", {
|
|
className: "p-tabview-title"
|
|
}, tab.props.header);
|
|
var rightIconElement = tab.props.rightIcon && /*#__PURE__*/React.createElement("i", {
|
|
className: tab.props.rightIcon
|
|
});
|
|
var closableIconElement = tab.props.closable && /*#__PURE__*/React.createElement("i", {
|
|
className: "p-tabview-close pi pi-times",
|
|
onClick: function onClick(e) {
|
|
return _this4.onTabHeaderClose(e, index);
|
|
}
|
|
});
|
|
var content =
|
|
/*#__PURE__*/
|
|
|
|
/* eslint-disable */
|
|
React.createElement("a", {
|
|
role: "tab",
|
|
className: "p-tabview-nav-link",
|
|
onClick: function onClick(event) {
|
|
return _this4.onTabHeaderClick(event, tab, index);
|
|
},
|
|
id: id,
|
|
onKeyDown: function onKeyDown(event) {
|
|
return _this4.onKeyDown(event, tab, index);
|
|
},
|
|
"aria-controls": ariaControls,
|
|
"aria-selected": selected,
|
|
tabIndex: tabIndex
|
|
}, leftIconElement, titleElement, rightIconElement, closableIconElement, /*#__PURE__*/React.createElement(Ripple, null))
|
|
/* eslint-enable */
|
|
;
|
|
|
|
if (tab.props.headerTemplate) {
|
|
var defaultContentOptions = {
|
|
className: 'p-tabview-nav-link',
|
|
titleClassName: 'p-tabview-title',
|
|
onClick: function onClick(event) {
|
|
return _this4.onTabHeaderClick(event, tab, index);
|
|
},
|
|
onKeyDown: function onKeyDown(event) {
|
|
return _this4.onKeyDown(event, tab, index);
|
|
},
|
|
leftIconElement: leftIconElement,
|
|
titleElement: titleElement,
|
|
rightIconElement: rightIconElement,
|
|
element: content,
|
|
props: this.props,
|
|
index: index,
|
|
selected: selected,
|
|
ariaControls: ariaControls
|
|
};
|
|
content = ObjectUtils.getJSXElement(tab.props.headerTemplate, defaultContentOptions);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
ref: function ref(el) {
|
|
return _this4["tab_".concat(index)] = el;
|
|
},
|
|
className: className,
|
|
style: style,
|
|
role: "presentation"
|
|
}, content);
|
|
}
|
|
}, {
|
|
key: "renderTabHeaders",
|
|
value: function renderTabHeaders() {
|
|
var _this5 = this;
|
|
|
|
return React.Children.map(this.props.children, function (tab, index) {
|
|
if (_this5.shouldTabRender(tab, index)) {
|
|
return _this5.renderTabHeader(tab, index);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderNavigator",
|
|
value: function renderNavigator() {
|
|
var _this6 = this;
|
|
|
|
var headers = this.renderTabHeaders();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this6.content = el;
|
|
},
|
|
id: this.props.id,
|
|
className: "p-tabview-nav-content",
|
|
style: this.props.style,
|
|
onScroll: this.onScroll
|
|
}, /*#__PURE__*/React.createElement("ul", {
|
|
ref: function ref(el) {
|
|
return _this6.nav = el;
|
|
},
|
|
className: "p-tabview-nav",
|
|
role: "tablist"
|
|
}, headers, /*#__PURE__*/React.createElement("li", {
|
|
ref: function ref(el) {
|
|
return _this6.inkbar = el;
|
|
},
|
|
className: "p-tabview-ink-bar"
|
|
})));
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
var _this7 = this;
|
|
|
|
var contents = React.Children.map(this.props.children, function (tab, index) {
|
|
if (_this7.shouldTabRender(tab, index) && (!_this7.props.renderActiveOnly || _this7.isSelected(index))) {
|
|
return _this7.createContent(tab, index);
|
|
}
|
|
});
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-tabview-panels"
|
|
}, contents);
|
|
}
|
|
}, {
|
|
key: "createContent",
|
|
value: function createContent(tab, index) {
|
|
var selected = this.isSelected(index);
|
|
|
|
var style = _objectSpread$b(_objectSpread$b({}, tab.props.contentStyle || {}), tab.props.style || {});
|
|
|
|
var className = classNames(tab.props.contentClassName, tab.props.className, 'p-tabview-panel', {
|
|
'p-hidden': !selected
|
|
});
|
|
var id = this.state.id + '_content_' + index;
|
|
var ariaLabelledBy = this.state.id + '_header_' + index;
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: id,
|
|
"aria-labelledby": ariaLabelledBy,
|
|
"aria-hidden": !selected,
|
|
className: className,
|
|
style: style,
|
|
role: "tabpanel"
|
|
}, !this.props.renderActiveOnly ? tab.props.children : selected && tab.props.children);
|
|
}
|
|
}, {
|
|
key: "renderPrevButton",
|
|
value: function renderPrevButton() {
|
|
var _this8 = this;
|
|
|
|
if (this.props.scrollable && !this.state.backwardIsDisabled) {
|
|
return /*#__PURE__*/React.createElement("button", {
|
|
ref: function ref(el) {
|
|
return _this8.prevBtn = el;
|
|
},
|
|
className: "p-tabview-nav-prev p-tabview-nav-btn p-link",
|
|
onClick: this.navBackward,
|
|
type: "button"
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "pi pi-chevron-left"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderNextButton",
|
|
value: function renderNextButton() {
|
|
var _this9 = this;
|
|
|
|
if (this.props.scrollable && !this.state.forwardIsDisabled) {
|
|
return /*#__PURE__*/React.createElement("button", {
|
|
ref: function ref(el) {
|
|
return _this9.nextBtn = el;
|
|
},
|
|
className: "p-tabview-nav-next p-tabview-nav-btn p-link",
|
|
onClick: this.navForward,
|
|
type: "button"
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "pi pi-chevron-right"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-tabview p-component', this.props.className, {
|
|
'p-tabview-scrollable': this.props.scrollable
|
|
});
|
|
var navigator = this.renderNavigator();
|
|
var content = this.renderContent();
|
|
var prevButton = this.renderPrevButton();
|
|
var nextButton = this.renderNextButton();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: className
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-tabview-nav-container"
|
|
}, prevButton, navigator, nextButton), content);
|
|
}
|
|
}]);
|
|
|
|
return TabView;
|
|
}(Component);
|
|
|
|
_defineProperty(TabView, "defaultProps", {
|
|
id: null,
|
|
activeIndex: 0,
|
|
style: null,
|
|
className: null,
|
|
renderActiveOnly: true,
|
|
onTabChange: null,
|
|
onTabClose: null,
|
|
scrollable: false
|
|
});
|
|
|
|
function _createSuper$p(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$p(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$p() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Tag = /*#__PURE__*/function (_Component) {
|
|
_inherits(Tag, _Component);
|
|
|
|
var _super = _createSuper$p(Tag);
|
|
|
|
function Tag() {
|
|
_classCallCheck(this, Tag);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(Tag, [{
|
|
key: "render",
|
|
value: function render() {
|
|
var tagClassName = classNames('p-tag p-component', {
|
|
'p-tag-info': this.props.severity === 'info',
|
|
'p-tag-success': this.props.severity === 'success',
|
|
'p-tag-warning': this.props.severity === 'warning',
|
|
'p-tag-danger': this.props.severity === 'danger',
|
|
'p-tag-rounded': this.props.rounded
|
|
}, this.props.className);
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: tagClassName,
|
|
style: this.props.style
|
|
}, IconUtils.getJSXIcon(this.props.icon, {
|
|
className: 'p-tag-icon'
|
|
}, {
|
|
props: this.props
|
|
}), /*#__PURE__*/React.createElement("span", {
|
|
className: "p-tag-value"
|
|
}, this.props.value), /*#__PURE__*/React.createElement("span", null, this.props.children));
|
|
}
|
|
}]);
|
|
|
|
return Tag;
|
|
}(Component);
|
|
|
|
_defineProperty(Tag, "defaultProps", {
|
|
value: null,
|
|
severity: null,
|
|
rounded: false,
|
|
icon: null,
|
|
style: null,
|
|
className: null
|
|
});
|
|
|
|
function _createSuper$o(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$o(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$o() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var TieredMenuSub = /*#__PURE__*/function (_Component) {
|
|
_inherits(TieredMenuSub, _Component);
|
|
|
|
var _super = _createSuper$o(TieredMenuSub);
|
|
|
|
function TieredMenuSub(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, TieredMenuSub);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
activeItem: null
|
|
};
|
|
_this.onLeafClick = _this.onLeafClick.bind(_assertThisInitialized(_this));
|
|
_this.onChildItemKeyDown = _this.onChildItemKeyDown.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(TieredMenuSub, [{
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.parentActive && !this.props.parentActive) {
|
|
this.setState({
|
|
activeItem: null
|
|
});
|
|
}
|
|
|
|
if (this.props.parentActive && !this.props.root) {
|
|
this.position();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
var _this2 = this;
|
|
|
|
if (!this.documentClickListener) {
|
|
this.documentClickListener = function (event) {
|
|
if (_this2.element && !_this2.element.contains(event.target)) {
|
|
_this2.setState({
|
|
activeItem: null
|
|
});
|
|
}
|
|
};
|
|
|
|
document.addEventListener('click', this.documentClickListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.documentClickListener) {
|
|
document.removeEventListener('click', this.documentClickListener);
|
|
this.documentClickListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "position",
|
|
value: function position() {
|
|
if (this.element) {
|
|
var parentItem = this.element.parentElement;
|
|
var containerOffset = DomHandler.getOffset(parentItem);
|
|
var viewport = DomHandler.getViewport();
|
|
var sublistWidth = this.element.offsetParent ? this.element.offsetWidth : DomHandler.getHiddenElementOuterWidth(this.element);
|
|
var itemOuterWidth = DomHandler.getOuterWidth(parentItem.children[0]);
|
|
|
|
if (parseInt(containerOffset.left, 10) + itemOuterWidth + sublistWidth > viewport.width - DomHandler.calculateScrollbarWidth()) {
|
|
DomHandler.addClass(this.element, 'p-submenu-list-flipped');
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onItemMouseEnter",
|
|
value: function onItemMouseEnter(event, item) {
|
|
if (item.disabled) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
if (this.props.root) {
|
|
if (this.state.activeItem || this.props.popup) {
|
|
this.setState({
|
|
activeItem: item
|
|
});
|
|
}
|
|
} else {
|
|
this.setState({
|
|
activeItem: item
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onItemClick",
|
|
value: function onItemClick(event, item) {
|
|
if (item.disabled) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
if (!item.url) {
|
|
event.preventDefault();
|
|
}
|
|
|
|
if (item.command) {
|
|
item.command({
|
|
originalEvent: event,
|
|
item: item
|
|
});
|
|
}
|
|
|
|
if (this.props.root) {
|
|
if (item.items) {
|
|
if (this.state.activeItem && item === this.state.activeItem) {
|
|
this.setState({
|
|
activeItem: null
|
|
});
|
|
} else {
|
|
this.setState({
|
|
activeItem: item
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!item.items) {
|
|
this.onLeafClick();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onItemKeyDown",
|
|
value: function onItemKeyDown(event, item) {
|
|
var listItem = event.currentTarget.parentElement;
|
|
|
|
switch (event.which) {
|
|
//down
|
|
case 40:
|
|
var nextItem = this.findNextItem(listItem);
|
|
|
|
if (nextItem) {
|
|
nextItem.children[0].focus();
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//up
|
|
|
|
case 38:
|
|
var prevItem = this.findPrevItem(listItem);
|
|
|
|
if (prevItem) {
|
|
prevItem.children[0].focus();
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//right
|
|
|
|
case 39:
|
|
if (item.items) {
|
|
this.setState({
|
|
activeItem: item
|
|
});
|
|
setTimeout(function () {
|
|
listItem.children[1].children[0].children[0].focus();
|
|
}, 50);
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
|
|
if (this.props.onKeyDown) {
|
|
this.props.onKeyDown(event, listItem);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onChildItemKeyDown",
|
|
value: function onChildItemKeyDown(event, childListItem) {
|
|
//left
|
|
if (event.which === 37) {
|
|
this.setState({
|
|
activeItem: null
|
|
});
|
|
childListItem.parentElement.previousElementSibling.focus();
|
|
}
|
|
}
|
|
}, {
|
|
key: "findNextItem",
|
|
value: function findNextItem(item) {
|
|
var nextItem = item.nextElementSibling;
|
|
if (nextItem) return DomHandler.hasClass(nextItem, 'p-disabled') || !DomHandler.hasClass(nextItem, 'p-menuitem') ? this.findNextItem(nextItem) : nextItem;else return null;
|
|
}
|
|
}, {
|
|
key: "findPrevItem",
|
|
value: function findPrevItem(item) {
|
|
var prevItem = item.previousElementSibling;
|
|
if (prevItem) return DomHandler.hasClass(prevItem, 'p-disabled') || !DomHandler.hasClass(prevItem, 'p-menuitem') ? this.findPrevItem(prevItem) : prevItem;else return null;
|
|
}
|
|
}, {
|
|
key: "onLeafClick",
|
|
value: function onLeafClick() {
|
|
this.setState({
|
|
activeItem: null
|
|
});
|
|
|
|
if (this.props.onLeafClick) {
|
|
this.props.onLeafClick();
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderSeparator",
|
|
value: function renderSeparator(index) {
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: 'separator_' + index,
|
|
className: "p-menu-separator",
|
|
role: "separator"
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderSubmenu",
|
|
value: function renderSubmenu(item) {
|
|
if (item.items) {
|
|
return /*#__PURE__*/React.createElement(TieredMenuSub, {
|
|
model: item.items,
|
|
onLeafClick: this.onLeafClick,
|
|
popup: this.props.popup,
|
|
onKeyDown: this.onChildItemKeyDown,
|
|
parentActive: item === this.state.activeItem
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderMenuitem",
|
|
value: function renderMenuitem(item, index) {
|
|
var _this3 = this;
|
|
|
|
var active = this.state.activeItem === item;
|
|
var className = classNames('p-menuitem', {
|
|
'p-menuitem-active': active
|
|
}, item.className);
|
|
var linkClassName = classNames('p-menuitem-link', {
|
|
'p-disabled': item.disabled
|
|
});
|
|
var iconClassName = classNames('p-menuitem-icon', item.icon);
|
|
var submenuIconClassName = 'p-submenu-icon pi pi-angle-right';
|
|
var icon = item.icon && /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
});
|
|
var label = item.label && /*#__PURE__*/React.createElement("span", {
|
|
className: "p-menuitem-text"
|
|
}, item.label);
|
|
var submenuIcon = item.items && /*#__PURE__*/React.createElement("span", {
|
|
className: submenuIconClassName
|
|
});
|
|
var submenu = this.renderSubmenu(item);
|
|
var content = /*#__PURE__*/React.createElement("a", {
|
|
href: item.url || '#',
|
|
className: linkClassName,
|
|
target: item.target,
|
|
role: "menuitem",
|
|
"aria-haspopup": item.items != null,
|
|
onClick: function onClick(event) {
|
|
return _this3.onItemClick(event, item);
|
|
},
|
|
onKeyDown: function onKeyDown(event) {
|
|
return _this3.onItemKeyDown(event, item);
|
|
},
|
|
"aria-disabled": item.disabled
|
|
}, icon, label, submenuIcon, /*#__PURE__*/React.createElement(Ripple, null));
|
|
|
|
if (item.template) {
|
|
var defaultContentOptions = {
|
|
onClick: function onClick(event) {
|
|
return _this3.onItemClick(event, item);
|
|
},
|
|
onKeyDown: function onKeyDown(event) {
|
|
return _this3.onItemKeyDown(event, item);
|
|
},
|
|
className: linkClassName,
|
|
labelClassName: 'p-menuitem-text',
|
|
iconClassName: iconClassName,
|
|
submenuIconClassName: submenuIconClassName,
|
|
element: content,
|
|
props: this.props,
|
|
active: active
|
|
};
|
|
content = ObjectUtils.getJSXElement(item.template, item, defaultContentOptions);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: item.label + '_' + index,
|
|
className: className,
|
|
style: item.style,
|
|
onMouseEnter: function onMouseEnter(event) {
|
|
return _this3.onItemMouseEnter(event, item);
|
|
},
|
|
role: "none"
|
|
}, content, submenu);
|
|
}
|
|
}, {
|
|
key: "renderItem",
|
|
value: function renderItem(item, index) {
|
|
if (item.separator) return this.renderSeparator(index);else return this.renderMenuitem(item, index);
|
|
}
|
|
}, {
|
|
key: "renderMenu",
|
|
value: function renderMenu() {
|
|
var _this4 = this;
|
|
|
|
if (this.props.model) {
|
|
return this.props.model.map(function (item, index) {
|
|
return _this4.renderItem(item, index);
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this5 = this;
|
|
|
|
var className = classNames({
|
|
'p-submenu-list': !this.props.root
|
|
});
|
|
var submenu = this.renderMenu();
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
ref: function ref(el) {
|
|
return _this5.element = el;
|
|
},
|
|
className: className,
|
|
role: this.props.root ? 'menubar' : 'menu',
|
|
"aria-orientation": "horizontal"
|
|
}, submenu);
|
|
}
|
|
}]);
|
|
|
|
return TieredMenuSub;
|
|
}(Component);
|
|
|
|
_defineProperty(TieredMenuSub, "defaultProps", {
|
|
model: null,
|
|
root: false,
|
|
className: null,
|
|
popup: false,
|
|
onLeafClick: null,
|
|
onKeyDown: null,
|
|
parentActive: false
|
|
});
|
|
|
|
function _createSuper$n(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$n(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$n() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var TieredMenu = /*#__PURE__*/function (_Component) {
|
|
_inherits(TieredMenu, _Component);
|
|
|
|
var _super = _createSuper$n(TieredMenu);
|
|
|
|
function TieredMenu(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, TieredMenu);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
visible: !props.popup
|
|
};
|
|
_this.onEnter = _this.onEnter.bind(_assertThisInitialized(_this));
|
|
_this.onEntered = _this.onEntered.bind(_assertThisInitialized(_this));
|
|
_this.onExit = _this.onExit.bind(_assertThisInitialized(_this));
|
|
_this.onExited = _this.onExited.bind(_assertThisInitialized(_this));
|
|
_this.onPanelClick = _this.onPanelClick.bind(_assertThisInitialized(_this));
|
|
_this.menuRef = /*#__PURE__*/React.createRef();
|
|
return _this;
|
|
}
|
|
|
|
_createClass(TieredMenu, [{
|
|
key: "onPanelClick",
|
|
value: function onPanelClick(event) {
|
|
if (this.props.popup) {
|
|
OverlayService.emit('overlay-click', {
|
|
originalEvent: event,
|
|
target: this.target
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "toggle",
|
|
value: function toggle(event) {
|
|
if (this.props.popup) {
|
|
if (this.state.visible) this.hide(event);else this.show(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "show",
|
|
value: function show(event) {
|
|
var _this2 = this;
|
|
|
|
this.target = event.currentTarget;
|
|
var currentEvent = event;
|
|
this.setState({
|
|
visible: true
|
|
}, function () {
|
|
if (_this2.props.onShow) {
|
|
_this2.props.onShow(currentEvent);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "hide",
|
|
value: function hide(event) {
|
|
var _this3 = this;
|
|
|
|
var currentEvent = event;
|
|
this.setState({
|
|
visible: false
|
|
}, function () {
|
|
if (_this3.props.onHide) {
|
|
_this3.props.onHide(currentEvent);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "onEnter",
|
|
value: function onEnter() {
|
|
if (this.props.autoZIndex) {
|
|
ZIndexUtils.set('menu', this.menuRef.current, PrimeReact.autoZIndex, this.props.baseZIndex || PrimeReact.zIndex['menu']);
|
|
}
|
|
|
|
DomHandler.absolutePosition(this.menuRef.current, this.target);
|
|
}
|
|
}, {
|
|
key: "onEntered",
|
|
value: function onEntered() {
|
|
this.bindDocumentListeners();
|
|
this.bindScrollListener();
|
|
}
|
|
}, {
|
|
key: "onExit",
|
|
value: function onExit() {
|
|
this.target = null;
|
|
this.unbindDocumentListeners();
|
|
this.unbindScrollListener();
|
|
}
|
|
}, {
|
|
key: "onExited",
|
|
value: function onExited() {
|
|
ZIndexUtils.clear(this.menuRef.current);
|
|
}
|
|
}, {
|
|
key: "bindDocumentListeners",
|
|
value: function bindDocumentListeners() {
|
|
this.bindDocumentClickListener();
|
|
this.bindDocumentResizeListener();
|
|
}
|
|
}, {
|
|
key: "unbindDocumentListeners",
|
|
value: function unbindDocumentListeners() {
|
|
this.unbindDocumentClickListener();
|
|
this.unbindDocumentResizeListener();
|
|
}
|
|
}, {
|
|
key: "bindDocumentClickListener",
|
|
value: function bindDocumentClickListener() {
|
|
var _this4 = this;
|
|
|
|
if (!this.documentClickListener) {
|
|
this.documentClickListener = function (event) {
|
|
if (_this4.props.popup && _this4.state.visible && _this4.menuRef.current && !_this4.menuRef.current.contains(event.target)) {
|
|
_this4.hide(event);
|
|
}
|
|
};
|
|
|
|
document.addEventListener('click', this.documentClickListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentClickListener",
|
|
value: function unbindDocumentClickListener() {
|
|
if (this.documentClickListener) {
|
|
document.removeEventListener('click', this.documentClickListener);
|
|
this.documentClickListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindDocumentResizeListener",
|
|
value: function bindDocumentResizeListener() {
|
|
var _this5 = this;
|
|
|
|
if (!this.documentResizeListener) {
|
|
this.documentResizeListener = function (event) {
|
|
if (_this5.state.visible && !DomHandler.isTouchDevice()) {
|
|
_this5.hide(event);
|
|
}
|
|
};
|
|
|
|
window.addEventListener('resize', this.documentResizeListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentResizeListener",
|
|
value: function unbindDocumentResizeListener() {
|
|
if (this.documentResizeListener) {
|
|
window.removeEventListener('resize', this.documentResizeListener);
|
|
this.documentResizeListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindScrollListener",
|
|
value: function bindScrollListener() {
|
|
var _this6 = this;
|
|
|
|
if (!this.scrollHandler) {
|
|
this.scrollHandler = new ConnectedOverlayScrollHandler(this.target, function (event) {
|
|
if (_this6.state.visible) {
|
|
_this6.hide(event);
|
|
}
|
|
});
|
|
}
|
|
|
|
this.scrollHandler.bindScrollListener();
|
|
}
|
|
}, {
|
|
key: "unbindScrollListener",
|
|
value: function unbindScrollListener() {
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.unbindScrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.unbindDocumentListeners();
|
|
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.destroy();
|
|
this.scrollHandler = null;
|
|
}
|
|
|
|
ZIndexUtils.clear(this.menuRef.current);
|
|
}
|
|
}, {
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
var className = classNames('p-tieredmenu p-component', {
|
|
'p-tieredmenu-overlay': this.props.popup
|
|
}, this.props.className);
|
|
return /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.menuRef,
|
|
classNames: "p-connected-overlay",
|
|
"in": this.state.visible,
|
|
timeout: {
|
|
enter: 120,
|
|
exit: 100
|
|
},
|
|
options: this.props.transitionOptions,
|
|
unmountOnExit: true,
|
|
onEnter: this.onEnter,
|
|
onEntered: this.onEntered,
|
|
onExit: this.onExit,
|
|
onExited: this.onExited
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.menuRef,
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style,
|
|
onClick: this.onPanelClick
|
|
}, /*#__PURE__*/React.createElement(TieredMenuSub, {
|
|
model: this.props.model,
|
|
root: true,
|
|
popup: this.props.popup
|
|
})));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var element = this.renderElement();
|
|
return this.props.popup ? /*#__PURE__*/React.createElement(Portal, {
|
|
element: element,
|
|
appendTo: this.props.appendTo
|
|
}) : element;
|
|
}
|
|
}]);
|
|
|
|
return TieredMenu;
|
|
}(Component);
|
|
|
|
_defineProperty(TieredMenu, "defaultProps", {
|
|
id: null,
|
|
model: null,
|
|
popup: false,
|
|
style: null,
|
|
className: null,
|
|
autoZIndex: true,
|
|
baseZIndex: 0,
|
|
appendTo: null,
|
|
transitionOptions: null,
|
|
onShow: null,
|
|
onHide: null
|
|
});
|
|
|
|
function _createSuper$m(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$m(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$m() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Timeline = /*#__PURE__*/function (_Component) {
|
|
_inherits(Timeline, _Component);
|
|
|
|
var _super = _createSuper$m(Timeline);
|
|
|
|
function Timeline() {
|
|
_classCallCheck(this, Timeline);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(Timeline, [{
|
|
key: "getKey",
|
|
value: function getKey(item, index) {
|
|
return this.props.dataKey ? ObjectUtils.resolveFieldData(item, this.props.dataKey) : "pr_id__".concat(index);
|
|
}
|
|
}, {
|
|
key: "renderEvents",
|
|
value: function renderEvents() {
|
|
var _this = this;
|
|
|
|
return this.props.value && this.props.value.map(function (item, index) {
|
|
var opposite = ObjectUtils.getJSXElement(_this.props.opposite, item, index);
|
|
var marker = ObjectUtils.getJSXElement(_this.props.marker, item, index) || /*#__PURE__*/React.createElement("div", {
|
|
className: "p-timeline-event-marker"
|
|
});
|
|
var connector = index !== _this.props.value.length - 1 && /*#__PURE__*/React.createElement("div", {
|
|
className: "p-timeline-event-connector"
|
|
});
|
|
var content = ObjectUtils.getJSXElement(_this.props.content, item, index);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
key: _this.getKey(item, index),
|
|
className: "p-timeline-event"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-timeline-event-opposite"
|
|
}, opposite), /*#__PURE__*/React.createElement("div", {
|
|
className: "p-timeline-event-separator"
|
|
}, marker, connector), /*#__PURE__*/React.createElement("div", {
|
|
className: "p-timeline-event-content"
|
|
}, content));
|
|
});
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _classNames;
|
|
|
|
var containerClassName = classNames('p-timeline p-component', (_classNames = {}, _defineProperty(_classNames, "p-timeline-".concat(this.props.align), true), _defineProperty(_classNames, "p-timeline-".concat(this.props.layout), true), _classNames), this.props.className);
|
|
var events = this.renderEvents();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
className: containerClassName,
|
|
style: this.props.style
|
|
}, events);
|
|
}
|
|
}]);
|
|
|
|
return Timeline;
|
|
}(Component);
|
|
|
|
_defineProperty(Timeline, "defaultProps", {
|
|
id: null,
|
|
value: null,
|
|
align: 'left',
|
|
layout: 'vertical',
|
|
dataKey: null,
|
|
className: null,
|
|
style: null,
|
|
opposite: null,
|
|
marker: null,
|
|
content: null
|
|
});
|
|
|
|
function ownKeys$a(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$a(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$a(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$a(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$l(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$l(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$l() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
var ToastMessageComponent = /*#__PURE__*/function (_Component) {
|
|
_inherits(ToastMessageComponent, _Component);
|
|
|
|
var _super = _createSuper$l(ToastMessageComponent);
|
|
|
|
function ToastMessageComponent(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, ToastMessageComponent);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onClose = _this.onClose.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(ToastMessageComponent, [{
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.timeout) {
|
|
clearTimeout(this.timeout);
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
var _this2 = this;
|
|
|
|
if (!this.props.message.sticky) {
|
|
this.timeout = setTimeout(function () {
|
|
_this2.onClose(null);
|
|
}, this.props.message.life || 3000);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onClose",
|
|
value: function onClose() {
|
|
if (this.timeout) {
|
|
clearTimeout(this.timeout);
|
|
}
|
|
|
|
if (this.props.onClose) {
|
|
this.props.onClose(this.props.message);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
if (this.props.onClick && !(DomHandler.hasClass(event.target, 'p-toast-icon-close') || DomHandler.hasClass(event.target, 'p-toast-icon-close-icon'))) {
|
|
this.props.onClick(this.props.message);
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderCloseIcon",
|
|
value: function renderCloseIcon() {
|
|
if (this.props.message.closable !== false) {
|
|
return /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "p-toast-icon-close p-link",
|
|
onClick: this.onClose
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-toast-icon-close-icon pi pi-times"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderMessage",
|
|
value: function renderMessage() {
|
|
if (this.props.message) {
|
|
var _this$props$message = this.props.message,
|
|
severity = _this$props$message.severity,
|
|
content = _this$props$message.content,
|
|
summary = _this$props$message.summary,
|
|
detail = _this$props$message.detail;
|
|
var contentEl = ObjectUtils.getJSXElement(content, _objectSpread$a(_objectSpread$a({}, this.props), {}, {
|
|
onClose: this.onClose
|
|
}));
|
|
var iconClassName = classNames('p-toast-message-icon pi', {
|
|
'pi-info-circle': severity === 'info',
|
|
'pi-exclamation-triangle': severity === 'warn',
|
|
'pi-times': severity === 'error',
|
|
'pi-check': severity === 'success'
|
|
});
|
|
return contentEl || /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
}), /*#__PURE__*/React.createElement("div", {
|
|
className: "p-toast-message-text"
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-toast-summary"
|
|
}, summary), detail && /*#__PURE__*/React.createElement("div", {
|
|
className: "p-toast-detail"
|
|
}, detail)));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var severity = this.props.message.severity;
|
|
var contentClassName = this.props.message.contentClassName;
|
|
var contentStyle = this.props.message.contentStyle;
|
|
var style = this.props.message.style;
|
|
var className = classNames('p-toast-message', {
|
|
'p-toast-message-info': severity === 'info',
|
|
'p-toast-message-warn': severity === 'warn',
|
|
'p-toast-message-error': severity === 'error',
|
|
'p-toast-message-success': severity === 'success'
|
|
}, this.props.message.className);
|
|
var message = this.renderMessage();
|
|
var closeIcon = this.renderCloseIcon();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: this.props.forwardRef,
|
|
className: className,
|
|
style: style,
|
|
role: "alert",
|
|
"aria-live": "assertive",
|
|
"aria-atomic": "true",
|
|
onClick: this.onClick
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: classNames('p-toast-message-content', contentClassName),
|
|
style: contentStyle
|
|
}, message, closeIcon));
|
|
}
|
|
}]);
|
|
|
|
return ToastMessageComponent;
|
|
}(Component);
|
|
|
|
_defineProperty(ToastMessageComponent, "defaultProps", {
|
|
message: null,
|
|
onClose: null,
|
|
onClick: null
|
|
});
|
|
|
|
var ToastMessage = /*#__PURE__*/React.forwardRef(function (props, ref) {
|
|
return /*#__PURE__*/React.createElement(ToastMessageComponent, _extends({
|
|
forwardRef: ref
|
|
}, props));
|
|
});
|
|
|
|
function _createSuper$k(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$k(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$k() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var messageIdx = 0;
|
|
var Toast = /*#__PURE__*/function (_Component) {
|
|
_inherits(Toast, _Component);
|
|
|
|
var _super = _createSuper$k(Toast);
|
|
|
|
function Toast(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Toast);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
messages: []
|
|
};
|
|
_this.onClose = _this.onClose.bind(_assertThisInitialized(_this));
|
|
_this.onEntered = _this.onEntered.bind(_assertThisInitialized(_this));
|
|
_this.onExited = _this.onExited.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Toast, [{
|
|
key: "show",
|
|
value: function show(value) {
|
|
if (value) {
|
|
if (value) {
|
|
var newMessages;
|
|
|
|
if (Array.isArray(value)) {
|
|
for (var i = 0; i < value.length; i++) {
|
|
value[i].id = messageIdx++;
|
|
newMessages = [].concat(_toConsumableArray(this.state.messages), _toConsumableArray(value));
|
|
}
|
|
} else {
|
|
value.id = messageIdx++;
|
|
newMessages = this.state.messages ? [].concat(_toConsumableArray(this.state.messages), [value]) : [value];
|
|
}
|
|
|
|
this.state.messages.length === 0 && ZIndexUtils.set('toast', this.container, PrimeReact.autoZIndex, this.props.baseZIndex || PrimeReact.zIndex['toast']);
|
|
this.setState({
|
|
messages: newMessages
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "clear",
|
|
value: function clear() {
|
|
ZIndexUtils.clear(this.container);
|
|
this.setState({
|
|
messages: []
|
|
});
|
|
}
|
|
}, {
|
|
key: "onClose",
|
|
value: function onClose(message) {
|
|
var newMessages = this.state.messages.filter(function (msg) {
|
|
return msg.id !== message.id;
|
|
});
|
|
this.setState({
|
|
messages: newMessages
|
|
});
|
|
|
|
if (this.props.onRemove) {
|
|
this.props.onRemove(message);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onEntered",
|
|
value: function onEntered() {
|
|
this.props.onShow && this.props.onShow();
|
|
}
|
|
}, {
|
|
key: "onExited",
|
|
value: function onExited() {
|
|
this.state.messages.length === 0 && ZIndexUtils.clear(this.container);
|
|
this.props.onHide && this.props.onHide();
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
ZIndexUtils.clear(this.container);
|
|
}
|
|
}, {
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
var _this2 = this;
|
|
|
|
var className = classNames('p-toast p-component p-toast-' + this.props.position, this.props.className);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
_this2.container = el;
|
|
},
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, /*#__PURE__*/React.createElement(TransitionGroup, null, this.state.messages.map(function (message) {
|
|
var messageRef = /*#__PURE__*/React.createRef();
|
|
return /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: messageRef,
|
|
key: message.id,
|
|
classNames: "p-toast-message",
|
|
unmountOnExit: true,
|
|
timeout: {
|
|
enter: 300,
|
|
exit: 300
|
|
},
|
|
onEntered: _this2.onEntered,
|
|
onExited: _this2.onExited,
|
|
options: _this2.props.transitionOptions
|
|
}, /*#__PURE__*/React.createElement(ToastMessage, {
|
|
ref: messageRef,
|
|
message: message,
|
|
onClick: _this2.props.onClick,
|
|
onClose: _this2.onClose
|
|
}));
|
|
})));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var element = this.renderElement();
|
|
return /*#__PURE__*/React.createElement(Portal, {
|
|
element: element,
|
|
appendTo: this.props.appendTo
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return Toast;
|
|
}(Component);
|
|
|
|
_defineProperty(Toast, "defaultProps", {
|
|
id: null,
|
|
className: null,
|
|
style: null,
|
|
baseZIndex: 0,
|
|
position: 'top-right',
|
|
transitionOptions: null,
|
|
appendTo: 'self',
|
|
onClick: null,
|
|
onRemove: null,
|
|
onShow: null,
|
|
onHide: null
|
|
});
|
|
|
|
function ownKeys$9(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$9(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$9(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$9(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$j(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$j(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$j() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var ToggleButton = /*#__PURE__*/function (_Component) {
|
|
_inherits(ToggleButton, _Component);
|
|
|
|
var _super = _createSuper$j(ToggleButton);
|
|
|
|
function ToggleButton(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, ToggleButton);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.toggle = _this.toggle.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(ToggleButton, [{
|
|
key: "toggle",
|
|
value: function toggle(e) {
|
|
if (!this.props.disabled && this.props.onChange) {
|
|
this.props.onChange({
|
|
originalEvent: e,
|
|
value: !this.props.checked,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: !this.props.checked
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event) {
|
|
if (event.key === 'Enter') {
|
|
this.toggle(event);
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "hasLabel",
|
|
value: function hasLabel() {
|
|
return this.props.onLabel && this.props.onLabel.length > 0 && this.props.offLabel && this.props.offLabel.length > 0;
|
|
}
|
|
}, {
|
|
key: "hasIcon",
|
|
value: function hasIcon() {
|
|
return this.props.onIcon && this.props.onIcon.length > 0 && this.props.offIcon && this.props.offIcon.length > 0;
|
|
}
|
|
}, {
|
|
key: "getLabel",
|
|
value: function getLabel() {
|
|
return this.hasLabel() ? this.props.checked ? this.props.onLabel : this.props.offLabel : ' ';
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (this.props.tooltip) {
|
|
this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$9({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.container,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this2 = this;
|
|
|
|
var className = classNames('p-button p-togglebutton p-component', {
|
|
'p-button-icon-only': this.hasIcon() && !this.hasLabel(),
|
|
'p-highlight': this.props.checked,
|
|
'p-disabled': this.props.disabled
|
|
}, this.props.className),
|
|
iconClassName = null;
|
|
var hasIcon = this.hasIcon();
|
|
var label = this.getLabel();
|
|
var icon = this.props.checked ? this.props.onIcon : this.props.offIcon;
|
|
|
|
if (hasIcon) {
|
|
iconClassName = classNames('p-button-icon p-c', {
|
|
'p-button-icon-left': this.props.iconPos === 'left' && label,
|
|
'p-button-icon-right': this.props.iconPos === 'right' && label
|
|
});
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this2.container = el;
|
|
},
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style,
|
|
onClick: this.toggle,
|
|
onFocus: this.props.onFocus,
|
|
onBlur: this.props.onBlur,
|
|
onKeyDown: this.onKeyDown,
|
|
tabIndex: !this.props.disabled && this.props.tabIndex,
|
|
"aria-labelledby": this.props.ariaLabelledBy
|
|
}, hasIcon && IconUtils.getJSXIcon(icon, {
|
|
className: iconClassName
|
|
}, {
|
|
props: this.props
|
|
}), /*#__PURE__*/React.createElement("span", {
|
|
className: "p-button-label"
|
|
}, label), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
}]);
|
|
|
|
return ToggleButton;
|
|
}(Component);
|
|
|
|
_defineProperty(ToggleButton, "defaultProps", {
|
|
id: null,
|
|
onIcon: null,
|
|
offIcon: null,
|
|
onLabel: 'Yes',
|
|
offLabel: 'No',
|
|
iconPos: 'left',
|
|
style: null,
|
|
className: null,
|
|
checked: false,
|
|
tabIndex: 0,
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
ariaLabelledBy: null,
|
|
onChange: null,
|
|
onFocus: null,
|
|
onBlur: null
|
|
});
|
|
|
|
function _createSuper$i(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$i(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$i() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Toolbar = /*#__PURE__*/function (_Component) {
|
|
_inherits(Toolbar, _Component);
|
|
|
|
var _super = _createSuper$i(Toolbar);
|
|
|
|
function Toolbar() {
|
|
_classCallCheck(this, Toolbar);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(Toolbar, [{
|
|
key: "render",
|
|
value: function render() {
|
|
var toolbarClass = classNames('p-toolbar p-component', this.props.className);
|
|
var left = ObjectUtils.getJSXElement(this.props.left, this.props);
|
|
var right = ObjectUtils.getJSXElement(this.props.right, this.props);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
className: toolbarClass,
|
|
style: this.props.style,
|
|
role: "toolbar"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-toolbar-group-left"
|
|
}, left), /*#__PURE__*/React.createElement("div", {
|
|
className: "p-toolbar-group-right"
|
|
}, right));
|
|
}
|
|
}]);
|
|
|
|
return Toolbar;
|
|
}(Component);
|
|
|
|
_defineProperty(Toolbar, "defaultProps", {
|
|
id: null,
|
|
style: null,
|
|
className: null,
|
|
left: null,
|
|
right: null
|
|
});
|
|
|
|
function _createForOfIteratorHelper$6(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$6(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$6(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$6(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$6(o, minLen); }
|
|
|
|
function _arrayLikeToArray$6(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 ownKeys$8(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$8(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$8(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$8(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$h(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$h(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$h() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var UITreeNode = /*#__PURE__*/function (_Component) {
|
|
_inherits(UITreeNode, _Component);
|
|
|
|
var _super = _createSuper$h(UITreeNode);
|
|
|
|
function UITreeNode(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, UITreeNode);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onDoubleClick = _this.onDoubleClick.bind(_assertThisInitialized(_this));
|
|
_this.onRightClick = _this.onRightClick.bind(_assertThisInitialized(_this));
|
|
_this.onTouchEnd = _this.onTouchEnd.bind(_assertThisInitialized(_this));
|
|
_this.onTogglerClick = _this.onTogglerClick.bind(_assertThisInitialized(_this));
|
|
_this.onNodeKeyDown = _this.onNodeKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.propagateUp = _this.propagateUp.bind(_assertThisInitialized(_this));
|
|
_this.onDrop = _this.onDrop.bind(_assertThisInitialized(_this));
|
|
_this.onDragOver = _this.onDragOver.bind(_assertThisInitialized(_this));
|
|
_this.onDragEnter = _this.onDragEnter.bind(_assertThisInitialized(_this));
|
|
_this.onDragLeave = _this.onDragLeave.bind(_assertThisInitialized(_this));
|
|
_this.onDragStart = _this.onDragStart.bind(_assertThisInitialized(_this));
|
|
_this.onDragEnd = _this.onDragEnd.bind(_assertThisInitialized(_this));
|
|
_this.onDropPointDragOver = _this.onDropPointDragOver.bind(_assertThisInitialized(_this));
|
|
_this.onDropPointDragEnter = _this.onDropPointDragEnter.bind(_assertThisInitialized(_this));
|
|
_this.onDropPointDragLeave = _this.onDropPointDragLeave.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(UITreeNode, [{
|
|
key: "isLeaf",
|
|
value: function isLeaf() {
|
|
return this.props.isNodeLeaf(this.props.node);
|
|
}
|
|
}, {
|
|
key: "expand",
|
|
value: function expand(event) {
|
|
var expandedKeys = this.props.expandedKeys ? _objectSpread$8({}, this.props.expandedKeys) : {};
|
|
expandedKeys[this.props.node.key] = true;
|
|
this.props.onToggle({
|
|
originalEvent: event,
|
|
value: expandedKeys
|
|
});
|
|
this.invokeToggleEvents(event, true);
|
|
}
|
|
}, {
|
|
key: "collapse",
|
|
value: function collapse(event) {
|
|
var expandedKeys = _objectSpread$8({}, this.props.expandedKeys);
|
|
|
|
delete expandedKeys[this.props.node.key];
|
|
this.props.onToggle({
|
|
originalEvent: event,
|
|
value: expandedKeys
|
|
});
|
|
this.invokeToggleEvents(event, false);
|
|
}
|
|
}, {
|
|
key: "onTogglerClick",
|
|
value: function onTogglerClick(event) {
|
|
if (this.props.disabled) {
|
|
return;
|
|
}
|
|
|
|
if (this.isExpanded()) this.collapse(event);else this.expand(event);
|
|
}
|
|
}, {
|
|
key: "invokeToggleEvents",
|
|
value: function invokeToggleEvents(event, expanded) {
|
|
if (expanded) {
|
|
if (this.props.onExpand) {
|
|
this.props.onExpand({
|
|
originalEvent: event,
|
|
node: this.props.node
|
|
});
|
|
}
|
|
} else {
|
|
if (this.props.onCollapse) {
|
|
this.props.onCollapse({
|
|
originalEvent: event,
|
|
node: this.props.node
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "isExpanded",
|
|
value: function isExpanded() {
|
|
return (this.props.expandedKeys ? this.props.expandedKeys[this.props.node.key] !== undefined : false) || this.props.node.expanded;
|
|
}
|
|
}, {
|
|
key: "onNodeKeyDown",
|
|
value: function onNodeKeyDown(event) {
|
|
if (this.props.disabled) {
|
|
return;
|
|
}
|
|
|
|
var nodeElement = event.target.parentElement;
|
|
|
|
if (!DomHandler.hasClass(nodeElement, 'p-treenode')) {
|
|
return;
|
|
}
|
|
|
|
switch (event.which) {
|
|
//down arrow
|
|
case 40:
|
|
var listElement = nodeElement.children[1];
|
|
|
|
if (listElement) {
|
|
this.focusNode(listElement.children[0]);
|
|
} else {
|
|
var nextNodeElement = nodeElement.nextElementSibling;
|
|
|
|
if (nextNodeElement) {
|
|
this.focusNode(nextNodeElement);
|
|
} else {
|
|
var nextSiblingAncestor = this.findNextSiblingOfAncestor(nodeElement);
|
|
|
|
if (nextSiblingAncestor) {
|
|
this.focusNode(nextSiblingAncestor);
|
|
}
|
|
}
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//up arrow
|
|
|
|
case 38:
|
|
if (nodeElement.previousElementSibling) {
|
|
this.focusNode(this.findLastVisibleDescendant(nodeElement.previousElementSibling));
|
|
} else {
|
|
var parentNodeElement = this.getParentNodeElement(nodeElement);
|
|
|
|
if (parentNodeElement) {
|
|
this.focusNode(parentNodeElement);
|
|
}
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//right arrow
|
|
|
|
case 39:
|
|
if (!this.isExpanded()) {
|
|
this.expand(event);
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//left arrow
|
|
|
|
case 37:
|
|
if (this.isExpanded()) {
|
|
this.collapse(event);
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//enter
|
|
|
|
case 13:
|
|
this.onClick(event);
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
}
|
|
}, {
|
|
key: "findNextSiblingOfAncestor",
|
|
value: function findNextSiblingOfAncestor(nodeElement) {
|
|
var parentNodeElement = this.getParentNodeElement(nodeElement);
|
|
|
|
if (parentNodeElement) {
|
|
if (parentNodeElement.nextElementSibling) return parentNodeElement.nextElementSibling;else return this.findNextSiblingOfAncestor(parentNodeElement);
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "findLastVisibleDescendant",
|
|
value: function findLastVisibleDescendant(nodeElement) {
|
|
var childrenListElement = nodeElement.children[1];
|
|
|
|
if (childrenListElement) {
|
|
var lastChildElement = childrenListElement.children[childrenListElement.children.length - 1];
|
|
return this.findLastVisibleDescendant(lastChildElement);
|
|
} else {
|
|
return nodeElement;
|
|
}
|
|
}
|
|
}, {
|
|
key: "getParentNodeElement",
|
|
value: function getParentNodeElement(nodeElement) {
|
|
var parentNodeElement = nodeElement.parentElement.parentElement;
|
|
return DomHandler.hasClass(parentNodeElement, 'p-treenode') ? parentNodeElement : null;
|
|
}
|
|
}, {
|
|
key: "focusNode",
|
|
value: function focusNode(element) {
|
|
element.children[0].focus();
|
|
}
|
|
}, {
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
if (this.props.onClick) {
|
|
this.props.onClick({
|
|
originalEvent: event,
|
|
node: this.props.node
|
|
});
|
|
}
|
|
|
|
if (event.target.className && event.target.className.constructor === String && event.target.className.indexOf('p-tree-toggler') === 0 || this.props.disabled) {
|
|
return;
|
|
}
|
|
|
|
if (this.props.selectionMode && this.props.node.selectable !== false) {
|
|
var selectionKeys;
|
|
|
|
if (this.isCheckboxSelectionMode()) {
|
|
var checked = this.isChecked();
|
|
selectionKeys = this.props.selectionKeys ? _objectSpread$8({}, this.props.selectionKeys) : {};
|
|
|
|
if (checked) {
|
|
if (this.props.propagateSelectionDown) this.propagateDown(this.props.node, false, selectionKeys);else delete selectionKeys[this.props.node.key];
|
|
|
|
if (this.props.propagateSelectionUp && this.props.onPropagateUp) {
|
|
this.props.onPropagateUp({
|
|
originalEvent: event,
|
|
check: false,
|
|
selectionKeys: selectionKeys
|
|
});
|
|
}
|
|
|
|
if (this.props.onUnselect) {
|
|
this.props.onUnselect({
|
|
originalEvent: event,
|
|
node: this.props.node
|
|
});
|
|
}
|
|
} else {
|
|
if (this.props.propagateSelectionDown) this.propagateDown(this.props.node, true, selectionKeys);else selectionKeys[this.props.node.key] = {
|
|
checked: true
|
|
};
|
|
|
|
if (this.props.propagateSelectionUp && this.props.onPropagateUp) {
|
|
this.props.onPropagateUp({
|
|
originalEvent: event,
|
|
check: true,
|
|
selectionKeys: selectionKeys
|
|
});
|
|
}
|
|
|
|
if (this.props.onSelect) {
|
|
this.props.onSelect({
|
|
originalEvent: event,
|
|
node: this.props.node
|
|
});
|
|
}
|
|
}
|
|
} else {
|
|
var selected = this.isSelected();
|
|
var metaSelection = this.nodeTouched ? false : this.props.metaKeySelection;
|
|
|
|
if (metaSelection) {
|
|
var metaKey = event.metaKey || event.ctrlKey;
|
|
|
|
if (selected && metaKey) {
|
|
if (this.isSingleSelectionMode()) {
|
|
selectionKeys = null;
|
|
} else {
|
|
selectionKeys = _objectSpread$8({}, this.props.selectionKeys);
|
|
delete selectionKeys[this.props.node.key];
|
|
}
|
|
|
|
if (this.props.onUnselect) {
|
|
this.props.onUnselect({
|
|
originalEvent: event,
|
|
node: this.props.node
|
|
});
|
|
}
|
|
} else {
|
|
if (this.isSingleSelectionMode()) {
|
|
selectionKeys = this.props.node.key;
|
|
} else if (this.isMultipleSelectionMode()) {
|
|
selectionKeys = !metaKey ? {} : this.props.selectionKeys ? _objectSpread$8({}, this.props.selectionKeys) : {};
|
|
selectionKeys[this.props.node.key] = true;
|
|
}
|
|
|
|
if (this.props.onSelect) {
|
|
this.props.onSelect({
|
|
originalEvent: event,
|
|
node: this.props.node
|
|
});
|
|
}
|
|
}
|
|
} else {
|
|
if (this.isSingleSelectionMode()) {
|
|
if (selected) {
|
|
selectionKeys = null;
|
|
|
|
if (this.props.onUnselect) {
|
|
this.props.onUnselect({
|
|
originalEvent: event,
|
|
node: this.props.node
|
|
});
|
|
}
|
|
} else {
|
|
selectionKeys = this.props.node.key;
|
|
|
|
if (this.props.onSelect) {
|
|
this.props.onSelect({
|
|
originalEvent: event,
|
|
node: this.props.node
|
|
});
|
|
}
|
|
}
|
|
} else {
|
|
if (selected) {
|
|
selectionKeys = _objectSpread$8({}, this.props.selectionKeys);
|
|
delete selectionKeys[this.props.node.key];
|
|
|
|
if (this.props.onUnselect) {
|
|
this.props.onUnselect({
|
|
originalEvent: event,
|
|
node: this.props.node
|
|
});
|
|
}
|
|
} else {
|
|
selectionKeys = this.props.selectionKeys ? _objectSpread$8({}, this.props.selectionKeys) : {};
|
|
selectionKeys[this.props.node.key] = true;
|
|
|
|
if (this.props.onSelect) {
|
|
this.props.onSelect({
|
|
originalEvent: event,
|
|
node: this.props.node
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.props.onSelectionChange) {
|
|
this.props.onSelectionChange({
|
|
originalEvent: event,
|
|
value: selectionKeys
|
|
});
|
|
}
|
|
}
|
|
|
|
this.nodeTouched = false;
|
|
}
|
|
}, {
|
|
key: "onDoubleClick",
|
|
value: function onDoubleClick(event) {
|
|
if (this.props.onDoubleClick) {
|
|
this.props.onDoubleClick({
|
|
originalEvent: event,
|
|
node: this.props.node
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onRightClick",
|
|
value: function onRightClick(event) {
|
|
if (this.props.disabled) {
|
|
return;
|
|
}
|
|
|
|
DomHandler.clearSelection();
|
|
|
|
if (this.props.onContextMenuSelectionChange) {
|
|
this.props.onContextMenuSelectionChange({
|
|
originalEvent: event,
|
|
value: this.props.node.key
|
|
});
|
|
}
|
|
|
|
if (this.props.onContextMenu) {
|
|
this.props.onContextMenu({
|
|
originalEvent: event,
|
|
node: this.props.node
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "propagateUp",
|
|
value: function propagateUp(event) {
|
|
var check = event.check;
|
|
var selectionKeys = event.selectionKeys;
|
|
var checkedChildCount = 0;
|
|
var childPartialSelected = false;
|
|
|
|
var _iterator = _createForOfIteratorHelper$6(this.props.node.children),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var child = _step.value;
|
|
if (selectionKeys[child.key] && selectionKeys[child.key].checked) checkedChildCount++;else if (selectionKeys[child.key] && selectionKeys[child.key].partialChecked) childPartialSelected = true;
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
|
|
if (check && checkedChildCount === this.props.node.children.length) {
|
|
selectionKeys[this.props.node.key] = {
|
|
checked: true,
|
|
partialChecked: false
|
|
};
|
|
} else {
|
|
if (!check) {
|
|
delete selectionKeys[this.props.node.key];
|
|
}
|
|
|
|
if (childPartialSelected || checkedChildCount > 0 && checkedChildCount !== this.props.node.children.length) selectionKeys[this.props.node.key] = {
|
|
checked: false,
|
|
partialChecked: true
|
|
};else delete selectionKeys[this.props.node.key];
|
|
}
|
|
|
|
if (this.props.propagateSelectionUp && this.props.onPropagateUp) {
|
|
this.props.onPropagateUp(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "propagateDown",
|
|
value: function propagateDown(node, check, selectionKeys) {
|
|
if (check) selectionKeys[node.key] = {
|
|
checked: true,
|
|
partialChecked: false
|
|
};else delete selectionKeys[node.key];
|
|
|
|
if (node.children && node.children.length) {
|
|
for (var i = 0; i < node.children.length; i++) {
|
|
this.propagateDown(node.children[i], check, selectionKeys);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "isSelected",
|
|
value: function isSelected() {
|
|
if (this.props.selectionMode && this.props.selectionKeys) return this.isSingleSelectionMode() ? this.props.selectionKeys === this.props.node.key : this.props.selectionKeys[this.props.node.key] !== undefined;else return false;
|
|
}
|
|
}, {
|
|
key: "isChecked",
|
|
value: function isChecked() {
|
|
return this.props.selectionKeys ? this.props.selectionKeys[this.props.node.key] && this.props.selectionKeys[this.props.node.key].checked : false;
|
|
}
|
|
}, {
|
|
key: "isPartialChecked",
|
|
value: function isPartialChecked() {
|
|
return this.props.selectionKeys ? this.props.selectionKeys[this.props.node.key] && this.props.selectionKeys[this.props.node.key].partialChecked : false;
|
|
}
|
|
}, {
|
|
key: "isSingleSelectionMode",
|
|
value: function isSingleSelectionMode() {
|
|
return this.props.selectionMode && this.props.selectionMode === 'single';
|
|
}
|
|
}, {
|
|
key: "isMultipleSelectionMode",
|
|
value: function isMultipleSelectionMode() {
|
|
return this.props.selectionMode && this.props.selectionMode === 'multiple';
|
|
}
|
|
}, {
|
|
key: "isCheckboxSelectionMode",
|
|
value: function isCheckboxSelectionMode() {
|
|
return this.props.selectionMode && this.props.selectionMode === 'checkbox';
|
|
}
|
|
}, {
|
|
key: "onTouchEnd",
|
|
value: function onTouchEnd() {
|
|
this.nodeTouched = true;
|
|
}
|
|
}, {
|
|
key: "onDropPoint",
|
|
value: function onDropPoint(event, position) {
|
|
event.preventDefault();
|
|
|
|
if (this.props.node.droppable !== false) {
|
|
DomHandler.removeClass(event.target, 'p-treenode-droppoint-active');
|
|
|
|
if (this.props.onDropPoint) {
|
|
this.props.onDropPoint({
|
|
originalEvent: event,
|
|
path: this.props.path,
|
|
index: this.props.index,
|
|
position: position
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDropPointDragOver",
|
|
value: function onDropPointDragOver(event) {
|
|
if (event.dataTransfer.types[1] === this.props.dragdropScope.toLocaleLowerCase()) {
|
|
event.dataTransfer.dropEffect = 'move';
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDropPointDragEnter",
|
|
value: function onDropPointDragEnter(event) {
|
|
if (event.dataTransfer.types[1] === this.props.dragdropScope.toLocaleLowerCase()) {
|
|
DomHandler.addClass(event.target, 'p-treenode-droppoint-active');
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDropPointDragLeave",
|
|
value: function onDropPointDragLeave(event) {
|
|
if (event.dataTransfer.types[1] === this.props.dragdropScope.toLocaleLowerCase()) {
|
|
DomHandler.removeClass(event.target, 'p-treenode-droppoint-active');
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDrop",
|
|
value: function onDrop(event) {
|
|
if (this.props.dragdropScope && this.props.node.droppable !== false) {
|
|
DomHandler.removeClass(this.contentElement, 'p-treenode-dragover');
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
|
|
if (this.props.onDrop) {
|
|
this.props.onDrop({
|
|
originalEvent: event,
|
|
path: this.props.path,
|
|
index: this.props.index
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDragOver",
|
|
value: function onDragOver(event) {
|
|
if (event.dataTransfer.types[1] === this.props.dragdropScope.toLocaleLowerCase() && this.props.node.droppable !== false) {
|
|
event.dataTransfer.dropEffect = 'move';
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDragEnter",
|
|
value: function onDragEnter(event) {
|
|
if (event.dataTransfer.types[1] === this.props.dragdropScope.toLocaleLowerCase() && this.props.node.droppable !== false) {
|
|
DomHandler.addClass(this.contentElement, 'p-treenode-dragover');
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDragLeave",
|
|
value: function onDragLeave(event) {
|
|
if (event.dataTransfer.types[1] === this.props.dragdropScope.toLocaleLowerCase() && this.props.node.droppable !== false) {
|
|
var rect = event.currentTarget.getBoundingClientRect();
|
|
|
|
if (event.nativeEvent.x > rect.left + rect.width || event.nativeEvent.x < rect.left || event.nativeEvent.y >= Math.floor(rect.top + rect.height) || event.nativeEvent.y < rect.top) {
|
|
DomHandler.removeClass(this.contentElement, 'p-treenode-dragover');
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDragStart",
|
|
value: function onDragStart(event) {
|
|
event.dataTransfer.setData("text", this.props.dragdropScope);
|
|
event.dataTransfer.setData(this.props.dragdropScope, this.props.dragdropScope);
|
|
|
|
if (this.props.onDragStart) {
|
|
this.props.onDragStart({
|
|
originalEvent: event,
|
|
path: this.props.path,
|
|
index: this.props.index
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDragEnd",
|
|
value: function onDragEnd(event) {
|
|
if (this.props.onDragEnd) {
|
|
this.props.onDragEnd({
|
|
originalEvent: event
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderLabel",
|
|
value: function renderLabel() {
|
|
var content = /*#__PURE__*/React.createElement("span", {
|
|
className: "p-treenode-label"
|
|
}, this.props.node.label);
|
|
|
|
if (this.props.nodeTemplate) {
|
|
var defaultContentOptions = {
|
|
onTogglerClick: this.onTogglerClick,
|
|
className: 'p-treenode-label',
|
|
element: content,
|
|
props: this.props,
|
|
expanded: this.isExpanded()
|
|
};
|
|
content = ObjectUtils.getJSXElement(this.props.nodeTemplate, this.props.node, defaultContentOptions);
|
|
}
|
|
|
|
return content;
|
|
}
|
|
}, {
|
|
key: "renderCheckbox",
|
|
value: function renderCheckbox() {
|
|
if (this.isCheckboxSelectionMode() && this.props.node.selectable !== false) {
|
|
var checked = this.isChecked();
|
|
var partialChecked = this.isPartialChecked();
|
|
var className = classNames('p-checkbox-box', {
|
|
'p-highlight': checked,
|
|
'p-indeterminate': partialChecked,
|
|
'p-disabled': this.props.disabled
|
|
});
|
|
var icon = classNames('p-checkbox-icon p-c', {
|
|
'pi pi-check': checked,
|
|
'pi pi-minus': partialChecked
|
|
});
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-checkbox p-component"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: className,
|
|
role: "checkbox",
|
|
"aria-checked": checked
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: icon
|
|
})));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderIcon",
|
|
value: function renderIcon(expanded) {
|
|
var icon = this.props.node.icon || (expanded ? this.props.node.expandedIcon : this.props.node.collapsedIcon);
|
|
|
|
if (icon) {
|
|
var className = classNames('p-treenode-icon', icon);
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: className
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderToggler",
|
|
value: function renderToggler(expanded) {
|
|
var iconClassName = classNames('p-tree-toggler-icon pi pi-fw', {
|
|
'pi-chevron-right': !expanded,
|
|
'pi-chevron-down': expanded
|
|
});
|
|
var content = /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "p-tree-toggler p-link",
|
|
tabIndex: -1,
|
|
onClick: this.onTogglerClick
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
|
|
if (this.props.togglerTemplate) {
|
|
var defaultContentOptions = {
|
|
onClick: this.onTogglerClick,
|
|
containerClassName: 'p-tree-toggler p-link',
|
|
iconClassName: 'p-tree-toggler-icon',
|
|
element: content,
|
|
props: this.props,
|
|
expanded: expanded
|
|
};
|
|
content = ObjectUtils.getJSXElement(this.props.togglerTemplate, this.props.node, defaultContentOptions);
|
|
}
|
|
|
|
return content;
|
|
}
|
|
}, {
|
|
key: "renderDropPoint",
|
|
value: function renderDropPoint(position) {
|
|
var _this2 = this;
|
|
|
|
if (this.props.dragdropScope) {
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
className: "p-treenode-droppoint",
|
|
onDrop: function onDrop(event) {
|
|
return _this2.onDropPoint(event, position);
|
|
},
|
|
onDragOver: this.onDropPointDragOver,
|
|
onDragEnter: this.onDropPointDragEnter,
|
|
onDragLeave: this.onDropPointDragLeave
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
var _this3 = this;
|
|
|
|
var selected = this.isSelected();
|
|
var checked = this.isChecked();
|
|
var className = classNames('p-treenode-content', this.props.node.className, {
|
|
'p-treenode-selectable': this.props.selectionMode && this.props.node.selectable !== false,
|
|
'p-highlight': this.isCheckboxSelectionMode() ? checked : selected,
|
|
'p-highlight-contextmenu': this.props.contextMenuSelectionKey && this.props.contextMenuSelectionKey === this.props.node.key,
|
|
'p-disabled': this.props.disabled
|
|
});
|
|
var expanded = this.isExpanded();
|
|
var toggler = this.renderToggler(expanded);
|
|
var checkbox = this.renderCheckbox();
|
|
var icon = this.renderIcon(expanded);
|
|
var label = this.renderLabel();
|
|
var tabIndex = this.props.disabled ? undefined : 0;
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this3.contentElement = el;
|
|
},
|
|
className: className,
|
|
style: this.props.node.style,
|
|
onClick: this.onClick,
|
|
onDoubleClick: this.onDoubleClick,
|
|
onContextMenu: this.onRightClick,
|
|
onTouchEnd: this.onTouchEnd,
|
|
draggable: this.props.dragdropScope && this.props.node.draggable !== false && !this.props.disabled,
|
|
onDrop: this.onDrop,
|
|
onDragOver: this.onDragOver,
|
|
onDragEnter: this.onDragEnter,
|
|
onDragLeave: this.onDragLeave,
|
|
onDragStart: this.onDragStart,
|
|
onDragEnd: this.onDragEnd,
|
|
tabIndex: tabIndex,
|
|
onKeyDown: this.onNodeKeyDown,
|
|
role: "treeitem",
|
|
"aria-posinset": this.props.index + 1,
|
|
"aria-expanded": this.isExpanded(),
|
|
"aria-selected": checked || selected
|
|
}, toggler, checkbox, icon, label);
|
|
}
|
|
}, {
|
|
key: "renderChildren",
|
|
value: function renderChildren() {
|
|
var _this4 = this;
|
|
|
|
if (this.props.node.children && this.props.node.children.length && this.isExpanded()) {
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
className: "p-treenode-children",
|
|
role: "group"
|
|
}, this.props.node.children.map(function (childNode, index) {
|
|
return /*#__PURE__*/React.createElement(UITreeNode, {
|
|
key: childNode.key || childNode.label,
|
|
node: childNode,
|
|
parent: _this4.props.node,
|
|
index: index,
|
|
last: index === _this4.props.node.children.length - 1,
|
|
path: _this4.props.path + '-' + index,
|
|
disabled: _this4.props.disabled,
|
|
selectionMode: _this4.props.selectionMode,
|
|
selectionKeys: _this4.props.selectionKeys,
|
|
onSelectionChange: _this4.props.onSelectionChange,
|
|
metaKeySelection: _this4.props.metaKeySelection,
|
|
propagateSelectionDown: _this4.props.propagateSelectionDown,
|
|
propagateSelectionUp: _this4.props.propagateSelectionUp,
|
|
contextMenuSelectionKey: _this4.props.contextMenuSelectionKey,
|
|
onContextMenuSelectionChange: _this4.props.onContextMenuSelectionChange,
|
|
onContextMenu: _this4.props.onContextMenu,
|
|
onExpand: _this4.props.onExpand,
|
|
onCollapse: _this4.props.onCollapse,
|
|
onSelect: _this4.props.onSelect,
|
|
onUnselect: _this4.props.onUnselect,
|
|
expandedKeys: _this4.props.expandedKeys,
|
|
onToggle: _this4.props.onToggle,
|
|
onPropagateUp: _this4.propagateUp,
|
|
nodeTemplate: _this4.props.nodeTemplate,
|
|
togglerTemplate: _this4.props.togglerTemplate,
|
|
isNodeLeaf: _this4.props.isNodeLeaf,
|
|
dragdropScope: _this4.props.dragdropScope,
|
|
onDragStart: _this4.props.onDragStart,
|
|
onDragEnd: _this4.props.onDragEnd,
|
|
onDrop: _this4.props.onDrop,
|
|
onDropPoint: _this4.props.onDropPoint
|
|
});
|
|
}));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderNode",
|
|
value: function renderNode() {
|
|
var className = classNames('p-treenode', {
|
|
'p-treenode-leaf': this.isLeaf()
|
|
}, this.props.node.className);
|
|
var content = this.renderContent();
|
|
var children = this.renderChildren();
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
className: className,
|
|
style: this.props.node.style
|
|
}, content, children);
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var node = this.renderNode();
|
|
|
|
if (this.props.dragdropScope && !this.props.disabled) {
|
|
var beforeDropPoint = this.renderDropPoint(-1);
|
|
var afterDropPoint = this.props.last ? this.renderDropPoint(1) : null;
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, beforeDropPoint, node, afterDropPoint);
|
|
} else {
|
|
return node;
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return UITreeNode;
|
|
}(Component);
|
|
|
|
_defineProperty(UITreeNode, "defaultProps", {
|
|
node: null,
|
|
index: null,
|
|
last: null,
|
|
parent: null,
|
|
path: null,
|
|
disabled: false,
|
|
selectionMode: null,
|
|
selectionKeys: null,
|
|
contextMenuSelectionKey: null,
|
|
metaKeySelection: true,
|
|
expandedKeys: null,
|
|
propagateSelectionUp: true,
|
|
propagateSelectionDown: true,
|
|
dragdropScope: null,
|
|
ariaLabel: null,
|
|
ariaLabelledBy: null,
|
|
nodeTemplate: null,
|
|
togglerTemplate: null,
|
|
isNodeLeaf: null,
|
|
onSelect: null,
|
|
onUnselect: null,
|
|
onExpand: null,
|
|
onCollapse: null,
|
|
onToggle: null,
|
|
onSelectionChange: null,
|
|
onContextMenuSelectionChange: null,
|
|
onPropagateUp: null,
|
|
onDragStart: null,
|
|
onDragEnd: null,
|
|
onDrop: null,
|
|
onDropPoint: null,
|
|
onContextMenu: null,
|
|
onNodeClick: null,
|
|
onNodeDoubleClick: null
|
|
});
|
|
|
|
function ownKeys$7(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$7(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$7(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$7(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createForOfIteratorHelper$5(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$5(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$5(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$5(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$5(o, minLen); }
|
|
|
|
function _arrayLikeToArray$5(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 _createSuper$g(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$g(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$g() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Tree = /*#__PURE__*/function (_Component) {
|
|
_inherits(Tree, _Component);
|
|
|
|
var _super = _createSuper$g(Tree);
|
|
|
|
function Tree(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Tree);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {};
|
|
|
|
if (!_this.props.onFilterValueChange) {
|
|
_this.state['filterValue'] = '';
|
|
}
|
|
|
|
if (!_this.props.onToggle) {
|
|
_this.state['expandedKeys'] = _this.props.expandedKeys;
|
|
}
|
|
|
|
_this.isNodeLeaf = _this.isNodeLeaf.bind(_assertThisInitialized(_this));
|
|
_this.onToggle = _this.onToggle.bind(_assertThisInitialized(_this));
|
|
_this.onDragStart = _this.onDragStart.bind(_assertThisInitialized(_this));
|
|
_this.onDragEnd = _this.onDragEnd.bind(_assertThisInitialized(_this));
|
|
_this.onDrop = _this.onDrop.bind(_assertThisInitialized(_this));
|
|
_this.onDropPoint = _this.onDropPoint.bind(_assertThisInitialized(_this));
|
|
_this.onFilterInputChange = _this.onFilterInputChange.bind(_assertThisInitialized(_this));
|
|
_this.onFilterInputKeyDown = _this.onFilterInputKeyDown.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Tree, [{
|
|
key: "getFilterValue",
|
|
value: function getFilterValue() {
|
|
return this.props.onFilterValueChange ? this.props.filterValue : this.state.filterValue;
|
|
}
|
|
}, {
|
|
key: "getExpandedKeys",
|
|
value: function getExpandedKeys() {
|
|
return this.props.onToggle ? this.props.expandedKeys : this.state.expandedKeys;
|
|
}
|
|
}, {
|
|
key: "getRootNode",
|
|
value: function getRootNode() {
|
|
return this.props.filter && this.filteredNodes ? this.filteredNodes : this.props.value;
|
|
}
|
|
}, {
|
|
key: "onToggle",
|
|
value: function onToggle(event) {
|
|
if (this.props.onToggle) {
|
|
this.props.onToggle(event);
|
|
} else {
|
|
this.setState({
|
|
expandedKeys: event.value
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDragStart",
|
|
value: function onDragStart(event) {
|
|
this.dragState = {
|
|
path: event.path,
|
|
index: event.index
|
|
};
|
|
}
|
|
}, {
|
|
key: "onDragEnd",
|
|
value: function onDragEnd() {
|
|
this.dragState = null;
|
|
}
|
|
}, {
|
|
key: "onDrop",
|
|
value: function onDrop(event) {
|
|
if (this.validateDropNode(this.dragState.path, event.path)) {
|
|
var value = JSON.parse(JSON.stringify(this.props.value));
|
|
var dragPaths = this.dragState.path.split('-');
|
|
dragPaths.pop();
|
|
var dragNodeParent = this.findNode(value, dragPaths);
|
|
var dragNode = dragNodeParent ? dragNodeParent.children[this.dragState.index] : value[this.dragState.index];
|
|
var dropNode = this.findNode(value, event.path.split('-'));
|
|
if (dropNode.children) dropNode.children.push(dragNode);else dropNode.children = [dragNode];
|
|
if (dragNodeParent) dragNodeParent.children.splice(this.dragState.index, 1);else value.splice(this.dragState.index, 1);
|
|
|
|
if (this.props.onDragDrop) {
|
|
this.props.onDragDrop({
|
|
originalEvent: event.originalEvent,
|
|
value: value,
|
|
dragNode: dragNode,
|
|
dropNode: dropNode,
|
|
dropIndex: event.index
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDropPoint",
|
|
value: function onDropPoint(event) {
|
|
if (this.validateDropPoint(event)) {
|
|
var value = JSON.parse(JSON.stringify(this.props.value));
|
|
var dragPaths = this.dragState.path.split('-');
|
|
dragPaths.pop();
|
|
var dropPaths = event.path.split('-');
|
|
dropPaths.pop();
|
|
var dragNodeParent = this.findNode(value, dragPaths);
|
|
var dropNodeParent = this.findNode(value, dropPaths);
|
|
var dragNode = dragNodeParent ? dragNodeParent.children[this.dragState.index] : value[this.dragState.index];
|
|
var siblings = this.areSiblings(this.dragState.path, event.path);
|
|
if (dragNodeParent) dragNodeParent.children.splice(this.dragState.index, 1);else value.splice(this.dragState.index, 1);
|
|
|
|
if (event.position < 0) {
|
|
var dropIndex = siblings ? this.dragState.index > event.index ? event.index : event.index - 1 : event.index;
|
|
if (dropNodeParent) dropNodeParent.children.splice(dropIndex, 0, dragNode);else value.splice(dropIndex, 0, dragNode);
|
|
} else {
|
|
if (dropNodeParent) dropNodeParent.children.push(dragNode);else value.push(dragNode);
|
|
}
|
|
|
|
if (this.props.onDragDrop) {
|
|
this.props.onDragDrop({
|
|
originalEvent: event.originalEvent,
|
|
value: value,
|
|
dragNode: dragNode,
|
|
dropNode: dropNodeParent,
|
|
dropIndex: event.index
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "validateDrop",
|
|
value: function validateDrop(dragPath, dropPath) {
|
|
if (!dragPath) {
|
|
return false;
|
|
} else {
|
|
//same node
|
|
if (dragPath === dropPath) {
|
|
return false;
|
|
} //parent dropped on an descendant
|
|
|
|
|
|
if (dropPath.indexOf(dragPath) === 0) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
}, {
|
|
key: "validateDropNode",
|
|
value: function validateDropNode(dragPath, dropPath) {
|
|
var validateDrop = this.validateDrop(dragPath, dropPath);
|
|
|
|
if (validateDrop) {
|
|
//child dropped on parent
|
|
if (dragPath.indexOf('-') > 0 && dragPath.substring(0, dragPath.lastIndexOf('-')) === dropPath) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}, {
|
|
key: "validateDropPoint",
|
|
value: function validateDropPoint(event) {
|
|
var validateDrop = this.validateDrop(this.dragState.path, event.path);
|
|
|
|
if (validateDrop) {
|
|
//child dropped to next sibling's drop point
|
|
if (event.position === -1 && this.areSiblings(this.dragState.path, event.path) && this.dragState.index + 1 === event.index) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}, {
|
|
key: "areSiblings",
|
|
value: function areSiblings(path1, path2) {
|
|
if (path1.length === 1 && path2.length === 1) return true;else return path1.substring(0, path1.lastIndexOf('-')) === path2.substring(0, path2.lastIndexOf('-'));
|
|
}
|
|
}, {
|
|
key: "findNode",
|
|
value: function findNode(value, path) {
|
|
if (path.length === 0) {
|
|
return null;
|
|
} else {
|
|
var index = parseInt(path[0], 10);
|
|
var nextSearchRoot = value.children ? value.children[index] : value[index];
|
|
|
|
if (path.length === 1) {
|
|
return nextSearchRoot;
|
|
} else {
|
|
path.shift();
|
|
return this.findNode(nextSearchRoot, path);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "isNodeLeaf",
|
|
value: function isNodeLeaf(node) {
|
|
return node.leaf === false ? false : !(node.children && node.children.length);
|
|
}
|
|
}, {
|
|
key: "onFilterInputKeyDown",
|
|
value: function onFilterInputKeyDown(event) {
|
|
//enter
|
|
if (event.which === 13) {
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onFilterInputChange",
|
|
value: function onFilterInputChange(event) {
|
|
this.filterChanged = true;
|
|
var filterValue = event.target.value;
|
|
|
|
if (this.props.onFilterValueChange) {
|
|
this.props.onFilterValueChange({
|
|
originalEvent: event,
|
|
value: filterValue
|
|
});
|
|
} else {
|
|
this.setState({
|
|
filterValue: filterValue
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "filter",
|
|
value: function filter(value) {
|
|
this.setState({
|
|
filterValue: ObjectUtils.isNotEmpty(value) ? value : ''
|
|
}, this._filter);
|
|
}
|
|
}, {
|
|
key: "_filter",
|
|
value: function _filter() {
|
|
if (!this.filterChanged) {
|
|
return;
|
|
}
|
|
|
|
var filterValue = this.getFilterValue();
|
|
|
|
if (ObjectUtils.isEmpty(filterValue)) {
|
|
this.filteredNodes = this.props.value;
|
|
} else {
|
|
this.filteredNodes = [];
|
|
var searchFields = this.props.filterBy.split(',');
|
|
var filterText = filterValue.toLocaleLowerCase(this.props.filterLocale);
|
|
var isStrictMode = this.props.filterMode === 'strict';
|
|
|
|
var _iterator = _createForOfIteratorHelper$5(this.props.value),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var node = _step.value;
|
|
|
|
var copyNode = _objectSpread$7({}, node);
|
|
|
|
var paramsWithoutNode = {
|
|
searchFields: searchFields,
|
|
filterText: filterText,
|
|
isStrictMode: isStrictMode
|
|
};
|
|
|
|
if (isStrictMode && (this.findFilteredNodes(copyNode, paramsWithoutNode) || this.isFilterMatched(copyNode, paramsWithoutNode)) || !isStrictMode && (this.isFilterMatched(copyNode, paramsWithoutNode) || this.findFilteredNodes(copyNode, paramsWithoutNode))) {
|
|
this.filteredNodes.push(copyNode);
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
}
|
|
|
|
this.filterChanged = false;
|
|
}
|
|
}, {
|
|
key: "findFilteredNodes",
|
|
value: function findFilteredNodes(node, paramsWithoutNode) {
|
|
if (node) {
|
|
var matched = false;
|
|
|
|
if (node.children) {
|
|
var childNodes = _toConsumableArray(node.children);
|
|
|
|
node.children = [];
|
|
|
|
var _iterator2 = _createForOfIteratorHelper$5(childNodes),
|
|
_step2;
|
|
|
|
try {
|
|
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
|
|
var childNode = _step2.value;
|
|
|
|
var copyChildNode = _objectSpread$7({}, childNode);
|
|
|
|
if (this.isFilterMatched(copyChildNode, paramsWithoutNode)) {
|
|
matched = true;
|
|
node.children.push(copyChildNode);
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator2.e(err);
|
|
} finally {
|
|
_iterator2.f();
|
|
}
|
|
}
|
|
|
|
if (matched) {
|
|
node.expanded = true;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "isFilterMatched",
|
|
value: function isFilterMatched(node, _ref) {
|
|
var searchFields = _ref.searchFields,
|
|
filterText = _ref.filterText,
|
|
isStrictMode = _ref.isStrictMode;
|
|
var matched = false;
|
|
|
|
var _iterator3 = _createForOfIteratorHelper$5(searchFields),
|
|
_step3;
|
|
|
|
try {
|
|
for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
|
|
var field = _step3.value;
|
|
var fieldValue = String(ObjectUtils.resolveFieldData(node, field)).toLocaleLowerCase(this.props.filterLocale);
|
|
|
|
if (fieldValue.indexOf(filterText) > -1) {
|
|
matched = true;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator3.e(err);
|
|
} finally {
|
|
_iterator3.f();
|
|
}
|
|
|
|
if (!matched || isStrictMode && !this.isNodeLeaf(node)) {
|
|
matched = this.findFilteredNodes(node, {
|
|
searchFields: searchFields,
|
|
filterText: filterText,
|
|
isStrictMode: isStrictMode
|
|
}) || matched;
|
|
}
|
|
|
|
return matched;
|
|
}
|
|
}, {
|
|
key: "renderRootChild",
|
|
value: function renderRootChild(node, index, last) {
|
|
return /*#__PURE__*/React.createElement(UITreeNode, {
|
|
key: node.key || node.label,
|
|
node: node,
|
|
index: index,
|
|
last: last,
|
|
path: String(index),
|
|
disabled: this.props.disabled,
|
|
selectionMode: this.props.selectionMode,
|
|
selectionKeys: this.props.selectionKeys,
|
|
onSelectionChange: this.props.onSelectionChange,
|
|
metaKeySelection: this.props.metaKeySelection,
|
|
contextMenuSelectionKey: this.props.contextMenuSelectionKey,
|
|
onContextMenuSelectionChange: this.props.onContextMenuSelectionChange,
|
|
onContextMenu: this.props.onContextMenu,
|
|
propagateSelectionDown: this.props.propagateSelectionDown,
|
|
propagateSelectionUp: this.props.propagateSelectionUp,
|
|
onExpand: this.props.onExpand,
|
|
onCollapse: this.props.onCollapse,
|
|
onSelect: this.props.onSelect,
|
|
onUnselect: this.props.onUnselect,
|
|
expandedKeys: this.getExpandedKeys(),
|
|
onToggle: this.onToggle,
|
|
nodeTemplate: this.props.nodeTemplate,
|
|
togglerTemplate: this.props.togglerTemplate,
|
|
isNodeLeaf: this.isNodeLeaf,
|
|
dragdropScope: this.props.dragdropScope,
|
|
onDragStart: this.onDragStart,
|
|
onDragEnd: this.onDragEnd,
|
|
onDrop: this.onDrop,
|
|
onDropPoint: this.onDropPoint,
|
|
onNodeClick: this.props.onNodeClick,
|
|
onNodeDoubleClick: this.props.onNodeDoubleClick
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderRootChildren",
|
|
value: function renderRootChildren() {
|
|
var _this2 = this;
|
|
|
|
if (this.props.filter) {
|
|
this.filterChanged = true;
|
|
|
|
this._filter();
|
|
}
|
|
|
|
var value = this.getRootNode();
|
|
return value.map(function (node, index) {
|
|
return _this2.renderRootChild(node, index, index === value.length - 1);
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderModel",
|
|
value: function renderModel() {
|
|
if (this.props.value) {
|
|
var rootNodes = this.renderRootChildren();
|
|
var contentClass = classNames('p-tree-container', this.props.contentClassName);
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
className: contentClass,
|
|
role: "tree",
|
|
"aria-label": this.props.ariaLabel,
|
|
"aria-labelledby": this.props.ariaLabelledBy,
|
|
style: this.props.contentStyle
|
|
}, rootNodes);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderLoader",
|
|
value: function renderLoader() {
|
|
if (this.props.loading) {
|
|
var icon = classNames('p-tree-loading-icon pi-spin', this.props.loadingIcon);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-tree-loading-overlay p-component-overlay"
|
|
}, /*#__PURE__*/React.createElement("i", {
|
|
className: icon
|
|
}));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderFilter",
|
|
value: function renderFilter() {
|
|
if (this.props.filter) {
|
|
var filterValue = this.getFilterValue();
|
|
filterValue = ObjectUtils.isNotEmpty(filterValue) ? filterValue : '';
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-tree-filter-container"
|
|
}, /*#__PURE__*/React.createElement("input", {
|
|
type: "text",
|
|
value: filterValue,
|
|
autoComplete: "off",
|
|
className: "p-tree-filter p-inputtext p-component",
|
|
placeholder: this.props.filterPlaceholder,
|
|
onKeyDown: this.onFilterInputKeyDown,
|
|
onChange: this.onFilterInputChange,
|
|
disabled: this.props.disabled
|
|
}), /*#__PURE__*/React.createElement("span", {
|
|
className: "p-tree-filter-icon pi pi-search"
|
|
}));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderHeader",
|
|
value: function renderHeader() {
|
|
if (this.props.showHeader) {
|
|
var filterElement = this.renderFilter();
|
|
var content = filterElement;
|
|
|
|
if (this.props.header) {
|
|
var defaultContentOptions = {
|
|
filterContainerClassName: 'p-tree-filter-container',
|
|
filterIconClasssName: 'p-tree-filter-icon pi pi-search',
|
|
filterInput: {
|
|
className: 'p-tree-filter p-inputtext p-component',
|
|
onKeyDown: this.onFilterInputKeyDown,
|
|
onChange: this.onFilterInputChange
|
|
},
|
|
filterElement: filterElement,
|
|
element: content,
|
|
props: this.props
|
|
};
|
|
content = ObjectUtils.getJSXElement(this.props.header, defaultContentOptions);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-tree-header"
|
|
}, content);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderFooter",
|
|
value: function renderFooter() {
|
|
var content = ObjectUtils.getJSXElement(this.props.footer, this.props);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-tree-footer"
|
|
}, content);
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames('p-tree p-component', this.props.className, {
|
|
'p-tree-selectable': this.props.selectionMode,
|
|
'p-tree-loading': this.props.loading,
|
|
'p-disabled': this.props.disabled
|
|
});
|
|
var loader = this.renderLoader();
|
|
var content = this.renderModel();
|
|
var header = this.renderHeader();
|
|
var footer = this.renderFooter();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, loader, header, content, footer);
|
|
}
|
|
}]);
|
|
|
|
return Tree;
|
|
}(Component);
|
|
|
|
_defineProperty(Tree, "defaultProps", {
|
|
id: null,
|
|
value: null,
|
|
disabled: false,
|
|
selectionMode: null,
|
|
selectionKeys: null,
|
|
onSelectionChange: null,
|
|
contextMenuSelectionKey: null,
|
|
onContextMenuSelectionChange: null,
|
|
expandedKeys: null,
|
|
style: null,
|
|
className: null,
|
|
contentStyle: null,
|
|
contentClassName: null,
|
|
metaKeySelection: true,
|
|
propagateSelectionUp: true,
|
|
propagateSelectionDown: true,
|
|
loading: false,
|
|
loadingIcon: 'pi pi-spinner',
|
|
dragdropScope: null,
|
|
header: null,
|
|
footer: null,
|
|
showHeader: true,
|
|
filter: false,
|
|
filterValue: null,
|
|
filterBy: 'label',
|
|
filterMode: 'lenient',
|
|
filterPlaceholder: null,
|
|
filterLocale: undefined,
|
|
nodeTemplate: null,
|
|
togglerTemplate: null,
|
|
onSelect: null,
|
|
onUnselect: null,
|
|
onExpand: null,
|
|
onCollapse: null,
|
|
onToggle: null,
|
|
onDragDrop: null,
|
|
onContextMenu: null,
|
|
onFilterValueChange: null,
|
|
onNodeClick: null,
|
|
onNodeDoubleClick: null
|
|
});
|
|
|
|
function _createSuper$f(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$f(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$f() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
var TreeSelectPanelComponent = /*#__PURE__*/function (_Component) {
|
|
_inherits(TreeSelectPanelComponent, _Component);
|
|
|
|
var _super = _createSuper$f(TreeSelectPanelComponent);
|
|
|
|
function TreeSelectPanelComponent() {
|
|
_classCallCheck(this, TreeSelectPanelComponent);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(TreeSelectPanelComponent, [{
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
var className = classNames('p-treeselect-panel p-component', this.props.panelClassName);
|
|
return /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.props.forwardRef,
|
|
classNames: "p-connected-overlay",
|
|
"in": this.props["in"],
|
|
timeout: {
|
|
enter: 120,
|
|
exit: 100
|
|
},
|
|
options: this.props.transitionOptions,
|
|
unmountOnExit: true,
|
|
onEnter: this.props.onEnter,
|
|
onEntering: this.props.onEntering,
|
|
onEntered: this.props.onEntered,
|
|
onExit: this.props.onExit,
|
|
onExited: this.props.onExited
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.props.forwardRef,
|
|
className: className,
|
|
style: this.props.panelStyle,
|
|
onClick: this.props.onClick
|
|
}, this.props.header, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-treeselect-items-wrapper",
|
|
style: {
|
|
maxHeight: this.props.scrollHeight || 'auto'
|
|
}
|
|
}, this.props.children), this.props.footer));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var element = this.renderElement();
|
|
return /*#__PURE__*/React.createElement(Portal, {
|
|
element: element,
|
|
appendTo: this.props.appendTo
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return TreeSelectPanelComponent;
|
|
}(Component);
|
|
|
|
var TreeSelectPanel = /*#__PURE__*/React.forwardRef(function (props, ref) {
|
|
return /*#__PURE__*/React.createElement(TreeSelectPanelComponent, _extends({
|
|
forwardRef: ref
|
|
}, props));
|
|
});
|
|
|
|
function _createForOfIteratorHelper$4(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$4(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$4(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$4(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$4(o, minLen); }
|
|
|
|
function _arrayLikeToArray$4(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 ownKeys$6(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$6(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$6(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$6(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$e(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$e(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$e() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var TreeSelect = /*#__PURE__*/function (_Component) {
|
|
_inherits(TreeSelect, _Component);
|
|
|
|
var _super = _createSuper$e(TreeSelect);
|
|
|
|
function TreeSelect(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, TreeSelect);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
focused: false,
|
|
overlayVisible: false,
|
|
expandedKeys: {}
|
|
};
|
|
|
|
if (!_this.props.onFilterValueChange) {
|
|
_this.state['filterValue'] = '';
|
|
}
|
|
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onInputFocus = _this.onInputFocus.bind(_assertThisInitialized(_this));
|
|
_this.onInputBlur = _this.onInputBlur.bind(_assertThisInitialized(_this));
|
|
_this.onInputKeyDown = _this.onInputKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onFilterInputChange = _this.onFilterInputChange.bind(_assertThisInitialized(_this));
|
|
_this.onFilterInputKeyDown = _this.onFilterInputKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayClick = _this.onOverlayClick.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEnter = _this.onOverlayEnter.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEntered = _this.onOverlayEntered.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExit = _this.onOverlayExit.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExited = _this.onOverlayExited.bind(_assertThisInitialized(_this));
|
|
_this.onSelectionChange = _this.onSelectionChange.bind(_assertThisInitialized(_this));
|
|
_this.onNodeSelect = _this.onNodeSelect.bind(_assertThisInitialized(_this));
|
|
_this.onNodeUnselect = _this.onNodeUnselect.bind(_assertThisInitialized(_this));
|
|
_this.onNodeToggle = _this.onNodeToggle.bind(_assertThisInitialized(_this));
|
|
_this.onFilterValueChange = _this.onFilterValueChange.bind(_assertThisInitialized(_this));
|
|
_this.hide = _this.hide.bind(_assertThisInitialized(_this));
|
|
_this.show = _this.show.bind(_assertThisInitialized(_this));
|
|
_this.overlayRef = /*#__PURE__*/createRef();
|
|
return _this;
|
|
}
|
|
|
|
_createClass(TreeSelect, [{
|
|
key: "getFilterValue",
|
|
value: function getFilterValue() {
|
|
return this.props.onFilterValueChange ? this.props.filterValue : this.state.filterValue;
|
|
}
|
|
}, {
|
|
key: "getSelectedNodes",
|
|
value: function getSelectedNodes() {
|
|
var selectedNodes = [];
|
|
|
|
if (ObjectUtils.isNotEmpty(this.props.value) && this.props.options) {
|
|
var keys = this.props.selectionMode === 'single' ? _defineProperty({}, "".concat(this.props.value), true) : _objectSpread$6({}, this.props.value);
|
|
this.findSelectedNodes(null, keys, selectedNodes);
|
|
}
|
|
|
|
return selectedNodes;
|
|
}
|
|
}, {
|
|
key: "getLabel",
|
|
value: function getLabel() {
|
|
var value = this.getSelectedNodes();
|
|
return value.length ? value.map(function (node) {
|
|
return node.label;
|
|
}).join(', ') : this.props.placeholder;
|
|
}
|
|
}, {
|
|
key: "isValueEmpty",
|
|
value: function isValueEmpty() {
|
|
return !this.props.value || Object.keys(this.props.value).length === 0;
|
|
}
|
|
}, {
|
|
key: "hasNoOptions",
|
|
value: function hasNoOptions() {
|
|
return !this.props.options || this.props.options.length === 0;
|
|
}
|
|
}, {
|
|
key: "show",
|
|
value: function show() {
|
|
this.setState({
|
|
overlayVisible: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "hide",
|
|
value: function hide() {
|
|
this.setState({
|
|
overlayVisible: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "onInputFocus",
|
|
value: function onInputFocus() {
|
|
this.setState({
|
|
focused: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "onInputBlur",
|
|
value: function onInputBlur() {
|
|
this.setState({
|
|
focused: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
if (!this.props.disabled && (!this.overlayRef || !this.overlayRef.current || !this.overlayRef.current.contains(event.target)) && !DomHandler.hasClass(event.target, 'p-treeselect-close')) {
|
|
this.focusInput.focus();
|
|
|
|
if (this.state.overlayVisible) {
|
|
this.hide();
|
|
} else {
|
|
this.show();
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onSelectionChange",
|
|
value: function onSelectionChange(event) {
|
|
if (this.props.onChange) {
|
|
this.selfChange = true;
|
|
this.props.onChange({
|
|
originalEvent: event.originalEvent,
|
|
value: event.value,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: event.value
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onNodeSelect",
|
|
value: function onNodeSelect(node) {
|
|
this.props.onNodeSelect && this.props.onNodeSelect(node);
|
|
|
|
if (this.props.selectionMode === 'single') {
|
|
this.hide();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onNodeUnselect",
|
|
value: function onNodeUnselect(node) {
|
|
this.props.onNodeUnselect && this.props.onNodeUnselect(node);
|
|
}
|
|
}, {
|
|
key: "onNodeToggle",
|
|
value: function onNodeToggle(e) {
|
|
this.setState({
|
|
expandedKeys: e.value
|
|
});
|
|
}
|
|
}, {
|
|
key: "onFilterValueChange",
|
|
value: function onFilterValueChange(e) {
|
|
this.setState({
|
|
filterValue: e.value
|
|
});
|
|
}
|
|
}, {
|
|
key: "onOverlayClick",
|
|
value: function onOverlayClick(event) {
|
|
OverlayService.emit('overlay-click', {
|
|
originalEvent: event,
|
|
target: this.container
|
|
});
|
|
}
|
|
}, {
|
|
key: "onInputKeyDown",
|
|
value: function onInputKeyDown(event) {
|
|
switch (event.which) {
|
|
//down
|
|
case 40:
|
|
if (!this.state.overlayVisible && event.altKey) {
|
|
this.show();
|
|
}
|
|
|
|
break;
|
|
//space
|
|
|
|
case 32:
|
|
if (!this.state.overlayVisible) {
|
|
this.show();
|
|
event.preventDefault();
|
|
}
|
|
|
|
break;
|
|
//enter and escape
|
|
|
|
case 13:
|
|
case 27:
|
|
if (this.state.overlayVisible) {
|
|
this.hide();
|
|
event.preventDefault();
|
|
}
|
|
|
|
break;
|
|
//tab
|
|
|
|
case 9:
|
|
this.hide();
|
|
break;
|
|
}
|
|
}
|
|
}, {
|
|
key: "onFilterInputKeyDown",
|
|
value: function onFilterInputKeyDown(event) {
|
|
//enter
|
|
if (event.which === 13) {
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onFilterInputChange",
|
|
value: function onFilterInputChange(event) {
|
|
var filterValue = event.target.value;
|
|
|
|
if (this.props.onFilterValueChange) {
|
|
this.props.onFilterValueChange({
|
|
originalEvent: event,
|
|
value: filterValue
|
|
});
|
|
} else {
|
|
this.setState({
|
|
filterValue: filterValue
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "resetFilter",
|
|
value: function resetFilter() {
|
|
this.setState({
|
|
filterValue: ''
|
|
});
|
|
}
|
|
}, {
|
|
key: "onOverlayEnter",
|
|
value: function onOverlayEnter() {
|
|
ZIndexUtils.set('overlay', this.overlayRef.current, PrimeReact.autoZIndex, PrimeReact.zIndex['overlay']);
|
|
this.alignOverlay();
|
|
this.scrollInView();
|
|
}
|
|
}, {
|
|
key: "onOverlayEntered",
|
|
value: function onOverlayEntered() {
|
|
this.bindDocumentClickListener();
|
|
this.bindScrollListener();
|
|
this.bindResizeListener();
|
|
|
|
if (this.props.filter && this.props.filterInputAutoFocus) {
|
|
this.filterInput.focus();
|
|
}
|
|
|
|
this.props.onShow && this.props.onShow();
|
|
}
|
|
}, {
|
|
key: "onOverlayExit",
|
|
value: function onOverlayExit() {
|
|
this.unbindDocumentClickListener();
|
|
this.unbindScrollListener();
|
|
this.unbindResizeListener();
|
|
}
|
|
}, {
|
|
key: "onOverlayExited",
|
|
value: function onOverlayExited() {
|
|
if (this.props.filter && this.props.resetFilterOnHide) {
|
|
this.resetFilter();
|
|
}
|
|
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
this.props.onHide && this.props.onHide();
|
|
}
|
|
}, {
|
|
key: "alignOverlay",
|
|
value: function alignOverlay() {
|
|
DomHandler.alignOverlay(this.overlayRef.current, this.trigger.parentElement, this.props.appendTo || PrimeReact.appendTo);
|
|
}
|
|
}, {
|
|
key: "scrollInView",
|
|
value: function scrollInView() {
|
|
var highlightItem = DomHandler.findSingle(this.overlayRef.current, '.p-treenode-content.p-highlight');
|
|
|
|
if (highlightItem) {
|
|
highlightItem.scrollIntoView({
|
|
block: 'nearest',
|
|
inline: 'start'
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindDocumentClickListener",
|
|
value: function bindDocumentClickListener() {
|
|
var _this2 = this;
|
|
|
|
if (!this.documentClickListener) {
|
|
this.documentClickListener = function (event) {
|
|
if (_this2.state.overlayVisible && _this2.isOutsideClicked(event)) {
|
|
_this2.hide();
|
|
}
|
|
};
|
|
|
|
document.addEventListener('click', this.documentClickListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentClickListener",
|
|
value: function unbindDocumentClickListener() {
|
|
if (this.documentClickListener) {
|
|
document.removeEventListener('click', this.documentClickListener);
|
|
this.documentClickListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindScrollListener",
|
|
value: function bindScrollListener() {
|
|
var _this3 = this;
|
|
|
|
if (!this.scrollHandler) {
|
|
this.scrollHandler = new ConnectedOverlayScrollHandler(this.container, function () {
|
|
if (_this3.state.overlayVisible) {
|
|
_this3.hide();
|
|
}
|
|
});
|
|
}
|
|
|
|
this.scrollHandler.bindScrollListener();
|
|
}
|
|
}, {
|
|
key: "unbindScrollListener",
|
|
value: function unbindScrollListener() {
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.unbindScrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindResizeListener",
|
|
value: function bindResizeListener() {
|
|
var _this4 = this;
|
|
|
|
if (!this.resizeListener) {
|
|
this.resizeListener = function () {
|
|
if (_this4.state.overlayVisible && !DomHandler.isTouchDevice()) {
|
|
_this4.hide();
|
|
}
|
|
};
|
|
|
|
window.addEventListener('resize', this.resizeListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindResizeListener",
|
|
value: function unbindResizeListener() {
|
|
if (this.resizeListener) {
|
|
window.removeEventListener('resize', this.resizeListener);
|
|
this.resizeListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "isOutsideClicked",
|
|
value: function isOutsideClicked(event) {
|
|
return this.container && !(this.container.isSameNode(event.target) || this.container.contains(event.target) || this.overlayRef && this.overlayRef.current.contains(event.target));
|
|
}
|
|
}, {
|
|
key: "findSelectedNodes",
|
|
value: function findSelectedNodes(node, keys, selectedNodes) {
|
|
if (node) {
|
|
if (this.isSelected(node, keys)) {
|
|
selectedNodes.push(node);
|
|
delete keys[node.key];
|
|
}
|
|
|
|
if (Object.keys(keys).length && node.children) {
|
|
var _iterator = _createForOfIteratorHelper$4(node.children),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var childNode = _step.value;
|
|
this.findSelectedNodes(childNode, keys, selectedNodes);
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
}
|
|
} else {
|
|
var _iterator2 = _createForOfIteratorHelper$4(this.props.options),
|
|
_step2;
|
|
|
|
try {
|
|
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
|
|
var _childNode = _step2.value;
|
|
this.findSelectedNodes(_childNode, keys, selectedNodes);
|
|
}
|
|
} catch (err) {
|
|
_iterator2.e(err);
|
|
} finally {
|
|
_iterator2.f();
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "isSelected",
|
|
value: function isSelected(node, keys) {
|
|
return this.props.selectionMode === 'checkbox' ? keys[node.key] && keys[node.key].checked : keys[node.key];
|
|
}
|
|
}, {
|
|
key: "updateTreeState",
|
|
value: function updateTreeState() {
|
|
var keys = this.props.selectionMode === 'single' ? _defineProperty({}, "".concat(this.props.value), true) : _objectSpread$6({}, this.props.value);
|
|
this.setState({
|
|
expandedKeys: {}
|
|
});
|
|
|
|
if (keys && this.props.options) {
|
|
this.updateTreeBranchState(null, null, keys);
|
|
}
|
|
}
|
|
}, {
|
|
key: "updateTreeBranchState",
|
|
value: function updateTreeBranchState(node, path, keys) {
|
|
if (node) {
|
|
if (this.isSelected(node, keys)) {
|
|
this.expandPath(path);
|
|
delete keys[node.key];
|
|
}
|
|
|
|
if (Object.keys(keys).length && node.children) {
|
|
var _iterator3 = _createForOfIteratorHelper$4(node.children),
|
|
_step3;
|
|
|
|
try {
|
|
for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
|
|
var childNode = _step3.value;
|
|
path.push(node.key);
|
|
this.updateTreeBranchState(childNode, path, keys);
|
|
}
|
|
} catch (err) {
|
|
_iterator3.e(err);
|
|
} finally {
|
|
_iterator3.f();
|
|
}
|
|
}
|
|
} else {
|
|
var _iterator4 = _createForOfIteratorHelper$4(this.props.options),
|
|
_step4;
|
|
|
|
try {
|
|
for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
|
|
var _childNode2 = _step4.value;
|
|
this.updateTreeBranchState(_childNode2, [], keys);
|
|
}
|
|
} catch (err) {
|
|
_iterator4.e(err);
|
|
} finally {
|
|
_iterator4.f();
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "expandPath",
|
|
value: function expandPath(path) {
|
|
if (path.length > 0) {
|
|
var expandedKeys = _objectSpread$6({}, this.state.expandedKeys || {});
|
|
|
|
var _iterator5 = _createForOfIteratorHelper$4(path),
|
|
_step5;
|
|
|
|
try {
|
|
for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
|
|
var key = _step5.value;
|
|
expandedKeys[key] = true;
|
|
}
|
|
} catch (err) {
|
|
_iterator5.e(err);
|
|
} finally {
|
|
_iterator5.f();
|
|
}
|
|
|
|
this.setState({
|
|
expandedKeys: expandedKeys
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.updateTreeState();
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps, prevState) {
|
|
if (this.state.overlayVisible) {
|
|
if (this.props.filter || prevState.expandedKeys !== this.state.expandedKeys) {
|
|
this.alignOverlay();
|
|
}
|
|
|
|
if (prevProps.value !== this.props.value) {
|
|
if (!this.selfChange) {
|
|
this.updateTreeState();
|
|
}
|
|
|
|
this.scrollInView();
|
|
this.selfChange = false;
|
|
}
|
|
}
|
|
|
|
if (prevProps.options !== this.props.options) {
|
|
this.updateTreeState();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.unbindDocumentClickListener();
|
|
this.unbindResizeListener();
|
|
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.destroy();
|
|
this.scrollHandler = null;
|
|
}
|
|
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
}
|
|
}, {
|
|
key: "renderKeyboardHelper",
|
|
value: function renderKeyboardHelper() {
|
|
var _this5 = this;
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-hidden-accessible"
|
|
}, /*#__PURE__*/React.createElement("input", {
|
|
ref: function ref(el) {
|
|
return _this5.focusInput = el;
|
|
},
|
|
role: "listbox",
|
|
id: this.props.inputId,
|
|
type: "text",
|
|
readOnly: true,
|
|
"aria-haspopup": "true",
|
|
"aria-expanded": this.state.overlayVisible,
|
|
onFocus: this.onInputFocus,
|
|
onBlur: this.onInputBlur,
|
|
onKeyDown: this.onInputKeyDown,
|
|
disabled: this.props.disabled,
|
|
tabIndex: this.props.tabIndex,
|
|
"aria-label": this.props.ariaLabel,
|
|
"aria-labelledby": this.props.ariaLabelledBy
|
|
}));
|
|
}
|
|
}, {
|
|
key: "renderLabel",
|
|
value: function renderLabel(selectedNodes) {
|
|
var isValueEmpty = this.isValueEmpty();
|
|
var labelClassName = classNames('p-treeselect-label', {
|
|
'p-placeholder': this.getLabel() === this.props.placeholder,
|
|
'p-treeselect-label-empty': !this.props.placeholder && isValueEmpty
|
|
});
|
|
var content = null;
|
|
|
|
if (this.props.valueTemplate) {
|
|
content = ObjectUtils.getJSXElement(this.props.valueTemplate, selectedNodes, this.props);
|
|
} else {
|
|
if (this.props.display === 'comma') {
|
|
content = this.getLabel() || 'empty';
|
|
} else if (this.props.display === 'chip') {
|
|
var _selectedNodes = this.getSelectedNodes();
|
|
|
|
content = /*#__PURE__*/React.createElement(React.Fragment, null, _selectedNodes && _selectedNodes.map(function (node, index) {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-treeselect-token",
|
|
key: "".concat(node.key, "_").concat(index)
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-treeselect-token-label"
|
|
}, node.label));
|
|
}), isValueEmpty && (this.props.placeholder || 'empty'));
|
|
}
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-treeselect-label-container"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: labelClassName
|
|
}, content));
|
|
}
|
|
}, {
|
|
key: "renderDropdownIcon",
|
|
value: function renderDropdownIcon() {
|
|
var _this6 = this;
|
|
|
|
var iconClassName = classNames('p-treeselect-trigger-icon p-clickable', this.props.dropdownIcon);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this6.trigger = el;
|
|
},
|
|
className: "p-treeselect-trigger",
|
|
role: "button",
|
|
"aria-haspopup": "listbox",
|
|
"aria-expanded": this.state.overlayVisible
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
}));
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
var filterValue = this.getFilterValue();
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Tree, {
|
|
value: this.props.options,
|
|
selectionMode: this.props.selectionMode,
|
|
selectionKeys: this.props.value,
|
|
metaKeySelection: this.props.metaKeySelection,
|
|
onSelectionChange: this.onSelectionChange,
|
|
onSelect: this.onNodeSelect,
|
|
onUnselect: this.onNodeUnselect,
|
|
expandedKeys: this.state.expandedKeys,
|
|
onToggle: this.onNodeToggle,
|
|
onExpand: this.props.onNodeExpand,
|
|
onCollapse: this.props.onNodeCollapse,
|
|
filter: this.props.filter,
|
|
filterValue: filterValue,
|
|
filterBy: this.props.filterBy,
|
|
filterMode: this.props.filterMode,
|
|
filterPlaceholder: this.props.filterPlaceholder,
|
|
filterLocale: this.props.filterLocale,
|
|
showHeader: false,
|
|
onFilterValueChange: this.onFilterValueChange
|
|
}), this.hasNoOptions() && /*#__PURE__*/React.createElement("div", {
|
|
className: "p-treeselect-empty-message"
|
|
}, this.props.emptyMessage || localeOption('emptyMessage')));
|
|
}
|
|
}, {
|
|
key: "renderFilterElement",
|
|
value: function renderFilterElement() {
|
|
var _this7 = this;
|
|
|
|
if (this.props.filter) {
|
|
var filterValue = this.getFilterValue();
|
|
filterValue = ObjectUtils.isNotEmpty(filterValue) ? filterValue : '';
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-treeselect-filter-container"
|
|
}, /*#__PURE__*/React.createElement("input", {
|
|
ref: function ref(el) {
|
|
return _this7.filterInput = el;
|
|
},
|
|
type: "text",
|
|
value: filterValue,
|
|
autoComplete: "off",
|
|
className: "p-treeselect-filter p-inputtext p-component",
|
|
placeholder: this.props.filterPlaceholder,
|
|
onKeyDown: this.onFilterInputKeyDown,
|
|
onChange: this.onFilterInputChange,
|
|
disabled: this.props.disabled
|
|
}), /*#__PURE__*/React.createElement("span", {
|
|
className: "p-treeselect-filter-icon pi pi-search"
|
|
}));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderHeader",
|
|
value: function renderHeader() {
|
|
var filterElement = this.renderFilterElement();
|
|
var closeElement = /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "p-treeselect-close p-link",
|
|
onClick: this.hide
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-treeselect-close-icon pi pi-times"
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
var content = /*#__PURE__*/React.createElement("div", {
|
|
className: "p-treeselect-header"
|
|
}, filterElement, closeElement);
|
|
|
|
if (this.props.header) {
|
|
var defaultOptions = {
|
|
className: 'p-treeselect-header',
|
|
filterElement: filterElement,
|
|
closeElement: closeElement,
|
|
closeElementClassName: 'p-treeselect-close p-link',
|
|
closeIconClassName: 'p-treeselect-close-icon pi pi-times',
|
|
onCloseClick: this.hide,
|
|
element: content,
|
|
props: this.props
|
|
};
|
|
return ObjectUtils.getJSXElement(this.props.header, defaultOptions);
|
|
}
|
|
|
|
return content;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this8 = this;
|
|
|
|
var className = classNames('p-treeselect p-component p-inputwrapper', {
|
|
'p-treeselect-chip': this.props.display === 'chip',
|
|
'p-disabled': this.props.disabled,
|
|
'p-focus': this.state.focused,
|
|
'p-inputwrapper-filled': !this.isValueEmpty(),
|
|
'p-inputwrapper-focus': this.state.focused || this.state.overlayVisible
|
|
}, this.props.className);
|
|
var selectedNodes = this.getSelectedNodes();
|
|
var keyboardHelper = this.renderKeyboardHelper();
|
|
var labelElement = this.renderLabel(selectedNodes);
|
|
var dropdownIcon = this.renderDropdownIcon();
|
|
var content = this.renderContent();
|
|
var header = this.renderHeader();
|
|
var footer = ObjectUtils.getJSXElement(this.props.footer, this.props);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
ref: function ref(el) {
|
|
return _this8.container = el;
|
|
},
|
|
className: className,
|
|
style: this.props.style,
|
|
onClick: this.onClick
|
|
}, keyboardHelper, labelElement, dropdownIcon, /*#__PURE__*/React.createElement(TreeSelectPanel, {
|
|
ref: this.overlayRef,
|
|
appendTo: this.props.appendTo,
|
|
panelStyle: this.props.panelStyle,
|
|
panelClassName: this.props.panelClassName,
|
|
scrollHeight: this.props.scrollHeight,
|
|
onClick: this.onOverlayClick,
|
|
header: header,
|
|
footer: footer,
|
|
transitionOptions: this.props.transitionOptions,
|
|
"in": this.state.overlayVisible,
|
|
onEnter: this.onOverlayEnter,
|
|
onEntered: this.onOverlayEntered,
|
|
onExit: this.onOverlayExit,
|
|
onExited: this.onOverlayExited
|
|
}, content));
|
|
}
|
|
}]);
|
|
|
|
return TreeSelect;
|
|
}(Component);
|
|
|
|
_defineProperty(TreeSelect, "defaultProps", {
|
|
id: null,
|
|
value: null,
|
|
name: null,
|
|
style: null,
|
|
className: null,
|
|
disabled: false,
|
|
options: null,
|
|
scrollHeight: '400px',
|
|
placeholder: null,
|
|
tabIndex: null,
|
|
inputId: null,
|
|
ariaLabel: null,
|
|
ariaLabelledBy: null,
|
|
selectionMode: 'single',
|
|
panelStyle: null,
|
|
panelClassName: null,
|
|
appendTo: null,
|
|
emptyMessage: null,
|
|
display: 'comma',
|
|
metaKeySelection: true,
|
|
valueTemplate: null,
|
|
panelHeaderTemplate: null,
|
|
panelFooterTemplate: null,
|
|
transitionOptions: null,
|
|
dropdownIcon: 'pi pi-chevron-down',
|
|
filter: false,
|
|
filterValue: null,
|
|
filterBy: 'label',
|
|
filterMode: 'lenient',
|
|
filterPlaceholder: null,
|
|
filterLocale: undefined,
|
|
filterInputAutoFocus: true,
|
|
resetFilterOnHide: false,
|
|
onShow: null,
|
|
onHide: null,
|
|
onChange: null,
|
|
onNodeSelect: null,
|
|
onNodeUnselect: null,
|
|
onNodeExpand: null,
|
|
onNodeCollapse: null,
|
|
onFilterValueChange: null
|
|
});
|
|
|
|
function _createForOfIteratorHelper$3(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$3(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$3(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$3(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$3(o, minLen); }
|
|
|
|
function _arrayLikeToArray$3(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 _createSuper$d(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$d(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$d() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var TreeTableHeader = /*#__PURE__*/function (_Component) {
|
|
_inherits(TreeTableHeader, _Component);
|
|
|
|
var _super = _createSuper$d(TreeTableHeader);
|
|
|
|
function TreeTableHeader(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, TreeTableHeader);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
badgeVisible: false
|
|
};
|
|
_this.onFilterInput = _this.onFilterInput.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(TreeTableHeader, [{
|
|
key: "onHeaderClick",
|
|
value: function onHeaderClick(event, column) {
|
|
if (column.props.sortable) {
|
|
var targetNode = event.target;
|
|
|
|
if (DomHandler.hasClass(targetNode, 'p-sortable-column') || DomHandler.hasClass(targetNode, 'p-column-title') || DomHandler.hasClass(targetNode, 'p-sortable-column-icon') || DomHandler.hasClass(targetNode.parentElement, 'p-sortable-column-icon')) {
|
|
this.props.onSort({
|
|
originalEvent: event,
|
|
sortField: column.props.sortField || column.props.field,
|
|
sortFunction: column.props.sortFunction,
|
|
sortable: column.props.sortable
|
|
});
|
|
DomHandler.clearSelection();
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onHeaderMouseDown",
|
|
value: function onHeaderMouseDown(event, column) {
|
|
if (this.props.reorderableColumns && column.props.reorderable) {
|
|
if (event.target.nodeName !== 'INPUT') event.currentTarget.draggable = true;else if (event.target.nodeName === 'INPUT') event.currentTarget.draggable = false;
|
|
}
|
|
}
|
|
}, {
|
|
key: "onHeaderKeyDown",
|
|
value: function onHeaderKeyDown(event, column) {
|
|
if (event.key === 'Enter') {
|
|
this.onHeaderClick(event, column);
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: "getMultiSortMetaDataIndex",
|
|
value: function getMultiSortMetaDataIndex(column) {
|
|
if (this.props.multiSortMeta) {
|
|
for (var i = 0; i < this.props.multiSortMeta.length; i++) {
|
|
if (this.props.multiSortMeta[i].field === column.props.field) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
}, {
|
|
key: "onResizerMouseDown",
|
|
value: function onResizerMouseDown(event, column) {
|
|
if (this.props.resizableColumns && this.props.onResizeStart) {
|
|
this.props.onResizeStart({
|
|
originalEvent: event,
|
|
columnEl: event.target.parentElement,
|
|
column: column
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDragStart",
|
|
value: function onDragStart(event, column) {
|
|
if (this.props.onDragStart) {
|
|
this.props.onDragStart({
|
|
originalEvent: event,
|
|
column: column
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDragOver",
|
|
value: function onDragOver(event, column) {
|
|
if (this.props.onDragOver) {
|
|
this.props.onDragOver({
|
|
originalEvent: event,
|
|
column: column
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDragLeave",
|
|
value: function onDragLeave(event, column) {
|
|
if (this.props.onDragLeave) {
|
|
this.props.onDragLeave({
|
|
originalEvent: event,
|
|
column: column
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onDrop",
|
|
value: function onDrop(event, column) {
|
|
if (this.props.onDrop) {
|
|
this.props.onDrop({
|
|
originalEvent: event,
|
|
column: column
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onFilterInput",
|
|
value: function onFilterInput(e, column) {
|
|
var _this2 = this;
|
|
|
|
if (column.props.filter && this.props.onFilter) {
|
|
if (this.filterTimeout) {
|
|
clearTimeout(this.filterTimeout);
|
|
}
|
|
|
|
var filterValue = e.target.value;
|
|
this.filterTimeout = setTimeout(function () {
|
|
_this2.props.onFilter({
|
|
value: filterValue,
|
|
field: column.props.field,
|
|
matchMode: column.props.filterMatchMode || 'startsWith'
|
|
});
|
|
|
|
_this2.filterTimeout = null;
|
|
}, this.props.filterDelay);
|
|
}
|
|
}
|
|
}, {
|
|
key: "hasColumnFilter",
|
|
value: function hasColumnFilter(columns) {
|
|
if (columns) {
|
|
var _iterator = _createForOfIteratorHelper$3(columns),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var col = _step.value;
|
|
|
|
if (col.props.filter) {
|
|
return true;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "renderSortIcon",
|
|
value: function renderSortIcon(column, sorted, sortOrder) {
|
|
if (column.props.sortable) {
|
|
var sortIcon = sorted ? sortOrder < 0 ? 'pi-sort-amount-down' : 'pi-sort-amount-up-alt' : 'pi-sort-alt';
|
|
var sortIconClassName = classNames('p-sortable-column-icon', 'pi pi-fw', sortIcon);
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: sortIconClassName
|
|
});
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderResizer",
|
|
value: function renderResizer(column) {
|
|
var _this3 = this;
|
|
|
|
if (this.props.resizableColumns) {
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: "p-column-resizer p-clickable",
|
|
onMouseDown: function onMouseDown(e) {
|
|
return _this3.onResizerMouseDown(e, column);
|
|
}
|
|
});
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "getAriaSort",
|
|
value: function getAriaSort(column, sorted, sortOrder) {
|
|
if (column.props.sortable) {
|
|
var sortIcon = sorted ? sortOrder < 0 ? 'pi-sort-down' : 'pi-sort-up' : 'pi-sort';
|
|
if (sortIcon === 'pi-sort-down') return 'descending';else if (sortIcon === 'pi-sort-up') return 'ascending';else return 'none';
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderSortBadge",
|
|
value: function renderSortBadge(sortMetaDataIndex) {
|
|
if (sortMetaDataIndex !== -1 && this.state.badgeVisible) {
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
className: "p-sortable-column-badge"
|
|
}, sortMetaDataIndex + 1);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderHeaderCell",
|
|
value: function renderHeaderCell(column, options) {
|
|
var _this4 = this;
|
|
|
|
var filterElement;
|
|
|
|
if (column.props.filter && options.renderFilter) {
|
|
filterElement = column.props.filterElement || /*#__PURE__*/React.createElement(InputText, {
|
|
onInput: function onInput(e) {
|
|
return _this4.onFilterInput(e, column);
|
|
},
|
|
type: this.props.filterType,
|
|
defaultValue: this.props.filters && this.props.filters[column.props.field] ? this.props.filters[column.props.field].value : null,
|
|
className: "p-column-filter",
|
|
placeholder: column.props.filterPlaceholder,
|
|
maxLength: column.props.filterMaxLength
|
|
});
|
|
}
|
|
|
|
if (options.filterOnly) {
|
|
return /*#__PURE__*/React.createElement("th", {
|
|
key: column.props.columnKey || column.props.field || options.index,
|
|
className: classNames('p-filter-column', column.props.filterHeaderClassName),
|
|
style: column.props.filterHeaderStyle || column.props.style,
|
|
rowSpan: column.props.rowSpan,
|
|
colSpan: column.props.colSpan
|
|
}, filterElement);
|
|
} else {
|
|
var sortMetaDataIndex = this.getMultiSortMetaDataIndex(column);
|
|
var multiSortMetaData = sortMetaDataIndex !== -1 ? this.props.multiSortMeta[sortMetaDataIndex] : null;
|
|
var singleSorted = column.props.field === this.props.sortField;
|
|
var multipleSorted = multiSortMetaData !== null;
|
|
var sorted = column.props.sortable && (singleSorted || multipleSorted);
|
|
var sortOrder = 0;
|
|
if (singleSorted) sortOrder = this.props.sortOrder;else if (multipleSorted) sortOrder = multiSortMetaData.order;
|
|
var sortIconElement = this.renderSortIcon(column, sorted, sortOrder);
|
|
var ariaSortData = this.getAriaSort(column, sorted, sortOrder);
|
|
var sortBadge = this.renderSortBadge(sortMetaDataIndex);
|
|
var className = classNames(column.props.headerClassName || column.props.className, {
|
|
'p-sortable-column': column.props.sortable,
|
|
'p-highlight': sorted,
|
|
'p-resizable-column': this.props.resizableColumns
|
|
});
|
|
var resizer = this.renderResizer(column);
|
|
return /*#__PURE__*/React.createElement("th", {
|
|
key: column.columnKey || column.field || options.index,
|
|
className: className,
|
|
style: column.props.headerStyle || column.props.style,
|
|
tabIndex: column.props.sortable ? this.props.tabIndex : null,
|
|
onClick: function onClick(e) {
|
|
return _this4.onHeaderClick(e, column);
|
|
},
|
|
onMouseDown: function onMouseDown(e) {
|
|
return _this4.onHeaderMouseDown(e, column);
|
|
},
|
|
onKeyDown: function onKeyDown(e) {
|
|
return _this4.onHeaderKeyDown(e, column);
|
|
},
|
|
rowSpan: column.props.rowSpan,
|
|
colSpan: column.props.colSpan,
|
|
"aria-sort": ariaSortData,
|
|
onDragStart: function onDragStart(e) {
|
|
return _this4.onDragStart(e, column);
|
|
},
|
|
onDragOver: function onDragOver(e) {
|
|
return _this4.onDragOver(e, column);
|
|
},
|
|
onDragLeave: function onDragLeave(e) {
|
|
return _this4.onDragLeave(e, column);
|
|
},
|
|
onDrop: function onDrop(e) {
|
|
return _this4.onDrop(e, column);
|
|
}
|
|
}, resizer, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-column-title"
|
|
}, column.props.header), sortIconElement, sortBadge, filterElement);
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderHeaderRow",
|
|
value: function renderHeaderRow(row, index) {
|
|
var _this5 = this;
|
|
|
|
var rowColumns = React.Children.toArray(row.props.children);
|
|
var rowHeaderCells = rowColumns.map(function (col, i) {
|
|
return _this5.renderHeaderCell(col, {
|
|
index: i,
|
|
filterOnly: false,
|
|
renderFilter: true
|
|
});
|
|
});
|
|
return /*#__PURE__*/React.createElement("tr", {
|
|
key: index
|
|
}, rowHeaderCells);
|
|
}
|
|
}, {
|
|
key: "renderColumnGroup",
|
|
value: function renderColumnGroup() {
|
|
var _this6 = this;
|
|
|
|
var rows = React.Children.toArray(this.props.columnGroup.props.children);
|
|
return rows.map(function (row, i) {
|
|
return _this6.renderHeaderRow(row, i);
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderColumns",
|
|
value: function renderColumns(columns) {
|
|
var _this7 = this;
|
|
|
|
if (columns) {
|
|
if (this.hasColumnFilter(columns)) {
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("tr", null, columns.map(function (col, i) {
|
|
return _this7.renderHeaderCell(col, {
|
|
index: i,
|
|
filterOnly: false,
|
|
renderFilter: false
|
|
});
|
|
})), /*#__PURE__*/React.createElement("tr", null, columns.map(function (col, i) {
|
|
return _this7.renderHeaderCell(col, {
|
|
index: i,
|
|
filterOnly: true,
|
|
renderFilter: true
|
|
});
|
|
})));
|
|
} else {
|
|
return /*#__PURE__*/React.createElement("tr", null, columns.map(function (col, i) {
|
|
return _this7.renderHeaderCell(col, {
|
|
index: i,
|
|
filterOnly: false,
|
|
renderFilter: false
|
|
});
|
|
}));
|
|
}
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var content = this.props.columnGroup ? this.renderColumnGroup() : this.renderColumns(this.props.columns);
|
|
return /*#__PURE__*/React.createElement("thead", {
|
|
className: "p-treetable-thead"
|
|
}, content);
|
|
}
|
|
}], [{
|
|
key: "getDerivedStateFromProps",
|
|
value: function getDerivedStateFromProps(nextProps, prevState) {
|
|
return {
|
|
badgeVisible: nextProps.multiSortMeta && nextProps.multiSortMeta.length > 1
|
|
};
|
|
}
|
|
}]);
|
|
|
|
return TreeTableHeader;
|
|
}(Component);
|
|
|
|
function _createSuper$c(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$c(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$c() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var TreeTableBodyCell = /*#__PURE__*/function (_Component) {
|
|
_inherits(TreeTableBodyCell, _Component);
|
|
|
|
var _super = _createSuper$c(TreeTableBodyCell);
|
|
|
|
function TreeTableBodyCell(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, TreeTableBodyCell);
|
|
|
|
_this = _super.call(this, props);
|
|
|
|
if (_this.props.editor) {
|
|
_this.state = {};
|
|
}
|
|
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onEditorFocus = _this.onEditorFocus.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(TreeTableBodyCell, [{
|
|
key: "onClick",
|
|
value: function onClick() {
|
|
var _this2 = this;
|
|
|
|
if (this.props.editor && !this.state.editing && (this.props.selectOnEdit || !this.props.selectOnEdit && this.props.selected)) {
|
|
this.selfClick = true;
|
|
this.setState({
|
|
editing: true
|
|
}, function () {
|
|
_this2.bindDocumentEditListener();
|
|
|
|
_this2.overlayEventListener = function (e) {
|
|
if (!_this2.isOutsideClicked(e.target)) {
|
|
_this2.selfClick = true;
|
|
}
|
|
};
|
|
|
|
OverlayService.on('overlay-click', _this2.overlayEventListener);
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event) {
|
|
if (event.which === 13 || event.which === 9) {
|
|
this.switchCellToViewMode(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindDocumentEditListener",
|
|
value: function bindDocumentEditListener() {
|
|
var _this3 = this;
|
|
|
|
if (!this.documentEditListener) {
|
|
this.documentEditListener = function (e) {
|
|
if (!_this3.selfClick && _this3.isOutsideClicked(e.target)) {
|
|
_this3.switchCellToViewMode(e);
|
|
}
|
|
|
|
_this3.selfClick = false;
|
|
};
|
|
|
|
document.addEventListener('click', this.documentEditListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "isOutsideClicked",
|
|
value: function isOutsideClicked(target) {
|
|
return this.container && !(this.container.isSameNode(target) || this.container.contains(target));
|
|
}
|
|
}, {
|
|
key: "unbindDocumentEditListener",
|
|
value: function unbindDocumentEditListener() {
|
|
if (this.documentEditListener) {
|
|
document.removeEventListener('click', this.documentEditListener);
|
|
this.documentEditListener = null;
|
|
this.selfClick = false;
|
|
}
|
|
}
|
|
}, {
|
|
key: "closeCell",
|
|
value: function closeCell() {
|
|
var _this4 = this;
|
|
|
|
/* When using the 'tab' key, the focus event of the next cell is not called in IE. */
|
|
setTimeout(function () {
|
|
_this4.setState({
|
|
editing: false
|
|
}, function () {
|
|
_this4.unbindDocumentEditListener();
|
|
|
|
OverlayService.off('overlay-click', _this4.overlayEventListener);
|
|
_this4.overlayEventListener = null;
|
|
});
|
|
}, 1);
|
|
}
|
|
}, {
|
|
key: "onEditorFocus",
|
|
value: function onEditorFocus(event) {
|
|
this.onClick(event);
|
|
}
|
|
}, {
|
|
key: "switchCellToViewMode",
|
|
value: function switchCellToViewMode(event) {
|
|
if (this.props.cellEditValidator) {
|
|
var valid = this.props.cellEditValidator({
|
|
originalEvent: event,
|
|
columnProps: this.props
|
|
});
|
|
|
|
if (valid) {
|
|
this.closeCell();
|
|
}
|
|
} else {
|
|
this.closeCell();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate() {
|
|
var _this5 = this;
|
|
|
|
if (this.container && this.props.editor) {
|
|
clearTimeout(this.tabindexTimeout);
|
|
|
|
if (this.state && this.state.editing) {
|
|
var focusable = DomHandler.findSingle(this.container, 'input');
|
|
|
|
if (focusable && document.activeElement !== focusable && !focusable.hasAttribute('data-isCellEditing')) {
|
|
focusable.setAttribute('data-isCellEditing', true);
|
|
focusable.focus();
|
|
}
|
|
|
|
this.keyHelper.tabIndex = -1;
|
|
} else {
|
|
this.tabindexTimeout = setTimeout(function () {
|
|
if (_this5.keyHelper) {
|
|
_this5.keyHelper.setAttribute('tabindex', 0);
|
|
}
|
|
}, 50);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.unbindDocumentEditListener();
|
|
|
|
if (this.overlayEventListener) {
|
|
OverlayService.off('overlay-click', this.overlayEventListener);
|
|
this.overlayEventListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this6 = this;
|
|
|
|
var className = classNames(this.props.bodyClassName || this.props.className, {
|
|
'p-editable-column': this.props.editor,
|
|
'p-cell-editing': this.props.editor ? this.state.editing : false
|
|
});
|
|
var style = this.props.bodyStyle || this.props.style;
|
|
var content;
|
|
|
|
if (this.state && this.state.editing) {
|
|
if (this.props.editor) content = ObjectUtils.getJSXElement(this.props.editor, {
|
|
node: this.props.node,
|
|
rowData: this.props.node.data,
|
|
value: ObjectUtils.resolveFieldData(this.props.node.data, this.props.field),
|
|
field: this.props.field,
|
|
rowIndex: this.props.rowIndex,
|
|
props: this.props
|
|
});else throw new Error("Editor is not found on column.");
|
|
} else {
|
|
if (this.props.body) content = ObjectUtils.getJSXElement(this.props.body, this.props.node, {
|
|
field: this.props.field,
|
|
rowIndex: this.props.rowIndex,
|
|
props: this.props
|
|
});else content = ObjectUtils.resolveFieldData(this.props.node.data, this.props.field);
|
|
}
|
|
/* eslint-disable */
|
|
|
|
|
|
var editorKeyHelper = this.props.editor && /*#__PURE__*/React.createElement("a", {
|
|
tabIndex: 0,
|
|
ref: function ref(el) {
|
|
_this6.keyHelper = el;
|
|
},
|
|
className: "p-cell-editor-key-helper p-hidden-accessible",
|
|
onFocus: this.onEditorFocus
|
|
}, /*#__PURE__*/React.createElement("span", null));
|
|
/* eslint-enable */
|
|
|
|
return /*#__PURE__*/React.createElement("td", {
|
|
ref: function ref(el) {
|
|
return _this6.container = el;
|
|
},
|
|
className: className,
|
|
style: style,
|
|
onClick: this.onClick,
|
|
onKeyDown: this.onKeyDown
|
|
}, this.props.children, editorKeyHelper, content);
|
|
}
|
|
}]);
|
|
|
|
return TreeTableBodyCell;
|
|
}(Component);
|
|
|
|
function _createForOfIteratorHelper$2(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$2(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$2(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$2(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$2(o, minLen); }
|
|
|
|
function _arrayLikeToArray$2(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 ownKeys$5(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$5(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$5(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$5(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$b(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$b(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$b() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var TreeTableRow = /*#__PURE__*/function (_Component) {
|
|
_inherits(TreeTableRow, _Component);
|
|
|
|
var _super = _createSuper$b(TreeTableRow);
|
|
|
|
function TreeTableRow(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, TreeTableRow);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onTogglerClick = _this.onTogglerClick.bind(_assertThisInitialized(_this));
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onTouchEnd = _this.onTouchEnd.bind(_assertThisInitialized(_this));
|
|
_this.propagateUp = _this.propagateUp.bind(_assertThisInitialized(_this));
|
|
_this.onCheckboxChange = _this.onCheckboxChange.bind(_assertThisInitialized(_this));
|
|
_this.onCheckboxFocus = _this.onCheckboxFocus.bind(_assertThisInitialized(_this));
|
|
_this.onCheckboxBlur = _this.onCheckboxBlur.bind(_assertThisInitialized(_this));
|
|
_this.onRightClick = _this.onRightClick.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(TreeTableRow, [{
|
|
key: "isLeaf",
|
|
value: function isLeaf() {
|
|
return this.props.node.leaf === false ? false : !(this.props.node.children && this.props.node.children.length);
|
|
}
|
|
}, {
|
|
key: "onTogglerClick",
|
|
value: function onTogglerClick(event) {
|
|
if (this.isExpanded()) this.collapse(event);else this.expand(event);
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
}
|
|
}, {
|
|
key: "expand",
|
|
value: function expand(event) {
|
|
var expandedKeys = this.props.expandedKeys ? _objectSpread$5({}, this.props.expandedKeys) : {};
|
|
expandedKeys[this.props.node.key] = true;
|
|
this.props.onToggle({
|
|
originalEvent: event,
|
|
value: expandedKeys
|
|
});
|
|
this.invokeToggleEvents(event, true);
|
|
}
|
|
}, {
|
|
key: "collapse",
|
|
value: function collapse(event) {
|
|
var expandedKeys = _objectSpread$5({}, this.props.expandedKeys);
|
|
|
|
delete expandedKeys[this.props.node.key];
|
|
this.props.onToggle({
|
|
originalEvent: event,
|
|
value: expandedKeys
|
|
});
|
|
this.invokeToggleEvents(event, false);
|
|
}
|
|
}, {
|
|
key: "invokeToggleEvents",
|
|
value: function invokeToggleEvents(event, expanded) {
|
|
if (expanded) {
|
|
if (this.props.onExpand) {
|
|
this.props.onExpand({
|
|
originalEvent: event,
|
|
node: this.props.node
|
|
});
|
|
}
|
|
} else {
|
|
if (this.props.onCollapse) {
|
|
this.props.onCollapse({
|
|
originalEvent: event,
|
|
node: this.props.node
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
if (this.props.onRowClick) {
|
|
this.props.onRowClick(event, this.props.node);
|
|
}
|
|
|
|
this.nodeTouched = false;
|
|
}
|
|
}, {
|
|
key: "onTouchEnd",
|
|
value: function onTouchEnd() {
|
|
this.nodeTouched = true;
|
|
}
|
|
}, {
|
|
key: "onCheckboxChange",
|
|
value: function onCheckboxChange(event) {
|
|
var checked = this.isChecked();
|
|
var selectionKeys = this.props.selectionKeys ? _objectSpread$5({}, this.props.selectionKeys) : {};
|
|
|
|
if (checked) {
|
|
if (this.props.propagateSelectionDown) this.propagateDown(this.props.node, false, selectionKeys);else delete selectionKeys[this.props.node.key];
|
|
|
|
if (this.props.propagateSelectionUp && this.props.onPropagateUp) {
|
|
this.props.onPropagateUp({
|
|
originalEvent: event,
|
|
check: false,
|
|
selectionKeys: selectionKeys
|
|
});
|
|
}
|
|
|
|
if (this.props.onUnselect) {
|
|
this.props.onUnselect({
|
|
originalEvent: event,
|
|
node: this.props.node
|
|
});
|
|
}
|
|
} else {
|
|
if (this.props.propagateSelectionDown) this.propagateDown(this.props.node, true, selectionKeys);else selectionKeys[this.props.node.key] = {
|
|
checked: true
|
|
};
|
|
|
|
if (this.props.propagateSelectionUp && this.props.onPropagateUp) {
|
|
this.props.onPropagateUp({
|
|
originalEvent: event,
|
|
check: true,
|
|
selectionKeys: selectionKeys
|
|
});
|
|
}
|
|
|
|
if (this.props.onSelect) {
|
|
this.props.onSelect({
|
|
originalEvent: event,
|
|
node: this.props.node
|
|
});
|
|
}
|
|
}
|
|
|
|
if (this.props.onSelectionChange) {
|
|
this.props.onSelectionChange({
|
|
originalEvent: event,
|
|
value: selectionKeys
|
|
});
|
|
}
|
|
|
|
DomHandler.clearSelection();
|
|
}
|
|
}, {
|
|
key: "onCheckboxFocus",
|
|
value: function onCheckboxFocus() {
|
|
DomHandler.addClass(this.checkboxBox, 'p-focus');
|
|
DomHandler.addClass(this.checkboxRef, 'p-checkbox-focused');
|
|
}
|
|
}, {
|
|
key: "onCheckboxBlur",
|
|
value: function onCheckboxBlur() {
|
|
DomHandler.removeClass(this.checkboxBox, 'p-focus');
|
|
DomHandler.removeClass(this.checkboxRef, 'p-checkbox-focused');
|
|
}
|
|
}, {
|
|
key: "propagateUp",
|
|
value: function propagateUp(event) {
|
|
var check = event.check;
|
|
var selectionKeys = event.selectionKeys;
|
|
var checkedChildCount = 0;
|
|
var childPartialSelected = false;
|
|
|
|
var _iterator = _createForOfIteratorHelper$2(this.props.node.children),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var child = _step.value;
|
|
if (selectionKeys[child.key] && selectionKeys[child.key].checked) checkedChildCount++;else if (selectionKeys[child.key] && selectionKeys[child.key].partialChecked) childPartialSelected = true;
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
|
|
if (check && checkedChildCount === this.props.node.children.length) {
|
|
selectionKeys[this.props.node.key] = {
|
|
checked: true,
|
|
partialChecked: false
|
|
};
|
|
} else {
|
|
if (!check) {
|
|
delete selectionKeys[this.props.node.key];
|
|
}
|
|
|
|
if (childPartialSelected || checkedChildCount > 0 && checkedChildCount !== this.props.node.children.length) selectionKeys[this.props.node.key] = {
|
|
checked: false,
|
|
partialChecked: true
|
|
};else selectionKeys[this.props.node.key] = {
|
|
checked: false,
|
|
partialChecked: false
|
|
};
|
|
}
|
|
|
|
if (this.props.propagateSelectionUp && this.props.onPropagateUp) {
|
|
this.props.onPropagateUp(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "propagateDown",
|
|
value: function propagateDown(node, check, selectionKeys) {
|
|
if (check) selectionKeys[node.key] = {
|
|
checked: true,
|
|
partialChecked: false
|
|
};else delete selectionKeys[node.key];
|
|
|
|
if (node.children && node.children.length) {
|
|
for (var i = 0; i < node.children.length; i++) {
|
|
this.propagateDown(node.children[i], check, selectionKeys);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onRightClick",
|
|
value: function onRightClick(event) {
|
|
DomHandler.clearSelection();
|
|
|
|
if (this.props.onContextMenuSelectionChange) {
|
|
this.props.onContextMenuSelectionChange({
|
|
originalEvent: event,
|
|
value: this.props.node.key
|
|
});
|
|
}
|
|
|
|
if (this.props.onContextMenu) {
|
|
this.props.onContextMenu({
|
|
originalEvent: event,
|
|
node: this.props.node
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event) {
|
|
if (event.target === this.container) {
|
|
var rowElement = event.currentTarget;
|
|
|
|
switch (event.which) {
|
|
//down arrow
|
|
case 40:
|
|
var nextRow = rowElement.nextElementSibling;
|
|
|
|
if (nextRow) {
|
|
nextRow.focus();
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//up arrow
|
|
|
|
case 38:
|
|
var previousRow = rowElement.previousElementSibling;
|
|
|
|
if (previousRow) {
|
|
previousRow.focus();
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//right arrow
|
|
|
|
case 39:
|
|
if (!this.isExpanded()) {
|
|
this.expand(event);
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//left arrow
|
|
|
|
case 37:
|
|
if (this.isExpanded()) {
|
|
this.collapse(event);
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//enter
|
|
|
|
case 13:
|
|
this.onClick(event);
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "isExpanded",
|
|
value: function isExpanded() {
|
|
return this.props.expandedKeys ? this.props.expandedKeys[this.props.node.key] !== undefined : false;
|
|
}
|
|
}, {
|
|
key: "isSelected",
|
|
value: function isSelected() {
|
|
if ((this.props.selectionMode === 'single' || this.props.selectionMode === 'multiple') && this.props.selectionKeys) return this.props.selectionMode === 'single' ? this.props.selectionKeys === this.props.node.key : this.props.selectionKeys[this.props.node.key] !== undefined;else return false;
|
|
}
|
|
}, {
|
|
key: "isChecked",
|
|
value: function isChecked() {
|
|
return this.props.selectionKeys ? this.props.selectionKeys[this.props.node.key] && this.props.selectionKeys[this.props.node.key].checked : false;
|
|
}
|
|
}, {
|
|
key: "isPartialChecked",
|
|
value: function isPartialChecked() {
|
|
return this.props.selectionKeys ? this.props.selectionKeys[this.props.node.key] && this.props.selectionKeys[this.props.node.key].partialChecked : false;
|
|
}
|
|
}, {
|
|
key: "renderToggler",
|
|
value: function renderToggler() {
|
|
var expanded = this.isExpanded();
|
|
var iconClassName = classNames('"p-treetable-toggler-icon pi pi-fw', {
|
|
'pi-chevron-right': !expanded,
|
|
'pi-chevron-down': expanded
|
|
});
|
|
var style = {
|
|
marginLeft: this.props.level * 16 + 'px',
|
|
visibility: this.props.node.leaf === false || this.props.node.children && this.props.node.children.length ? 'visible' : 'hidden'
|
|
};
|
|
return /*#__PURE__*/React.createElement("button", {
|
|
type: "button",
|
|
className: "p-treetable-toggler p-link p-unselectable-text",
|
|
onClick: this.onTogglerClick,
|
|
tabIndex: -1,
|
|
style: style
|
|
}, /*#__PURE__*/React.createElement("i", {
|
|
className: iconClassName
|
|
}), /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
}, {
|
|
key: "renderCheckbox",
|
|
value: function renderCheckbox() {
|
|
var _this2 = this;
|
|
|
|
if (this.props.selectionMode === 'checkbox' && this.props.node.selectable !== false) {
|
|
var checked = this.isChecked();
|
|
var partialChecked = this.isPartialChecked();
|
|
var className = classNames('p-checkbox-box', {
|
|
'p-highlight': checked,
|
|
'p-indeterminate': partialChecked
|
|
});
|
|
var icon = classNames('p-checkbox-icon p-c', {
|
|
'pi pi-check': checked,
|
|
'pi pi-minus': partialChecked
|
|
});
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-checkbox p-treetable-checkbox p-component",
|
|
ref: function ref(el) {
|
|
return _this2.checkboxRef = el;
|
|
},
|
|
onClick: this.onCheckboxChange,
|
|
role: "checkbox",
|
|
"aria-checked": checked
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-hidden-accessible"
|
|
}, /*#__PURE__*/React.createElement("input", {
|
|
type: "checkbox",
|
|
onFocus: this.onCheckboxFocus,
|
|
onBlur: this.onCheckboxBlur
|
|
})), /*#__PURE__*/React.createElement("div", {
|
|
className: className,
|
|
ref: function ref(el) {
|
|
return _this2.checkboxBox = el;
|
|
}
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: icon
|
|
})));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderCell",
|
|
value: function renderCell(column) {
|
|
var toggler, checkbox;
|
|
|
|
if (column.props.expander) {
|
|
toggler = this.renderToggler();
|
|
checkbox = this.renderCheckbox();
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement(TreeTableBodyCell, _extends({
|
|
key: column.props.columnKey || column.props.field
|
|
}, column.props, {
|
|
selectOnEdit: this.props.selectOnEdit,
|
|
selected: this.isSelected(),
|
|
node: this.props.node,
|
|
rowIndex: this.props.rowIndex
|
|
}), toggler, checkbox);
|
|
}
|
|
}, {
|
|
key: "renderChildren",
|
|
value: function renderChildren() {
|
|
var _this3 = this;
|
|
|
|
if (this.isExpanded() && this.props.node.children) {
|
|
return this.props.node.children.map(function (childNode, index) {
|
|
return /*#__PURE__*/React.createElement(TreeTableRow, {
|
|
key: childNode.key || JSON.stringify(childNode.data),
|
|
level: _this3.props.level + 1,
|
|
rowIndex: _this3.props.rowIndex + '_' + index,
|
|
node: childNode,
|
|
columns: _this3.props.columns,
|
|
expandedKeys: _this3.props.expandedKeys,
|
|
selectOnEdit: _this3.props.selectOnEdit,
|
|
onToggle: _this3.props.onToggle,
|
|
onExpand: _this3.props.onExpand,
|
|
onCollapse: _this3.props.onCollapse,
|
|
selectionMode: _this3.props.selectionMode,
|
|
selectionKeys: _this3.props.selectionKeys,
|
|
onSelectionChange: _this3.props.onSelectionChange,
|
|
metaKeySelection: _this3.props.metaKeySelection,
|
|
onRowClick: _this3.props.onRowClick,
|
|
onSelect: _this3.props.onSelect,
|
|
onUnselect: _this3.props.onUnselect,
|
|
propagateSelectionUp: _this3.props.propagateSelectionUp,
|
|
propagateSelectionDown: _this3.props.propagateSelectionDown,
|
|
onPropagateUp: _this3.propagateUp,
|
|
rowClassName: _this3.props.rowClassName,
|
|
contextMenuSelectionKey: _this3.props.contextMenuSelectionKey,
|
|
onContextMenuSelectionChange: _this3.props.onContextMenuSelectionChange,
|
|
onContextMenu: _this3.props.onContextMenu
|
|
});
|
|
});
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this4 = this;
|
|
|
|
var cells = this.props.columns.map(function (col) {
|
|
return _this4.renderCell(col);
|
|
});
|
|
var children = this.renderChildren();
|
|
var className = {
|
|
'p-highlight': this.isSelected(),
|
|
'p-highlight-contextmenu': this.props.contextMenuSelectionKey && this.props.contextMenuSelectionKey === this.props.node.key
|
|
};
|
|
|
|
if (this.props.rowClassName) {
|
|
var rowClassName = this.props.rowClassName(this.props.node);
|
|
className = _objectSpread$5(_objectSpread$5({}, className), rowClassName);
|
|
}
|
|
|
|
className = classNames(className, this.props.node.className);
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("tr", {
|
|
ref: function ref(el) {
|
|
return _this4.container = el;
|
|
},
|
|
tabIndex: 0,
|
|
className: className,
|
|
style: this.props.node.style,
|
|
onClick: this.onClick,
|
|
onTouchEnd: this.onTouchEnd,
|
|
onContextMenu: this.onRightClick,
|
|
onKeyDown: this.onKeyDown
|
|
}, cells), children);
|
|
}
|
|
}]);
|
|
|
|
return TreeTableRow;
|
|
}(Component);
|
|
|
|
_defineProperty(TreeTableRow, "defaultProps", {
|
|
node: null,
|
|
level: null,
|
|
columns: null,
|
|
expandedKeys: null,
|
|
contextMenuSelectionKey: null,
|
|
selectionMode: null,
|
|
selectionKeys: null,
|
|
metaKeySelection: true,
|
|
propagateSelectionUp: true,
|
|
propagateSelectionDown: true,
|
|
rowClassName: null,
|
|
onExpand: null,
|
|
onCollapse: null,
|
|
onToggle: null,
|
|
onRowClick: null,
|
|
onSelect: null,
|
|
onUnselect: null,
|
|
onSelectionChange: null,
|
|
onPropagateUp: null,
|
|
onContextMenuSelectionChange: null,
|
|
onContextMenu: null
|
|
});
|
|
|
|
function ownKeys$4(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$4(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$4(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$4(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createForOfIteratorHelper$1(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$1(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$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 _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 _createSuper$a(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$a(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$a() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var TreeTableBody = /*#__PURE__*/function (_Component) {
|
|
_inherits(TreeTableBody, _Component);
|
|
|
|
var _super = _createSuper$a(TreeTableBody);
|
|
|
|
function TreeTableBody(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, TreeTableBody);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onRowClick = _this.onRowClick.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(TreeTableBody, [{
|
|
key: "createRow",
|
|
value: function createRow(node, index) {
|
|
return /*#__PURE__*/React.createElement(TreeTableRow, {
|
|
key: node.key || JSON.stringify(node.data),
|
|
level: 0,
|
|
rowIndex: index,
|
|
selectOnEdit: this.props.selectOnEdit,
|
|
node: node,
|
|
columns: this.props.columns,
|
|
expandedKeys: this.props.expandedKeys,
|
|
onToggle: this.props.onToggle,
|
|
onExpand: this.props.onExpand,
|
|
onCollapse: this.props.onCollapse,
|
|
selectionMode: this.props.selectionMode,
|
|
selectionKeys: this.props.selectionKeys,
|
|
onSelectionChange: this.props.onSelectionChange,
|
|
metaKeySelection: this.props.metaKeySelection,
|
|
onRowClick: this.onRowClick,
|
|
onSelect: this.props.onSelect,
|
|
onUnselect: this.props.onUnselect,
|
|
propagateSelectionUp: this.props.propagateSelectionUp,
|
|
propagateSelectionDown: this.props.propagateSelectionDown,
|
|
rowClassName: this.props.rowClassName,
|
|
contextMenuSelectionKey: this.props.contextMenuSelectionKey,
|
|
onContextMenuSelectionChange: this.props.onContextMenuSelectionChange,
|
|
onContextMenu: this.props.onContextMenu
|
|
});
|
|
}
|
|
}, {
|
|
key: "flattenizeTree",
|
|
value: function flattenizeTree(nodes) {
|
|
var rows = [];
|
|
nodes = nodes || this.props.value;
|
|
|
|
var _iterator = _createForOfIteratorHelper$1(nodes),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var node = _step.value;
|
|
rows.push(node.key);
|
|
|
|
if (this.isExpandedKey(node.key)) {
|
|
rows = rows.concat(this.flattenizeTree(node.children));
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
|
|
return rows;
|
|
}
|
|
}, {
|
|
key: "isExpandedKey",
|
|
value: function isExpandedKey(key) {
|
|
return this.props.expandedKeys && !!this.props.expandedKeys[key];
|
|
}
|
|
}, {
|
|
key: "onRowClick",
|
|
value: function onRowClick(event, node) {
|
|
var _this2 = this;
|
|
|
|
if (this.props.onRowClick) {
|
|
this.props.onRowClick({
|
|
originalEvent: event,
|
|
node: node
|
|
});
|
|
}
|
|
|
|
var targetNode = event.target.nodeName;
|
|
|
|
if (targetNode === 'INPUT' || targetNode === 'BUTTON' || targetNode === 'A' || DomHandler.hasClass(event.target, 'p-clickable') || DomHandler.hasClass(event.target, 'p-treetable-toggler') || DomHandler.hasClass(event.target.parentElement, 'p-treetable-toggler')) {
|
|
return;
|
|
}
|
|
|
|
if ((this.isSingleSelectionMode() || this.isMultipleSelectionMode()) && node.selectable !== false) {
|
|
var selectionKeys;
|
|
var selected = this.isSelected(node);
|
|
var metaSelection = this.nodeTouched ? false : this.props.metaKeySelection;
|
|
var flatKeys = this.flattenizeTree();
|
|
var rowIndex = flatKeys.findIndex(function (key) {
|
|
return key === node.key;
|
|
});
|
|
|
|
if (this.isMultipleSelectionMode() && event.shiftKey) {
|
|
DomHandler.clearSelection(); // find first selected row
|
|
|
|
var anchorRowIndex = flatKeys.findIndex(function (key) {
|
|
return _this2.props.selectionKeys[key];
|
|
});
|
|
var rangeStart = Math.min(rowIndex, anchorRowIndex);
|
|
var rangeEnd = Math.max(rowIndex, anchorRowIndex);
|
|
selectionKeys = _objectSpread$4({}, this.props.selectionKeys);
|
|
|
|
for (var i = rangeStart; i <= rangeEnd; i++) {
|
|
var rowKey = flatKeys[i];
|
|
selectionKeys[rowKey] = true;
|
|
}
|
|
} else {
|
|
this.anchorRowIndex = rowIndex;
|
|
|
|
if (metaSelection) {
|
|
var metaKey = event.metaKey || event.ctrlKey;
|
|
|
|
if (selected && metaKey) {
|
|
if (this.isSingleSelectionMode()) {
|
|
selectionKeys = null;
|
|
} else {
|
|
selectionKeys = _objectSpread$4({}, this.props.selectionKeys);
|
|
delete selectionKeys[node.key];
|
|
}
|
|
|
|
if (this.props.onUnselect) {
|
|
this.props.onUnselect({
|
|
originalEvent: event,
|
|
node: node
|
|
});
|
|
}
|
|
} else {
|
|
if (this.isSingleSelectionMode()) {
|
|
selectionKeys = node.key;
|
|
} else if (this.isMultipleSelectionMode()) {
|
|
selectionKeys = !metaKey ? {} : this.props.selectionKeys ? _objectSpread$4({}, this.props.selectionKeys) : {};
|
|
selectionKeys[node.key] = true;
|
|
}
|
|
|
|
if (this.props.onSelect) {
|
|
this.props.onSelect({
|
|
originalEvent: event,
|
|
node: node
|
|
});
|
|
}
|
|
}
|
|
} else {
|
|
if (this.isSingleSelectionMode()) {
|
|
if (selected) {
|
|
selectionKeys = null;
|
|
|
|
if (this.props.onUnselect) {
|
|
this.props.onUnselect({
|
|
originalEvent: event,
|
|
node: node
|
|
});
|
|
}
|
|
} else {
|
|
selectionKeys = node.key;
|
|
|
|
if (this.props.onSelect) {
|
|
this.props.onSelect({
|
|
originalEvent: event,
|
|
node: node
|
|
});
|
|
}
|
|
}
|
|
} else {
|
|
if (selected) {
|
|
selectionKeys = _objectSpread$4({}, this.props.selectionKeys);
|
|
delete selectionKeys[node.key];
|
|
|
|
if (this.props.onUnselect) {
|
|
this.props.onUnselect({
|
|
originalEvent: event,
|
|
node: node
|
|
});
|
|
}
|
|
} else {
|
|
selectionKeys = this.props.selectionKeys ? _objectSpread$4({}, this.props.selectionKeys) : {};
|
|
selectionKeys[node.key] = true;
|
|
|
|
if (this.props.onSelect) {
|
|
this.props.onSelect({
|
|
originalEvent: event,
|
|
node: node
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.props.onSelectionChange) {
|
|
this.props.onSelectionChange({
|
|
originalEvent: event,
|
|
value: selectionKeys
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "isSingleSelectionMode",
|
|
value: function isSingleSelectionMode() {
|
|
return this.props.selectionMode && this.props.selectionMode === 'single';
|
|
}
|
|
}, {
|
|
key: "isMultipleSelectionMode",
|
|
value: function isMultipleSelectionMode() {
|
|
return this.props.selectionMode && this.props.selectionMode === 'multiple';
|
|
}
|
|
}, {
|
|
key: "isSelected",
|
|
value: function isSelected(node) {
|
|
if ((this.props.selectionMode === 'single' || this.props.selectionMode === 'multiple') && this.props.selectionKeys) return this.props.selectionMode === 'single' ? this.props.selectionKeys === node.key : this.props.selectionKeys[node.key] !== undefined;else return false;
|
|
}
|
|
}, {
|
|
key: "renderRows",
|
|
value: function renderRows() {
|
|
var _this3 = this;
|
|
|
|
if (this.props.paginator && !this.props.lazy) {
|
|
var rpp = this.props.rows || 0;
|
|
var startIndex = this.props.first || 0;
|
|
var endIndex = startIndex + rpp;
|
|
var rows = [];
|
|
|
|
for (var i = startIndex; i < endIndex; i++) {
|
|
var rowData = this.props.value[i];
|
|
if (rowData) rows.push(this.createRow(this.props.value[i]));else break;
|
|
}
|
|
|
|
return rows;
|
|
} else {
|
|
return this.props.value.map(function (node, index) {
|
|
return _this3.createRow(node, index);
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderEmptyMessage",
|
|
value: function renderEmptyMessage() {
|
|
if (this.props.loading) {
|
|
return null;
|
|
} else {
|
|
var colSpan = this.props.columns ? this.props.columns.length : null;
|
|
var content = this.props.emptyMessage || localeOption('emptyMessage');
|
|
return /*#__PURE__*/React.createElement("tr", null, /*#__PURE__*/React.createElement("td", {
|
|
className: "p-treetable-emptymessage",
|
|
colSpan: colSpan
|
|
}, content));
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var content = this.props.value && this.props.value.length ? this.renderRows() : this.renderEmptyMessage();
|
|
return /*#__PURE__*/React.createElement("tbody", {
|
|
className: "p-treetable-tbody"
|
|
}, content);
|
|
}
|
|
}]);
|
|
|
|
return TreeTableBody;
|
|
}(Component);
|
|
|
|
_defineProperty(TreeTableBody, "defaultProps", {
|
|
value: null,
|
|
columns: null,
|
|
expandedKeys: null,
|
|
contextMenuSelectionKey: null,
|
|
paginator: false,
|
|
first: null,
|
|
rows: null,
|
|
selectionMode: null,
|
|
selectionKeys: null,
|
|
metaKeySelection: true,
|
|
propagateSelectionUp: true,
|
|
propagateSelectionDown: true,
|
|
lazy: false,
|
|
rowClassName: null,
|
|
emptyMessage: null,
|
|
loading: false,
|
|
onExpand: null,
|
|
onCollapse: null,
|
|
onToggle: null,
|
|
onRowClick: null,
|
|
onSelect: null,
|
|
onUnselect: null,
|
|
onSelectionChange: null,
|
|
onContextMenuSelectionChange: null,
|
|
onContextMenu: null
|
|
});
|
|
|
|
function _createSuper$9(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$9(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$9() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var TreeTableFooter = /*#__PURE__*/function (_Component) {
|
|
_inherits(TreeTableFooter, _Component);
|
|
|
|
var _super = _createSuper$9(TreeTableFooter);
|
|
|
|
function TreeTableFooter() {
|
|
_classCallCheck(this, TreeTableFooter);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
_createClass(TreeTableFooter, [{
|
|
key: "renderFooterCell",
|
|
value: function renderFooterCell(column, index) {
|
|
return /*#__PURE__*/React.createElement("td", {
|
|
key: column.field || index,
|
|
className: column.props.footerClassName || column.props.className,
|
|
style: column.props.footerStyle || column.props.style,
|
|
rowSpan: column.props.rowSpan,
|
|
colSpan: column.props.colSpan
|
|
}, column.props.footer);
|
|
}
|
|
}, {
|
|
key: "renderFooterRow",
|
|
value: function renderFooterRow(row, index) {
|
|
var _this = this;
|
|
|
|
var rowColumns = React.Children.toArray(row.props.children);
|
|
var rowFooterCells = rowColumns.map(function (col, index) {
|
|
return _this.renderFooterCell(col, index);
|
|
});
|
|
return /*#__PURE__*/React.createElement("tr", {
|
|
key: index
|
|
}, rowFooterCells);
|
|
}
|
|
}, {
|
|
key: "renderColumnGroup",
|
|
value: function renderColumnGroup() {
|
|
var _this2 = this;
|
|
|
|
var rows = React.Children.toArray(this.props.columnGroup.props.children);
|
|
return rows.map(function (row, i) {
|
|
return _this2.renderFooterRow(row, i);
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderColumns",
|
|
value: function renderColumns(columns) {
|
|
var _this3 = this;
|
|
|
|
if (columns) {
|
|
var headerCells = columns.map(function (col, index) {
|
|
return _this3.renderFooterCell(col, index);
|
|
});
|
|
return /*#__PURE__*/React.createElement("tr", null, headerCells);
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "hasFooter",
|
|
value: function hasFooter() {
|
|
if (this.props.columnGroup) {
|
|
return true;
|
|
} else {
|
|
for (var i = 0; i < this.props.columns.length; i++) {
|
|
if (this.props.columns[i].props.footer) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var content = this.props.columnGroup ? this.renderColumnGroup() : this.renderColumns(this.props.columns);
|
|
|
|
if (this.hasFooter()) {
|
|
return /*#__PURE__*/React.createElement("tfoot", {
|
|
className: "p-treetable-tfoot"
|
|
}, content);
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return TreeTableFooter;
|
|
}(Component);
|
|
|
|
_defineProperty(TreeTableFooter, "defaultProps", {
|
|
columns: null,
|
|
columnGroup: null
|
|
});
|
|
|
|
function _createSuper$8(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$8(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$8() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var TreeTableScrollableView = /*#__PURE__*/function (_Component) {
|
|
_inherits(TreeTableScrollableView, _Component);
|
|
|
|
var _super = _createSuper$8(TreeTableScrollableView);
|
|
|
|
function TreeTableScrollableView(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, TreeTableScrollableView);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.onHeaderScroll = _this.onHeaderScroll.bind(_assertThisInitialized(_this));
|
|
_this.onBodyScroll = _this.onBodyScroll.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(TreeTableScrollableView, [{
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.setScrollHeight();
|
|
|
|
if (!this.props.frozen) {
|
|
var scrollBarWidth = DomHandler.calculateScrollbarWidth();
|
|
this.scrollHeaderBox.style.marginRight = scrollBarWidth + 'px';
|
|
|
|
if (this.scrollFooterBox) {
|
|
this.scrollFooterBox.style.marginRight = scrollBarWidth + 'px';
|
|
}
|
|
} else {
|
|
this.scrollBody.style.paddingBottom = DomHandler.calculateScrollbarWidth() + 'px';
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate() {
|
|
this.setScrollHeight();
|
|
}
|
|
}, {
|
|
key: "setScrollHeight",
|
|
value: function setScrollHeight() {
|
|
if (this.props.scrollHeight) {
|
|
if (this.props.scrollHeight.indexOf('%') !== -1) {
|
|
var datatableContainer = this.findDataTableContainer(this.container);
|
|
this.scrollBody.style.visibility = 'hidden';
|
|
this.scrollBody.style.height = '100px'; //temporary height to calculate static height
|
|
|
|
var containerHeight = DomHandler.getOuterHeight(datatableContainer);
|
|
var relativeHeight = DomHandler.getOuterHeight(datatableContainer.parentElement) * parseInt(this.props.scrollHeight, 10) / 100;
|
|
var staticHeight = containerHeight - 100; //total height of headers, footers, paginators
|
|
|
|
var scrollBodyHeight = relativeHeight - staticHeight;
|
|
this.scrollBody.style.height = 'auto';
|
|
this.scrollBody.style.maxHeight = scrollBodyHeight + 'px';
|
|
this.scrollBody.style.visibility = 'visible';
|
|
} else {
|
|
this.scrollBody.style.maxHeight = this.props.scrollHeight;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "findDataTableContainer",
|
|
value: function findDataTableContainer(element) {
|
|
if (element) {
|
|
var el = element;
|
|
|
|
while (el && !DomHandler.hasClass(el, 'p-treetable')) {
|
|
el = el.parentElement;
|
|
}
|
|
|
|
return el;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "onHeaderScroll",
|
|
value: function onHeaderScroll() {
|
|
this.scrollHeader.scrollLeft = 0;
|
|
}
|
|
}, {
|
|
key: "onBodyScroll",
|
|
value: function onBodyScroll() {
|
|
var frozenView = this.container.previousElementSibling;
|
|
var frozenScrollBody;
|
|
|
|
if (frozenView) {
|
|
frozenScrollBody = DomHandler.findSingle(frozenView, '.p-treetable-scrollable-body');
|
|
}
|
|
|
|
this.scrollHeaderBox.style.marginLeft = -1 * this.scrollBody.scrollLeft + 'px';
|
|
|
|
if (this.scrollFooterBox) {
|
|
this.scrollFooterBox.style.marginLeft = -1 * this.scrollBody.scrollLeft + 'px';
|
|
}
|
|
|
|
if (frozenScrollBody) {
|
|
frozenScrollBody.scrollTop = this.scrollBody.scrollTop;
|
|
}
|
|
}
|
|
}, {
|
|
key: "calculateRowHeight",
|
|
value: function calculateRowHeight() {
|
|
var row = DomHandler.findSingle(this.scrollTable, 'tr:not(.p-treetable-emptymessage-row)');
|
|
|
|
if (row) {
|
|
this.rowHeight = DomHandler.getOuterHeight(row);
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderColGroup",
|
|
value: function renderColGroup() {
|
|
if (this.props.columns && this.props.columns.length) {
|
|
return /*#__PURE__*/React.createElement("colgroup", {
|
|
className: "p-treetable-scrollable-colgroup"
|
|
}, this.props.columns.map(function (col, i) {
|
|
return /*#__PURE__*/React.createElement("col", {
|
|
key: col.field + '_' + i
|
|
});
|
|
}));
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this2 = this;
|
|
|
|
var className = classNames('p-treetable-scrollable-view', {
|
|
'p-treetable-frozen-view': this.props.frozen,
|
|
'p-treetable-unfrozen-view': !this.props.frozen && this.props.frozenWidth
|
|
});
|
|
var width = this.props.frozen ? this.props.frozenWidth : 'calc(100% - ' + this.props.frozenWidth + ')';
|
|
var left = this.props.frozen ? null : this.props.frozenWidth;
|
|
var colGroup = this.renderColGroup();
|
|
var scrollableBodyStyle = !this.props.frozen && this.props.scrollHeight ? {
|
|
overflowY: 'scroll'
|
|
} : null;
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: className,
|
|
style: {
|
|
width: width,
|
|
left: left
|
|
},
|
|
ref: function ref(el) {
|
|
_this2.container = el;
|
|
}
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-treetable-scrollable-header",
|
|
ref: function ref(el) {
|
|
_this2.scrollHeader = el;
|
|
},
|
|
onScroll: this.onHeaderScroll
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-treetable-scrollable-header-box",
|
|
ref: function ref(el) {
|
|
_this2.scrollHeaderBox = el;
|
|
}
|
|
}, /*#__PURE__*/React.createElement("table", {
|
|
className: "p-treetable-scrollable-header-table"
|
|
}, colGroup, this.props.header))), /*#__PURE__*/React.createElement("div", {
|
|
className: "p-treetable-scrollable-body",
|
|
ref: function ref(el) {
|
|
_this2.scrollBody = el;
|
|
},
|
|
style: scrollableBodyStyle,
|
|
onScroll: this.onBodyScroll
|
|
}, /*#__PURE__*/React.createElement("table", {
|
|
ref: function ref(el) {
|
|
_this2.scrollTable = el;
|
|
},
|
|
style: {
|
|
top: '0'
|
|
},
|
|
className: "p-treetable-scrollable-body-table"
|
|
}, colGroup, this.props.body)), /*#__PURE__*/React.createElement("div", {
|
|
className: "p-treetable-scrollable-footer",
|
|
ref: function ref(el) {
|
|
_this2.scrollFooter = el;
|
|
}
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-treetable-scrollable-footer-box",
|
|
ref: function ref(el) {
|
|
_this2.scrollFooterBox = el;
|
|
}
|
|
}, /*#__PURE__*/React.createElement("table", {
|
|
className: "p-treetable-scrollable-footer-table"
|
|
}, colGroup, this.props.footer))));
|
|
}
|
|
}]);
|
|
|
|
return TreeTableScrollableView;
|
|
}(Component);
|
|
|
|
_defineProperty(TreeTableScrollableView, "defaultProps", {
|
|
header: null,
|
|
body: null,
|
|
footer: null,
|
|
columns: null,
|
|
frozen: null,
|
|
frozenWidth: null,
|
|
frozenBody: null
|
|
});
|
|
|
|
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; }
|
|
|
|
function ownKeys$3(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$3(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$3(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$3(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$7(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$7(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$7() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var TreeTable = /*#__PURE__*/function (_Component) {
|
|
_inherits(TreeTable, _Component);
|
|
|
|
var _super = _createSuper$7(TreeTable);
|
|
|
|
function TreeTable(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, TreeTable);
|
|
|
|
_this = _super.call(this, props);
|
|
var state = {};
|
|
|
|
if (!_this.props.onToggle) {
|
|
_this.state = {
|
|
expandedKeys: _this.props.expandedKeys
|
|
};
|
|
}
|
|
|
|
if (!_this.props.onPage) {
|
|
state.first = props.first;
|
|
state.rows = props.rows;
|
|
}
|
|
|
|
if (!_this.props.onSort) {
|
|
state.sortField = props.sortField;
|
|
state.sortOrder = props.sortOrder;
|
|
state.multiSortMeta = props.multiSortMeta;
|
|
}
|
|
|
|
if (!_this.props.onFilter) {
|
|
state.filters = props.filters;
|
|
}
|
|
|
|
if (Object.keys(state).length) {
|
|
_this.state = state;
|
|
}
|
|
|
|
_this.onToggle = _this.onToggle.bind(_assertThisInitialized(_this));
|
|
_this.onPageChange = _this.onPageChange.bind(_assertThisInitialized(_this));
|
|
_this.onSort = _this.onSort.bind(_assertThisInitialized(_this));
|
|
_this.onFilter = _this.onFilter.bind(_assertThisInitialized(_this));
|
|
_this.onColumnResizeStart = _this.onColumnResizeStart.bind(_assertThisInitialized(_this));
|
|
_this.onColumnDragStart = _this.onColumnDragStart.bind(_assertThisInitialized(_this));
|
|
_this.onColumnDragOver = _this.onColumnDragOver.bind(_assertThisInitialized(_this));
|
|
_this.onColumnDragLeave = _this.onColumnDragLeave.bind(_assertThisInitialized(_this));
|
|
_this.onColumnDrop = _this.onColumnDrop.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(TreeTable, [{
|
|
key: "onToggle",
|
|
value: function onToggle(event) {
|
|
if (this.props.onToggle) {
|
|
this.props.onToggle(event);
|
|
} else {
|
|
this.setState({
|
|
expandedKeys: event.value
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onPageChange",
|
|
value: function onPageChange(event) {
|
|
if (this.props.onPage) this.props.onPage(event);else this.setState({
|
|
first: event.first,
|
|
rows: event.rows
|
|
});
|
|
}
|
|
}, {
|
|
key: "onSort",
|
|
value: function onSort(event) {
|
|
var sortField = event.sortField;
|
|
var sortOrder = this.props.defaultSortOrder;
|
|
var multiSortMeta;
|
|
var eventMeta;
|
|
this.columnSortable = event.sortable;
|
|
this.columnSortFunction = event.sortFunction;
|
|
this.columnField = event.sortField;
|
|
|
|
if (this.props.sortMode === 'multiple') {
|
|
var metaKey = event.originalEvent.metaKey || event.originalEvent.ctrlKey;
|
|
multiSortMeta = this.getMultiSortMeta();
|
|
|
|
if (multiSortMeta && multiSortMeta instanceof Array) {
|
|
var sortMeta = multiSortMeta.find(function (sortMeta) {
|
|
return sortMeta.field === sortField;
|
|
});
|
|
sortOrder = sortMeta ? this.getCalculatedSortOrder(sortMeta.order) : sortOrder;
|
|
}
|
|
|
|
var newMetaData = {
|
|
field: sortField,
|
|
order: sortOrder
|
|
};
|
|
|
|
if (sortOrder) {
|
|
if (!multiSortMeta || !metaKey) {
|
|
multiSortMeta = [];
|
|
}
|
|
|
|
this.addSortMeta(newMetaData, multiSortMeta);
|
|
} else if (this.props.removableSort && multiSortMeta) {
|
|
this.removeSortMeta(newMetaData, multiSortMeta);
|
|
}
|
|
|
|
eventMeta = {
|
|
multiSortMeta: multiSortMeta
|
|
};
|
|
} else {
|
|
sortOrder = this.getSortField() === sortField ? this.getCalculatedSortOrder(this.getSortOrder()) : sortOrder;
|
|
|
|
if (this.props.removableSort) {
|
|
sortField = sortOrder ? sortField : null;
|
|
}
|
|
|
|
eventMeta = {
|
|
sortField: sortField,
|
|
sortOrder: sortOrder
|
|
};
|
|
}
|
|
|
|
if (this.props.onSort) {
|
|
this.props.onSort(eventMeta);
|
|
} else {
|
|
eventMeta.first = 0;
|
|
this.setState(eventMeta);
|
|
}
|
|
}
|
|
}, {
|
|
key: "getCalculatedSortOrder",
|
|
value: function getCalculatedSortOrder(currentOrder) {
|
|
return this.props.removableSort ? this.props.defaultSortOrder === currentOrder ? currentOrder * -1 : 0 : currentOrder * -1;
|
|
}
|
|
}, {
|
|
key: "addSortMeta",
|
|
value: function addSortMeta(meta, multiSortMeta) {
|
|
var index = -1;
|
|
|
|
for (var i = 0; i < multiSortMeta.length; i++) {
|
|
if (multiSortMeta[i].field === meta.field) {
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (index >= 0) multiSortMeta[index] = meta;else multiSortMeta.push(meta);
|
|
}
|
|
}, {
|
|
key: "removeSortMeta",
|
|
value: function removeSortMeta(meta, multiSortMeta) {
|
|
var index = -1;
|
|
|
|
for (var i = 0; i < multiSortMeta.length; i++) {
|
|
if (multiSortMeta[i].field === meta.field) {
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (index >= 0) {
|
|
multiSortMeta.splice(index, 1);
|
|
}
|
|
|
|
multiSortMeta = multiSortMeta.length > 0 ? multiSortMeta : null;
|
|
}
|
|
}, {
|
|
key: "sortSingle",
|
|
value: function sortSingle(data) {
|
|
return this.sortNodes(data);
|
|
}
|
|
}, {
|
|
key: "sortNodes",
|
|
value: function sortNodes(data) {
|
|
var _this2 = this;
|
|
|
|
var value = _toConsumableArray(data);
|
|
|
|
if (this.columnSortable && this.columnSortable === 'custom' && this.columnSortFunction) {
|
|
value = this.columnSortFunction({
|
|
field: this.getSortField(),
|
|
order: this.getSortOrder()
|
|
});
|
|
} else {
|
|
value.sort(function (node1, node2) {
|
|
var sortField = _this2.getSortField();
|
|
|
|
var value1 = ObjectUtils.resolveFieldData(node1.data, sortField);
|
|
var value2 = ObjectUtils.resolveFieldData(node2.data, sortField);
|
|
var result = null;
|
|
if (value1 == null && value2 != null) result = -1;else if (value1 != null && value2 == null) result = 1;else if (value1 == null && value2 == null) result = 0;else if (typeof value1 === 'string' && typeof value2 === 'string') result = value1.localeCompare(value2, undefined, {
|
|
numeric: true
|
|
});else result = value1 < value2 ? -1 : value1 > value2 ? 1 : 0;
|
|
return _this2.getSortOrder() * result;
|
|
});
|
|
|
|
for (var i = 0; i < value.length; i++) {
|
|
if (value[i].children && value[i].children.length) {
|
|
value[i].children = this.sortNodes(value[i].children);
|
|
}
|
|
}
|
|
}
|
|
|
|
return value;
|
|
}
|
|
}, {
|
|
key: "sortMultiple",
|
|
value: function sortMultiple(data) {
|
|
var multiSortMeta = this.getMultiSortMeta();
|
|
if (multiSortMeta) return this.sortMultipleNodes(data, multiSortMeta);else return data;
|
|
}
|
|
}, {
|
|
key: "sortMultipleNodes",
|
|
value: function sortMultipleNodes(data, multiSortMeta) {
|
|
var _this3 = this;
|
|
|
|
var value = _toConsumableArray(data);
|
|
|
|
value.sort(function (node1, node2) {
|
|
return _this3.multisortField(node1, node2, multiSortMeta, 0);
|
|
});
|
|
|
|
for (var i = 0; i < value.length; i++) {
|
|
if (value[i].children && value[i].children.length) {
|
|
value[i].children = this.sortMultipleNodes(value[i].children, multiSortMeta);
|
|
}
|
|
}
|
|
|
|
return value;
|
|
}
|
|
}, {
|
|
key: "multisortField",
|
|
value: function multisortField(node1, node2, multiSortMeta, index) {
|
|
var value1 = ObjectUtils.resolveFieldData(node1.data, multiSortMeta[index].field);
|
|
var value2 = ObjectUtils.resolveFieldData(node2.data, multiSortMeta[index].field);
|
|
var result = null;
|
|
if (value1 == null && value2 != null) result = -1;else if (value1 != null && value2 == null) result = 1;else if (value1 == null && value2 == null) result = 0;else {
|
|
if (value1 === value2) {
|
|
return multiSortMeta.length - 1 > index ? this.multisortField(node1, node2, multiSortMeta, index + 1) : 0;
|
|
} else {
|
|
if ((typeof value1 === 'string' || value1 instanceof String) && (typeof value2 === 'string' || value2 instanceof String)) return multiSortMeta[index].order * value1.localeCompare(value2, undefined, {
|
|
numeric: true
|
|
});else result = value1 < value2 ? -1 : 1;
|
|
}
|
|
}
|
|
return multiSortMeta[index].order * result;
|
|
}
|
|
}, {
|
|
key: "filter",
|
|
value: function filter(value, field, mode) {
|
|
this.onFilter({
|
|
value: value,
|
|
field: field,
|
|
matchMode: mode
|
|
});
|
|
}
|
|
}, {
|
|
key: "onFilter",
|
|
value: function onFilter(event) {
|
|
var currentFilters = this.getFilters();
|
|
var newFilters = currentFilters ? _objectSpread$3({}, currentFilters) : {};
|
|
if (!this.isFilterBlank(event.value)) newFilters[event.field] = {
|
|
value: event.value,
|
|
matchMode: event.matchMode
|
|
};else if (newFilters[event.field]) delete newFilters[event.field];
|
|
|
|
if (this.props.onFilter) {
|
|
this.props.onFilter({
|
|
filters: newFilters
|
|
});
|
|
} else {
|
|
this.setState({
|
|
first: 0,
|
|
filters: newFilters
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "hasFilter",
|
|
value: function hasFilter() {
|
|
var filters = this.getFilters();
|
|
return filters && Object.keys(filters).length > 0;
|
|
}
|
|
}, {
|
|
key: "isFilterBlank",
|
|
value: function isFilterBlank(filter) {
|
|
if (filter !== null && filter !== undefined) {
|
|
if (typeof filter === 'string' && filter.trim().length === 0 || filter instanceof Array && filter.length === 0) return true;else return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}, {
|
|
key: "onColumnResizeStart",
|
|
value: function onColumnResizeStart(event) {
|
|
var containerLeft = DomHandler.getOffset(this.container).left;
|
|
this.resizeColumn = event.columnEl;
|
|
this.resizeColumnProps = event.column;
|
|
this.columnResizing = true;
|
|
this.lastResizerHelperX = event.originalEvent.pageX - containerLeft + this.container.scrollLeft;
|
|
this.bindColumnResizeEvents();
|
|
}
|
|
}, {
|
|
key: "onColumnResize",
|
|
value: function onColumnResize(event) {
|
|
var containerLeft = DomHandler.getOffset(this.container).left;
|
|
DomHandler.addClass(this.container, 'p-unselectable-text');
|
|
this.resizerHelper.style.height = this.container.offsetHeight + 'px';
|
|
this.resizerHelper.style.top = 0 + 'px';
|
|
this.resizerHelper.style.left = event.pageX - containerLeft + this.container.scrollLeft + 'px';
|
|
this.resizerHelper.style.display = 'block';
|
|
}
|
|
}, {
|
|
key: "onColumnResizeEnd",
|
|
value: function onColumnResizeEnd(event) {
|
|
var delta = this.resizerHelper.offsetLeft - this.lastResizerHelperX;
|
|
var columnWidth = this.resizeColumn.offsetWidth;
|
|
var newColumnWidth = columnWidth + delta;
|
|
var minWidth = this.resizeColumn.style.minWidth || 15;
|
|
|
|
if (columnWidth + delta > parseInt(minWidth, 10)) {
|
|
if (this.props.columnResizeMode === 'fit') {
|
|
var nextColumn = this.resizeColumn.nextElementSibling;
|
|
var nextColumnWidth = nextColumn.offsetWidth - delta;
|
|
|
|
if (newColumnWidth > 15 && nextColumnWidth > 15) {
|
|
if (this.props.scrollable) {
|
|
var scrollableView = this.findParentScrollableView(this.resizeColumn);
|
|
var scrollableBodyTable = DomHandler.findSingle(scrollableView, 'table.p-treetable-scrollable-body-table');
|
|
var scrollableHeaderTable = DomHandler.findSingle(scrollableView, 'table.p-treetable-scrollable-header-table');
|
|
var scrollableFooterTable = DomHandler.findSingle(scrollableView, 'table.p-treetable-scrollable-footer-table');
|
|
var resizeColumnIndex = DomHandler.index(this.resizeColumn);
|
|
this.resizeColGroup(scrollableHeaderTable, resizeColumnIndex, newColumnWidth, nextColumnWidth);
|
|
this.resizeColGroup(scrollableBodyTable, resizeColumnIndex, newColumnWidth, nextColumnWidth);
|
|
this.resizeColGroup(scrollableFooterTable, resizeColumnIndex, newColumnWidth, nextColumnWidth);
|
|
} else {
|
|
this.resizeColumn.style.width = newColumnWidth + 'px';
|
|
|
|
if (nextColumn) {
|
|
nextColumn.style.width = nextColumnWidth + 'px';
|
|
}
|
|
}
|
|
}
|
|
} else if (this.props.columnResizeMode === 'expand') {
|
|
if (this.props.scrollable) {
|
|
var _scrollableView = this.findParentScrollableView(this.resizeColumn);
|
|
|
|
var _scrollableBodyTable = DomHandler.findSingle(_scrollableView, 'table.p-treetable-scrollable-body-table');
|
|
|
|
var _scrollableHeaderTable = DomHandler.findSingle(_scrollableView, 'table.p-treetable-scrollable-header-table');
|
|
|
|
var _scrollableFooterTable = DomHandler.findSingle(_scrollableView, 'table.p-treetable-scrollable-footer-table');
|
|
|
|
_scrollableBodyTable.style.width = _scrollableBodyTable.offsetWidth + delta + 'px';
|
|
_scrollableHeaderTable.style.width = _scrollableHeaderTable.offsetWidth + delta + 'px';
|
|
|
|
if (_scrollableFooterTable) {
|
|
_scrollableFooterTable.style.width = _scrollableHeaderTable.offsetWidth + delta + 'px';
|
|
}
|
|
|
|
var _resizeColumnIndex = DomHandler.index(this.resizeColumn);
|
|
|
|
this.resizeColGroup(_scrollableHeaderTable, _resizeColumnIndex, newColumnWidth, null);
|
|
this.resizeColGroup(_scrollableBodyTable, _resizeColumnIndex, newColumnWidth, null);
|
|
this.resizeColGroup(_scrollableFooterTable, _resizeColumnIndex, newColumnWidth, null);
|
|
} else {
|
|
this.table.style.width = this.table.offsetWidth + delta + 'px';
|
|
this.resizeColumn.style.width = newColumnWidth + 'px';
|
|
}
|
|
}
|
|
|
|
if (this.props.onColumnResizeEnd) {
|
|
this.props.onColumnResizeEnd({
|
|
element: this.resizeColumn,
|
|
column: this.resizeColumnProps,
|
|
delta: delta
|
|
});
|
|
}
|
|
}
|
|
|
|
this.resizerHelper.style.display = 'none';
|
|
this.resizeColumn = null;
|
|
this.resizeColumnProps = null;
|
|
DomHandler.removeClass(this.container, 'p-unselectable-text');
|
|
this.unbindColumnResizeEvents();
|
|
}
|
|
}, {
|
|
key: "findParentScrollableView",
|
|
value: function findParentScrollableView(column) {
|
|
if (column) {
|
|
var parent = column.parentElement;
|
|
|
|
while (parent && !DomHandler.hasClass(parent, 'p-treetable-scrollable-view')) {
|
|
parent = parent.parentElement;
|
|
}
|
|
|
|
return parent;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "resizeColGroup",
|
|
value: function resizeColGroup(table, resizeColumnIndex, newColumnWidth, nextColumnWidth) {
|
|
if (table) {
|
|
var colGroup = table.children[0].nodeName === 'COLGROUP' ? table.children[0] : null;
|
|
|
|
if (colGroup) {
|
|
var col = colGroup.children[resizeColumnIndex];
|
|
var nextCol = col.nextElementSibling;
|
|
col.style.width = newColumnWidth + 'px';
|
|
|
|
if (nextCol && nextColumnWidth) {
|
|
nextCol.style.width = nextColumnWidth + 'px';
|
|
}
|
|
} else {
|
|
throw new Error("Scrollable tables require a colgroup to support resizable columns");
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindColumnResizeEvents",
|
|
value: function bindColumnResizeEvents() {
|
|
var _this4 = this;
|
|
|
|
this.documentColumnResizeListener = document.addEventListener('mousemove', function (event) {
|
|
if (_this4.columnResizing) {
|
|
_this4.onColumnResize(event);
|
|
}
|
|
});
|
|
this.documentColumnResizeEndListener = document.addEventListener('mouseup', function (event) {
|
|
if (_this4.columnResizing) {
|
|
_this4.columnResizing = false;
|
|
|
|
_this4.onColumnResizeEnd(event);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "unbindColumnResizeEvents",
|
|
value: function unbindColumnResizeEvents() {
|
|
document.removeEventListener('document', this.documentColumnResizeListener);
|
|
document.removeEventListener('document', this.documentColumnResizeEndListener);
|
|
}
|
|
}, {
|
|
key: "onColumnDragStart",
|
|
value: function onColumnDragStart(e) {
|
|
var event = e.originalEvent,
|
|
column = e.column;
|
|
|
|
if (this.columnResizing) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
|
|
this.iconWidth = DomHandler.getHiddenElementOuterWidth(this.reorderIndicatorUp);
|
|
this.iconHeight = DomHandler.getHiddenElementOuterHeight(this.reorderIndicatorUp);
|
|
this.draggedColumnEl = this.findParentHeader(event.currentTarget);
|
|
this.draggedColumn = column;
|
|
event.dataTransfer.setData('text', 'b'); // Firefox requires this to make dragging possible
|
|
}
|
|
}, {
|
|
key: "onColumnDragOver",
|
|
value: function onColumnDragOver(e) {
|
|
var event = e.originalEvent;
|
|
var dropHeader = this.findParentHeader(event.currentTarget);
|
|
|
|
if (this.props.reorderableColumns && this.draggedColumnEl && dropHeader) {
|
|
event.preventDefault();
|
|
var containerOffset = DomHandler.getOffset(this.container);
|
|
var dropHeaderOffset = DomHandler.getOffset(dropHeader);
|
|
|
|
if (this.draggedColumnEl !== dropHeader) {
|
|
var targetLeft = dropHeaderOffset.left - containerOffset.left; //let targetTop = containerOffset.top - dropHeaderOffset.top;
|
|
|
|
var columnCenter = dropHeaderOffset.left + dropHeader.offsetWidth / 2;
|
|
this.reorderIndicatorUp.style.top = dropHeaderOffset.top - containerOffset.top - (this.iconHeight - 1) + 'px';
|
|
this.reorderIndicatorDown.style.top = dropHeaderOffset.top - containerOffset.top + dropHeader.offsetHeight + 'px';
|
|
|
|
if (event.pageX > columnCenter) {
|
|
this.reorderIndicatorUp.style.left = targetLeft + dropHeader.offsetWidth - Math.ceil(this.iconWidth / 2) + 'px';
|
|
this.reorderIndicatorDown.style.left = targetLeft + dropHeader.offsetWidth - Math.ceil(this.iconWidth / 2) + 'px';
|
|
this.dropPosition = 1;
|
|
} else {
|
|
this.reorderIndicatorUp.style.left = targetLeft - Math.ceil(this.iconWidth / 2) + 'px';
|
|
this.reorderIndicatorDown.style.left = targetLeft - Math.ceil(this.iconWidth / 2) + 'px';
|
|
this.dropPosition = -1;
|
|
}
|
|
|
|
this.reorderIndicatorUp.style.display = 'block';
|
|
this.reorderIndicatorDown.style.display = 'block';
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "onColumnDragLeave",
|
|
value: function onColumnDragLeave(e) {
|
|
var event = e.originalEvent;
|
|
|
|
if (this.props.reorderableColumns && this.draggedColumnEl) {
|
|
event.preventDefault();
|
|
this.reorderIndicatorUp.style.display = 'none';
|
|
this.reorderIndicatorDown.style.display = 'none';
|
|
}
|
|
}
|
|
}, {
|
|
key: "onColumnDrop",
|
|
value: function onColumnDrop(e) {
|
|
var _this5 = this;
|
|
|
|
var event = e.originalEvent,
|
|
column = e.column;
|
|
event.preventDefault();
|
|
|
|
if (this.draggedColumnEl) {
|
|
var dragIndex = DomHandler.index(this.draggedColumnEl);
|
|
var dropIndex = DomHandler.index(this.findParentHeader(event.currentTarget));
|
|
var allowDrop = dragIndex !== dropIndex;
|
|
|
|
if (allowDrop && (dropIndex - dragIndex === 1 && this.dropPosition === -1 || dragIndex - dropIndex === 1 && this.dropPosition === 1)) {
|
|
allowDrop = false;
|
|
}
|
|
|
|
if (allowDrop) {
|
|
var columns = this.state.columnOrder ? this.getColumns() : React.Children.toArray(this.props.children);
|
|
|
|
var isSameColumn = function isSameColumn(col1, col2) {
|
|
return col1.props.columnKey || col2.props.columnKey ? ObjectUtils.equals(col1, col2, 'props.columnKey') : ObjectUtils.equals(col1, col2, 'props.field');
|
|
};
|
|
|
|
var dragColIndex = columns.findIndex(function (child) {
|
|
return isSameColumn(child, _this5.draggedColumn);
|
|
});
|
|
var dropColIndex = columns.findIndex(function (child) {
|
|
return isSameColumn(child, column);
|
|
});
|
|
|
|
if (dropColIndex < dragColIndex && this.dropPosition === 1) {
|
|
dropColIndex++;
|
|
}
|
|
|
|
if (dropColIndex > dragColIndex && this.dropPosition === -1) {
|
|
dropColIndex--;
|
|
}
|
|
|
|
ObjectUtils.reorderArray(columns, dragColIndex, dropColIndex);
|
|
var columnOrder = [];
|
|
|
|
var _iterator = _createForOfIteratorHelper(columns),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var _column = _step.value;
|
|
columnOrder.push(_column.props.columnKey || _column.props.field);
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
|
|
this.setState({
|
|
columnOrder: columnOrder
|
|
});
|
|
|
|
if (this.props.onColReorder) {
|
|
this.props.onColReorder({
|
|
dragIndex: dragColIndex,
|
|
dropIndex: dropColIndex,
|
|
columns: columns
|
|
});
|
|
}
|
|
}
|
|
|
|
this.reorderIndicatorUp.style.display = 'none';
|
|
this.reorderIndicatorDown.style.display = 'none';
|
|
this.draggedColumnEl.draggable = false;
|
|
this.draggedColumnEl = null;
|
|
this.dropPosition = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "findParentHeader",
|
|
value: function findParentHeader(element) {
|
|
if (element.nodeName === 'TH') {
|
|
return element;
|
|
} else {
|
|
var parent = element.parentElement;
|
|
|
|
while (parent.nodeName !== 'TH') {
|
|
parent = parent.parentElement;
|
|
if (!parent) break;
|
|
}
|
|
|
|
return parent;
|
|
}
|
|
}
|
|
}, {
|
|
key: "getExpandedKeys",
|
|
value: function getExpandedKeys() {
|
|
return this.props.onToggle ? this.props.expandedKeys : this.state.expandedKeys;
|
|
}
|
|
}, {
|
|
key: "getFirst",
|
|
value: function getFirst() {
|
|
return this.props.onPage ? this.props.first : this.state.first;
|
|
}
|
|
}, {
|
|
key: "getRows",
|
|
value: function getRows() {
|
|
return this.props.onPage ? this.props.rows : this.state.rows;
|
|
}
|
|
}, {
|
|
key: "getSortField",
|
|
value: function getSortField() {
|
|
return this.props.onSort ? this.props.sortField : this.state.sortField;
|
|
}
|
|
}, {
|
|
key: "getSortOrder",
|
|
value: function getSortOrder() {
|
|
return this.props.onSort ? this.props.sortOrder : this.state.sortOrder;
|
|
}
|
|
}, {
|
|
key: "getMultiSortMeta",
|
|
value: function getMultiSortMeta() {
|
|
return this.props.onSort ? this.props.multiSortMeta : this.state.multiSortMeta;
|
|
}
|
|
}, {
|
|
key: "getFilters",
|
|
value: function getFilters() {
|
|
return this.props.onFilter ? this.props.filters : this.state.filters;
|
|
}
|
|
}, {
|
|
key: "findColumnByKey",
|
|
value: function findColumnByKey(columns, key) {
|
|
if (columns && columns.length) {
|
|
for (var i = 0; i < columns.length; i++) {
|
|
var child = columns[i];
|
|
|
|
if (child.props.columnKey === key || child.props.field === key) {
|
|
return child;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "getColumns",
|
|
value: function getColumns() {
|
|
var columns = React.Children.toArray(this.props.children);
|
|
|
|
if (columns && columns.length) {
|
|
if (this.props.reorderableColumns && this.state.columnOrder) {
|
|
var orderedColumns = [];
|
|
|
|
var _iterator2 = _createForOfIteratorHelper(this.state.columnOrder),
|
|
_step2;
|
|
|
|
try {
|
|
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
|
|
var columnKey = _step2.value;
|
|
var column = this.findColumnByKey(columns, columnKey);
|
|
|
|
if (column) {
|
|
orderedColumns.push(column);
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator2.e(err);
|
|
} finally {
|
|
_iterator2.f();
|
|
}
|
|
|
|
return [].concat(orderedColumns, _toConsumableArray(columns.filter(function (item) {
|
|
return orderedColumns.indexOf(item) < 0;
|
|
})));
|
|
} else {
|
|
return columns;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "getTotalRecords",
|
|
value: function getTotalRecords(data) {
|
|
return this.props.lazy ? this.props.totalRecords : data ? data.length : 0;
|
|
}
|
|
}, {
|
|
key: "isSingleSelectionMode",
|
|
value: function isSingleSelectionMode() {
|
|
return this.props.selectionMode && this.props.selectionMode === 'single';
|
|
}
|
|
}, {
|
|
key: "isMultipleSelectionMode",
|
|
value: function isMultipleSelectionMode() {
|
|
return this.props.selectionMode && this.props.selectionMode === 'multiple';
|
|
}
|
|
}, {
|
|
key: "isRowSelectionMode",
|
|
value: function isRowSelectionMode() {
|
|
return this.isSingleSelectionMode() || this.isMultipleSelectionMode();
|
|
}
|
|
}, {
|
|
key: "getFrozenColumns",
|
|
value: function getFrozenColumns(columns) {
|
|
var frozenColumns = null;
|
|
|
|
var _iterator3 = _createForOfIteratorHelper(columns),
|
|
_step3;
|
|
|
|
try {
|
|
for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
|
|
var col = _step3.value;
|
|
|
|
if (col.props.frozen) {
|
|
frozenColumns = frozenColumns || [];
|
|
frozenColumns.push(col);
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator3.e(err);
|
|
} finally {
|
|
_iterator3.f();
|
|
}
|
|
|
|
return frozenColumns;
|
|
}
|
|
}, {
|
|
key: "getScrollableColumns",
|
|
value: function getScrollableColumns(columns) {
|
|
var scrollableColumns = null;
|
|
|
|
var _iterator4 = _createForOfIteratorHelper(columns),
|
|
_step4;
|
|
|
|
try {
|
|
for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
|
|
var col = _step4.value;
|
|
|
|
if (!col.props.frozen) {
|
|
scrollableColumns = scrollableColumns || [];
|
|
scrollableColumns.push(col);
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator4.e(err);
|
|
} finally {
|
|
_iterator4.f();
|
|
}
|
|
|
|
return scrollableColumns;
|
|
}
|
|
}, {
|
|
key: "filterLocal",
|
|
value: function filterLocal(value) {
|
|
var filteredNodes = [];
|
|
var filters = this.getFilters();
|
|
var columns = React.Children.toArray(this.props.children);
|
|
var isStrictMode = this.props.filterMode === 'strict';
|
|
|
|
var _iterator5 = _createForOfIteratorHelper(value),
|
|
_step5;
|
|
|
|
try {
|
|
for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
|
|
var node = _step5.value;
|
|
|
|
var copyNode = _objectSpread$3({}, node);
|
|
|
|
var localMatch = true;
|
|
var globalMatch = false;
|
|
|
|
for (var j = 0; j < columns.length; j++) {
|
|
var col = columns[j];
|
|
var filterMeta = filters ? filters[col.props.field] : null;
|
|
var filterField = col.props.field;
|
|
var filterValue = void 0,
|
|
filterConstraint = void 0,
|
|
paramsWithoutNode = void 0,
|
|
options = void 0; //local
|
|
|
|
if (filterMeta) {
|
|
var filterMatchMode = filterMeta.matchMode || col.props.filterMatchMode || 'startsWith';
|
|
filterValue = filterMeta.value;
|
|
filterConstraint = filterMatchMode === 'custom' ? col.props.filterFunction : FilterService.filters[filterMatchMode];
|
|
options = {
|
|
rowData: node,
|
|
filters: filters,
|
|
props: this.props,
|
|
column: {
|
|
filterMeta: filterMeta,
|
|
filterField: filterField,
|
|
props: col.props
|
|
}
|
|
};
|
|
paramsWithoutNode = {
|
|
filterField: filterField,
|
|
filterValue: filterValue,
|
|
filterConstraint: filterConstraint,
|
|
isStrictMode: isStrictMode,
|
|
options: options
|
|
};
|
|
|
|
if (isStrictMode && !(this.findFilteredNodes(copyNode, paramsWithoutNode) || this.isFilterMatched(copyNode, paramsWithoutNode)) || !isStrictMode && !(this.isFilterMatched(copyNode, paramsWithoutNode) || this.findFilteredNodes(copyNode, paramsWithoutNode))) {
|
|
localMatch = false;
|
|
}
|
|
|
|
if (!localMatch) {
|
|
break;
|
|
}
|
|
} //global
|
|
|
|
|
|
if (this.props.globalFilter && !globalMatch) {
|
|
var copyNodeForGlobal = _objectSpread$3({}, copyNode);
|
|
|
|
filterValue = this.props.globalFilter;
|
|
filterConstraint = FilterService.filters['contains'];
|
|
paramsWithoutNode = {
|
|
filterField: filterField,
|
|
filterValue: filterValue,
|
|
filterConstraint: filterConstraint,
|
|
isStrictMode: isStrictMode
|
|
};
|
|
|
|
if (isStrictMode && (this.findFilteredNodes(copyNodeForGlobal, paramsWithoutNode) || this.isFilterMatched(copyNodeForGlobal, paramsWithoutNode)) || !isStrictMode && (this.isFilterMatched(copyNodeForGlobal, paramsWithoutNode) || this.findFilteredNodes(copyNodeForGlobal, paramsWithoutNode))) {
|
|
globalMatch = true;
|
|
copyNode = copyNodeForGlobal;
|
|
}
|
|
}
|
|
}
|
|
|
|
var matches = localMatch;
|
|
|
|
if (this.props.globalFilter) {
|
|
matches = localMatch && globalMatch;
|
|
}
|
|
|
|
if (matches) {
|
|
filteredNodes.push(copyNode);
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator5.e(err);
|
|
} finally {
|
|
_iterator5.f();
|
|
}
|
|
|
|
return filteredNodes;
|
|
}
|
|
}, {
|
|
key: "findFilteredNodes",
|
|
value: function findFilteredNodes(node, paramsWithoutNode) {
|
|
if (node) {
|
|
var matched = false;
|
|
|
|
if (node.children) {
|
|
var childNodes = _toConsumableArray(node.children);
|
|
|
|
node.children = [];
|
|
|
|
var _iterator6 = _createForOfIteratorHelper(childNodes),
|
|
_step6;
|
|
|
|
try {
|
|
for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
|
|
var childNode = _step6.value;
|
|
|
|
var copyChildNode = _objectSpread$3({}, childNode);
|
|
|
|
if (this.isFilterMatched(copyChildNode, paramsWithoutNode)) {
|
|
matched = true;
|
|
node.children.push(copyChildNode);
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator6.e(err);
|
|
} finally {
|
|
_iterator6.f();
|
|
}
|
|
}
|
|
|
|
if (matched) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "isFilterMatched",
|
|
value: function isFilterMatched(node, _ref) {
|
|
var filterField = _ref.filterField,
|
|
filterValue = _ref.filterValue,
|
|
filterConstraint = _ref.filterConstraint,
|
|
isStrictMode = _ref.isStrictMode,
|
|
options = _ref.options;
|
|
var matched = false;
|
|
var dataFieldValue = ObjectUtils.resolveFieldData(node.data, filterField);
|
|
|
|
if (filterConstraint(dataFieldValue, filterValue, this.props.filterLocale, options)) {
|
|
matched = true;
|
|
}
|
|
|
|
if (!matched || isStrictMode && !this.isNodeLeaf(node)) {
|
|
matched = this.findFilteredNodes(node, {
|
|
filterField: filterField,
|
|
filterValue: filterValue,
|
|
filterConstraint: filterConstraint,
|
|
isStrictMode: isStrictMode
|
|
}) || matched;
|
|
}
|
|
|
|
return matched;
|
|
}
|
|
}, {
|
|
key: "isNodeLeaf",
|
|
value: function isNodeLeaf(node) {
|
|
return node.leaf === false ? false : !(node.children && node.children.length);
|
|
}
|
|
}, {
|
|
key: "processValue",
|
|
value: function processValue() {
|
|
var data = this.props.value;
|
|
|
|
if (!this.props.lazy) {
|
|
if (data && data.length) {
|
|
if (this.getSortField() || this.getMultiSortMeta()) {
|
|
if (this.props.sortMode === 'single') data = this.sortSingle(data);else if (this.props.sortMode === 'multiple') data = this.sortMultiple(data);
|
|
}
|
|
|
|
var localFilters = this.getFilters();
|
|
|
|
if (localFilters || this.props.globalFilter) {
|
|
data = this.filterLocal(data, localFilters);
|
|
}
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
}, {
|
|
key: "createTableHeader",
|
|
value: function createTableHeader(columns, columnGroup) {
|
|
return /*#__PURE__*/React.createElement(TreeTableHeader, {
|
|
columns: columns,
|
|
columnGroup: columnGroup,
|
|
tabIndex: this.props.tabIndex,
|
|
onSort: this.onSort,
|
|
sortField: this.getSortField(),
|
|
sortOrder: this.getSortOrder(),
|
|
multiSortMeta: this.getMultiSortMeta(),
|
|
resizableColumns: this.props.resizableColumns,
|
|
onResizeStart: this.onColumnResizeStart,
|
|
reorderableColumns: this.props.reorderableColumns,
|
|
onDragStart: this.onColumnDragStart,
|
|
onDragOver: this.onColumnDragOver,
|
|
onDragLeave: this.onColumnDragLeave,
|
|
onDrop: this.onColumnDrop,
|
|
onFilter: this.onFilter,
|
|
filters: this.getFilters(),
|
|
filterDelay: this.props.filterDelay
|
|
});
|
|
}
|
|
}, {
|
|
key: "createTableFooter",
|
|
value: function createTableFooter(columns, columnGroup) {
|
|
return /*#__PURE__*/React.createElement(TreeTableFooter, {
|
|
columns: columns,
|
|
columnGroup: columnGroup
|
|
});
|
|
}
|
|
}, {
|
|
key: "createTableBody",
|
|
value: function createTableBody(value, columns) {
|
|
return /*#__PURE__*/React.createElement(TreeTableBody, {
|
|
value: value,
|
|
columns: columns,
|
|
expandedKeys: this.getExpandedKeys(),
|
|
selectOnEdit: this.props.selectOnEdit,
|
|
onToggle: this.onToggle,
|
|
onExpand: this.props.onExpand,
|
|
onCollapse: this.props.onCollapse,
|
|
paginator: this.props.paginator,
|
|
first: this.getFirst(),
|
|
rows: this.getRows(),
|
|
selectionMode: this.props.selectionMode,
|
|
selectionKeys: this.props.selectionKeys,
|
|
onSelectionChange: this.props.onSelectionChange,
|
|
metaKeySelection: this.props.metaKeySelection,
|
|
onRowClick: this.props.onRowClick,
|
|
onSelect: this.props.onSelect,
|
|
onUnselect: this.props.onUnselect,
|
|
propagateSelectionUp: this.props.propagateSelectionUp,
|
|
propagateSelectionDown: this.props.propagateSelectionDown,
|
|
lazy: this.props.lazy,
|
|
rowClassName: this.props.rowClassName,
|
|
emptyMessage: this.props.emptyMessage,
|
|
loading: this.props.loading,
|
|
contextMenuSelectionKey: this.props.contextMenuSelectionKey,
|
|
onContextMenuSelectionChange: this.props.onContextMenuSelectionChange,
|
|
onContextMenu: this.props.onContextMenu
|
|
});
|
|
}
|
|
}, {
|
|
key: "createPaginator",
|
|
value: function createPaginator(position, totalRecords) {
|
|
var className = classNames('p-paginator-' + position, this.props.paginatorClassName);
|
|
return /*#__PURE__*/React.createElement(Paginator, {
|
|
first: this.getFirst(),
|
|
rows: this.getRows(),
|
|
pageLinkSize: this.props.pageLinkSize,
|
|
className: className,
|
|
onPageChange: this.onPageChange,
|
|
template: this.props.paginatorTemplate,
|
|
totalRecords: totalRecords,
|
|
rowsPerPageOptions: this.props.rowsPerPageOptions,
|
|
currentPageReportTemplate: this.props.currentPageReportTemplate,
|
|
leftContent: this.props.paginatorLeft,
|
|
rightContent: this.props.paginatorRight,
|
|
alwaysShow: this.props.alwaysShowPaginator,
|
|
dropdownAppendTo: this.props.paginatorDropdownAppendTo
|
|
});
|
|
}
|
|
}, {
|
|
key: "createScrollableView",
|
|
value: function createScrollableView(value, columns, frozen, headerColumnGroup, footerColumnGroup) {
|
|
var header = this.createTableHeader(columns, headerColumnGroup);
|
|
var footer = this.createTableFooter(columns, footerColumnGroup);
|
|
var body = this.createTableBody(value, columns);
|
|
return /*#__PURE__*/React.createElement(TreeTableScrollableView, {
|
|
columns: columns,
|
|
header: header,
|
|
body: body,
|
|
footer: footer,
|
|
scrollHeight: this.props.scrollHeight,
|
|
frozen: frozen,
|
|
frozenWidth: this.props.frozenWidth
|
|
});
|
|
}
|
|
}, {
|
|
key: "renderScrollableTable",
|
|
value: function renderScrollableTable(value) {
|
|
var columns = this.getColumns();
|
|
var frozenColumns = this.getFrozenColumns(columns);
|
|
var scrollableColumns = frozenColumns ? this.getScrollableColumns(columns) : columns;
|
|
var frozenView, scrollableView;
|
|
|
|
if (frozenColumns) {
|
|
frozenView = this.createScrollableView(value, frozenColumns, true, this.props.frozenHeaderColumnGroup, this.props.frozenFooterColumnGroup);
|
|
}
|
|
|
|
scrollableView = this.createScrollableView(value, scrollableColumns, false, this.props.headerColumnGroup, this.props.footerColumnGroup);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-treetable-scrollable-wrapper"
|
|
}, frozenView, scrollableView);
|
|
}
|
|
}, {
|
|
key: "renderRegularTable",
|
|
value: function renderRegularTable(value) {
|
|
var _this6 = this;
|
|
|
|
var columns = this.getColumns();
|
|
var header = this.createTableHeader(columns, this.props.headerColumnGroup);
|
|
var footer = this.createTableFooter(columns, this.props.footerColumnGroup);
|
|
var body = this.createTableBody(value, columns);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-treetable-wrapper"
|
|
}, /*#__PURE__*/React.createElement("table", {
|
|
style: this.props.tableStyle,
|
|
className: this.props.tableClassName,
|
|
ref: function ref(el) {
|
|
return _this6.table = el;
|
|
}
|
|
}, header, footer, body));
|
|
}
|
|
}, {
|
|
key: "renderTable",
|
|
value: function renderTable(value) {
|
|
if (this.props.scrollable) return this.renderScrollableTable(value);else return this.renderRegularTable(value);
|
|
}
|
|
}, {
|
|
key: "renderLoader",
|
|
value: function renderLoader() {
|
|
if (this.props.loading) {
|
|
var iconClassName = classNames('p-treetable-loading-icon pi-spin', this.props.loadingIcon);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-treetable-loading"
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-treetable-loading-overlay p-component-overlay"
|
|
}, /*#__PURE__*/React.createElement("i", {
|
|
className: iconClassName
|
|
})));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this7 = this;
|
|
|
|
var value = this.processValue();
|
|
var className = classNames('p-treetable p-component', {
|
|
'p-treetable-hoverable-rows': this.props.rowHover,
|
|
'p-treetable-selectable': this.isRowSelectionMode(),
|
|
'p-treetable-resizable': this.props.resizableColumns,
|
|
'p-treetable-resizable-fit': this.props.resizableColumns && this.props.columnResizeMode === 'fit',
|
|
'p-treetable-auto-layout': this.props.autoLayout,
|
|
'p-treetable-striped': this.props.stripedRows,
|
|
'p-treetable-gridlines': this.props.showGridlines
|
|
}, this.props.className);
|
|
var table = this.renderTable(value);
|
|
var totalRecords = this.getTotalRecords(value);
|
|
var headerFacet = this.props.header && /*#__PURE__*/React.createElement("div", {
|
|
className: "p-treetable-header"
|
|
}, this.props.header);
|
|
var footerFacet = this.props.footer && /*#__PURE__*/React.createElement("div", {
|
|
className: "p-treetable-footer"
|
|
}, this.props.footer);
|
|
var paginatorTop = this.props.paginator && this.props.paginatorPosition !== 'bottom' && this.createPaginator('top', totalRecords);
|
|
var paginatorBottom = this.props.paginator && this.props.paginatorPosition !== 'top' && this.createPaginator('bottom', totalRecords);
|
|
var loader = this.renderLoader();
|
|
var resizeHelper = this.props.resizableColumns && /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
_this7.resizerHelper = el;
|
|
},
|
|
className: "p-column-resizer-helper",
|
|
style: {
|
|
display: 'none'
|
|
}
|
|
});
|
|
var reorderIndicatorUp = this.props.reorderableColumns && /*#__PURE__*/React.createElement("span", {
|
|
ref: function ref(el) {
|
|
return _this7.reorderIndicatorUp = el;
|
|
},
|
|
className: "pi pi-arrow-down p-datatable-reorder-indicator-up",
|
|
style: {
|
|
position: 'absolute',
|
|
display: 'none'
|
|
}
|
|
});
|
|
var reorderIndicatorDown = this.props.reorderableColumns && /*#__PURE__*/React.createElement("span", {
|
|
ref: function ref(el) {
|
|
return _this7.reorderIndicatorDown = el;
|
|
},
|
|
className: "pi pi-arrow-up p-datatable-reorder-indicator-down",
|
|
style: {
|
|
position: 'absolute',
|
|
display: 'none'
|
|
}
|
|
});
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style,
|
|
ref: function ref(el) {
|
|
return _this7.container = el;
|
|
},
|
|
"data-scrollselectors": ".p-treetable-scrollable-body"
|
|
}, loader, headerFacet, paginatorTop, table, paginatorBottom, footerFacet, resizeHelper, reorderIndicatorUp, reorderIndicatorDown);
|
|
}
|
|
}]);
|
|
|
|
return TreeTable;
|
|
}(Component);
|
|
|
|
_defineProperty(TreeTable, "defaultProps", {
|
|
id: null,
|
|
value: null,
|
|
header: null,
|
|
footer: null,
|
|
style: null,
|
|
className: null,
|
|
tableStyle: null,
|
|
tableClassName: null,
|
|
expandedKeys: null,
|
|
paginator: false,
|
|
paginatorPosition: 'bottom',
|
|
alwaysShowPaginator: true,
|
|
paginatorClassName: null,
|
|
paginatorTemplate: 'FirstPageLink PrevPageLink PageLinks NextPageLink LastPageLink RowsPerPageDropdown',
|
|
paginatorLeft: null,
|
|
paginatorRight: null,
|
|
paginatorDropdownAppendTo: null,
|
|
pageLinkSize: 5,
|
|
rowsPerPageOptions: null,
|
|
currentPageReportTemplate: '({currentPage} of {totalPages})',
|
|
first: null,
|
|
rows: null,
|
|
totalRecords: null,
|
|
lazy: false,
|
|
sortField: null,
|
|
sortOrder: null,
|
|
multiSortMeta: null,
|
|
sortMode: 'single',
|
|
defaultSortOrder: 1,
|
|
removableSort: false,
|
|
selectionMode: null,
|
|
selectionKeys: null,
|
|
contextMenuSelectionKey: null,
|
|
metaKeySelection: true,
|
|
selectOnEdit: true,
|
|
propagateSelectionUp: true,
|
|
propagateSelectionDown: true,
|
|
autoLayout: false,
|
|
rowClassName: null,
|
|
loading: false,
|
|
loadingIcon: 'pi pi-spinner',
|
|
tabIndex: 0,
|
|
scrollable: false,
|
|
scrollHeight: null,
|
|
reorderableColumns: false,
|
|
headerColumnGroup: null,
|
|
footerColumnGroup: null,
|
|
frozenHeaderColumnGroup: null,
|
|
frozenFooterColumnGroup: null,
|
|
frozenWidth: null,
|
|
resizableColumns: false,
|
|
columnResizeMode: 'fit',
|
|
emptyMessage: null,
|
|
filters: null,
|
|
globalFilter: null,
|
|
filterMode: 'lenient',
|
|
filterDelay: 300,
|
|
filterLocale: undefined,
|
|
rowHover: false,
|
|
showGridlines: false,
|
|
stripedRows: false,
|
|
onFilter: null,
|
|
onExpand: null,
|
|
onCollapse: null,
|
|
onToggle: null,
|
|
onPage: null,
|
|
onSort: null,
|
|
onSelect: null,
|
|
onUnselect: null,
|
|
onRowClick: null,
|
|
onSelectionChange: null,
|
|
onContextMenuSelectionChange: null,
|
|
onColumnResizeEnd: null,
|
|
onColReorder: null,
|
|
onContextMenu: null
|
|
});
|
|
|
|
function ownKeys$2(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$2(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$2(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$2(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
|
|
|
|
function _createSuper$6(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$6(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$6() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var TriStateCheckbox = /*#__PURE__*/function (_Component) {
|
|
_inherits(TriStateCheckbox, _Component);
|
|
|
|
var _super = _createSuper$6(TriStateCheckbox);
|
|
|
|
function TriStateCheckbox(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, TriStateCheckbox);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
focused: false
|
|
};
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onFocus = _this.onFocus.bind(_assertThisInitialized(_this));
|
|
_this.onBlur = _this.onBlur.bind(_assertThisInitialized(_this));
|
|
_this.inputRef = /*#__PURE__*/createRef(_this.props.inputRef);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(TriStateCheckbox, [{
|
|
key: "onClick",
|
|
value: function onClick(event) {
|
|
if (!this.props.disabled) {
|
|
this.toggle(event);
|
|
this.inputRef.current.focus();
|
|
}
|
|
}
|
|
}, {
|
|
key: "toggle",
|
|
value: function toggle(event) {
|
|
var newValue;
|
|
if (this.props.value === null || this.props.value === undefined) newValue = true;else if (this.props.value === true) newValue = false;else if (this.props.value === false) newValue = null;
|
|
|
|
if (this.props.onChange) {
|
|
this.props.onChange({
|
|
originalEvent: event,
|
|
value: newValue,
|
|
stopPropagation: function stopPropagation() {},
|
|
preventDefault: function preventDefault() {},
|
|
target: {
|
|
name: this.props.name,
|
|
id: this.props.id,
|
|
value: newValue
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "onFocus",
|
|
value: function onFocus() {
|
|
this.setState({
|
|
focused: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "onBlur",
|
|
value: function onBlur() {
|
|
this.setState({
|
|
focused: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "updateInputRef",
|
|
value: function updateInputRef() {
|
|
var ref = this.props.inputRef;
|
|
|
|
if (ref) {
|
|
if (typeof ref === 'function') {
|
|
ref(this.inputRef.current);
|
|
} else {
|
|
ref.current = this.inputRef.current;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.updateInputRef();
|
|
|
|
if (this.props.tooltip && !this.props.disabled) {
|
|
this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.tooltip !== this.props.tooltip || prevProps.tooltipOptions !== this.props.tooltipOptions) {
|
|
if (this.tooltip) this.tooltip.update(_objectSpread$2({
|
|
content: this.props.tooltip
|
|
}, this.props.tooltipOptions || {}));else this.renderTooltip();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.tooltip) {
|
|
this.tooltip.destroy();
|
|
this.tooltip = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderTooltip",
|
|
value: function renderTooltip() {
|
|
this.tooltip = tip({
|
|
target: this.element,
|
|
content: this.props.tooltip,
|
|
options: this.props.tooltipOptions
|
|
});
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this2 = this;
|
|
|
|
var containerClass = classNames('p-tristatecheckbox p-checkbox p-component', this.props.className);
|
|
var boxClass = classNames('p-checkbox-box', {
|
|
'p-highlight': (this.props.value || !this.props.value) && this.props.value !== null,
|
|
'p-disabled': this.props.disabled,
|
|
'p-focus': this.state.focused
|
|
});
|
|
var iconClass = classNames('p-checkbox-icon p-c', {
|
|
'pi pi-check': this.props.value === true,
|
|
'pi pi-times': this.props.value === false
|
|
});
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this2.element = el;
|
|
},
|
|
id: this.props.id,
|
|
className: containerClass,
|
|
style: this.props.style,
|
|
onClick: this.onClick
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-hidden-accessible"
|
|
}, /*#__PURE__*/React.createElement("input", {
|
|
ref: this.inputRef,
|
|
type: "checkbox",
|
|
"aria-labelledby": this.props.ariaLabelledBy,
|
|
id: this.props.inputId,
|
|
name: this.props.name,
|
|
onFocus: this.onFocus,
|
|
onBlur: this.onBlur,
|
|
disabled: this.props.disabled,
|
|
defaultChecked: this.props.value
|
|
})), /*#__PURE__*/React.createElement("div", {
|
|
className: boxClass,
|
|
ref: function ref(el) {
|
|
return _this2.box = el;
|
|
},
|
|
role: "checkbox",
|
|
"aria-checked": this.props.value === true
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: iconClass
|
|
})));
|
|
}
|
|
}]);
|
|
|
|
return TriStateCheckbox;
|
|
}(Component);
|
|
|
|
_defineProperty(TriStateCheckbox, "defaultProps", {
|
|
id: null,
|
|
inputRef: null,
|
|
inputId: null,
|
|
value: null,
|
|
name: null,
|
|
style: null,
|
|
className: null,
|
|
disabled: false,
|
|
tooltip: null,
|
|
tooltipOptions: null,
|
|
ariaLabelledBy: null,
|
|
onChange: null
|
|
});
|
|
|
|
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 _createSuper$5(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$5(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$5() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var SpeedDial = /*#__PURE__*/function (_Component) {
|
|
_inherits(SpeedDial, _Component);
|
|
|
|
var _super = _createSuper$5(SpeedDial);
|
|
|
|
function SpeedDial(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, SpeedDial);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
visible: false
|
|
};
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onItemClick = _this.onItemClick.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(SpeedDial, [{
|
|
key: "isVisible",
|
|
value: function isVisible() {
|
|
return this.props.onVisibleChange ? this.props.visible : this.state.visible;
|
|
}
|
|
}, {
|
|
key: "show",
|
|
value: function show() {
|
|
if (this.props.onVisibleChange) {
|
|
this.props.onVisibleChange(true);
|
|
} else {
|
|
this.setState({
|
|
visible: true
|
|
});
|
|
}
|
|
|
|
this.props.onShow && this.props.onShow();
|
|
}
|
|
}, {
|
|
key: "hide",
|
|
value: function hide() {
|
|
if (this.props.onVisibleChange) {
|
|
this.props.onVisibleChange(false);
|
|
} else {
|
|
this.setState({
|
|
visible: false
|
|
});
|
|
}
|
|
|
|
this.props.onHide && this.props.onHide();
|
|
}
|
|
}, {
|
|
key: "onClick",
|
|
value: function onClick(e) {
|
|
this.isVisible() ? this.hide() : this.show();
|
|
this.props.onClick && this.props.onClick(e);
|
|
this.isItemClicked = true;
|
|
}
|
|
}, {
|
|
key: "onItemClick",
|
|
value: function onItemClick(e, item) {
|
|
if (item.command) {
|
|
item.command({
|
|
originalEvent: e,
|
|
item: item
|
|
});
|
|
}
|
|
|
|
this.hide();
|
|
this.isItemClicked = true;
|
|
e.preventDefault();
|
|
}
|
|
}, {
|
|
key: "bindDocumentClickListener",
|
|
value: function bindDocumentClickListener() {
|
|
var _this2 = this;
|
|
|
|
if (!this.documentClickListener) {
|
|
this.documentClickListener = function (event) {
|
|
if (_this2.isVisible() && _this2.isOutsideClicked(event)) {
|
|
_this2.hide();
|
|
}
|
|
|
|
_this2.isItemClicked = false;
|
|
};
|
|
|
|
document.addEventListener('click', this.documentClickListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentClickListener",
|
|
value: function unbindDocumentClickListener() {
|
|
if (this.documentClickListener) {
|
|
document.removeEventListener('click', this.documentClickListener);
|
|
this.documentClickListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "isOutsideClicked",
|
|
value: function isOutsideClicked(event) {
|
|
return this.container && !(this.container.isSameNode(event.target) || this.container.contains(event.target) || this.isItemClicked);
|
|
}
|
|
}, {
|
|
key: "calculateTransitionDelay",
|
|
value: function calculateTransitionDelay(index) {
|
|
var length = this.props.model.length;
|
|
var visible = this.isVisible();
|
|
return (visible ? index : length - index - 1) * this.props.transitionDelay;
|
|
}
|
|
}, {
|
|
key: "calculatePointStyle",
|
|
value: function calculatePointStyle(index) {
|
|
var type = this.props.type;
|
|
|
|
if (type !== 'linear') {
|
|
var length = this.props.model.length;
|
|
var radius = this.props.radius || length * 20;
|
|
|
|
if (type === 'circle') {
|
|
var step = 2 * Math.PI / length;
|
|
return {
|
|
left: "calc(".concat(radius * Math.cos(step * index), "px + var(--item-diff-x, 0px))"),
|
|
top: "calc(".concat(radius * Math.sin(step * index), "px + var(--item-diff-y, 0px))")
|
|
};
|
|
} else if (type === 'semi-circle') {
|
|
var direction = this.props.direction;
|
|
|
|
var _step = Math.PI / (length - 1);
|
|
|
|
var x = "calc(".concat(radius * Math.cos(_step * index), "px + var(--item-diff-x, 0px))");
|
|
var y = "calc(".concat(radius * Math.sin(_step * index), "px + var(--item-diff-y, 0px))");
|
|
|
|
if (direction === 'up') {
|
|
return {
|
|
left: x,
|
|
bottom: y
|
|
};
|
|
} else if (direction === 'down') {
|
|
return {
|
|
left: x,
|
|
top: y
|
|
};
|
|
} else if (direction === 'left') {
|
|
return {
|
|
right: y,
|
|
top: x
|
|
};
|
|
} else if (direction === 'right') {
|
|
return {
|
|
left: y,
|
|
top: x
|
|
};
|
|
}
|
|
} else if (type === 'quarter-circle') {
|
|
var _direction = this.props.direction;
|
|
|
|
var _step2 = Math.PI / (2 * (length - 1));
|
|
|
|
var _x = "calc(".concat(radius * Math.cos(_step2 * index), "px + var(--item-diff-x, 0px))");
|
|
|
|
var _y = "calc(".concat(radius * Math.sin(_step2 * index), "px + var(--item-diff-y, 0px))");
|
|
|
|
if (_direction === 'up-left') {
|
|
return {
|
|
right: _x,
|
|
bottom: _y
|
|
};
|
|
} else if (_direction === 'up-right') {
|
|
return {
|
|
left: _x,
|
|
bottom: _y
|
|
};
|
|
} else if (_direction === 'down-left') {
|
|
return {
|
|
right: _y,
|
|
top: _x
|
|
};
|
|
} else if (_direction === 'down-right') {
|
|
return {
|
|
left: _y,
|
|
top: _x
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
return {};
|
|
}
|
|
}, {
|
|
key: "getItemStyle",
|
|
value: function getItemStyle(index) {
|
|
var transitionDelay = this.calculateTransitionDelay(index);
|
|
var pointStyle = this.calculatePointStyle(index);
|
|
return _objectSpread$1({
|
|
transitionDelay: "".concat(transitionDelay, "ms")
|
|
}, pointStyle);
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (this.props.type !== 'linear') {
|
|
var button = DomHandler.findSingle(this.container, '.p-speeddial-button');
|
|
var firstItem = DomHandler.findSingle(this.list, '.p-speeddial-item');
|
|
|
|
if (button && firstItem) {
|
|
var wDiff = Math.abs(button.offsetWidth - firstItem.offsetWidth);
|
|
var hDiff = Math.abs(button.offsetHeight - firstItem.offsetHeight);
|
|
this.list.style.setProperty('--item-diff-x', "".concat(wDiff / 2, "px"));
|
|
this.list.style.setProperty('--item-diff-y', "".concat(hDiff / 2, "px"));
|
|
}
|
|
}
|
|
|
|
if (this.props.hideOnClickOutside) {
|
|
this.bindDocumentClickListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.props.hideOnClickOutside) {
|
|
this.unbindDocumentClickListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderItem",
|
|
value: function renderItem(item, index) {
|
|
var _this3 = this;
|
|
|
|
var style = this.getItemStyle(index);
|
|
var disabled = item.disabled,
|
|
_icon = item.icon,
|
|
label = item.label,
|
|
template = item.template,
|
|
url = item.url,
|
|
target = item.target;
|
|
var contentClassName = classNames('p-speeddial-action', {
|
|
'p-disabled': disabled
|
|
});
|
|
var iconClassName = classNames('p-speeddial-action-icon', _icon);
|
|
|
|
var icon = _icon && /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
});
|
|
|
|
var content = /*#__PURE__*/React.createElement("a", {
|
|
href: url || '#',
|
|
role: "menuitem",
|
|
className: contentClassName,
|
|
target: target,
|
|
"data-pr-tooltip": label,
|
|
onClick: function onClick(e) {
|
|
return _this3.onItemClick(e, item);
|
|
}
|
|
}, icon, /*#__PURE__*/React.createElement(Ripple, null));
|
|
|
|
if (template) {
|
|
var defaultContentOptions = {
|
|
onClick: function onClick(e) {
|
|
return _this3.onItemClick(e, item);
|
|
},
|
|
className: contentClassName,
|
|
iconClassName: iconClassName,
|
|
element: content,
|
|
props: this.props,
|
|
visible: this.isVisible()
|
|
};
|
|
content = ObjectUtils.getJSXElement(template, item, defaultContentOptions);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: index,
|
|
className: "p-speeddial-item",
|
|
style: style,
|
|
role: "none"
|
|
}, content);
|
|
}
|
|
}, {
|
|
key: "renderItems",
|
|
value: function renderItems() {
|
|
var _this4 = this;
|
|
|
|
if (this.props.model) {
|
|
return this.props.model.map(function (item, index) {
|
|
return _this4.renderItem(item, index);
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderList",
|
|
value: function renderList() {
|
|
var _this5 = this;
|
|
|
|
var items = this.renderItems();
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
ref: function ref(el) {
|
|
return _this5.list = el;
|
|
},
|
|
className: "p-speeddial-list",
|
|
role: "menu"
|
|
}, items);
|
|
}
|
|
}, {
|
|
key: "renderButton",
|
|
value: function renderButton() {
|
|
var _classNames,
|
|
_this6 = this;
|
|
|
|
var visible = this.isVisible();
|
|
var className = classNames('p-speeddial-button p-button-rounded', {
|
|
'p-speeddial-rotate': this.props.rotateAnimation && !this.props.hideIcon
|
|
}, this.props.buttonClassName);
|
|
var iconClassName = classNames((_classNames = {}, _defineProperty(_classNames, "".concat(this.props.showIcon), !visible && !!this.props.showIcon || !this.props.hideIcon), _defineProperty(_classNames, "".concat(this.props.hideIcon), visible && !!this.props.hideIcon), _classNames));
|
|
var content = /*#__PURE__*/React.createElement(Button, {
|
|
type: "button",
|
|
style: this.props.buttonStyle,
|
|
className: className,
|
|
icon: iconClassName,
|
|
onClick: this.onClick,
|
|
disabled: this.props.disabled
|
|
});
|
|
|
|
if (this.props.buttonTemplate) {
|
|
var defaultContentOptions = {
|
|
onClick: function onClick(event) {
|
|
return _this6.onClick(event);
|
|
},
|
|
className: className,
|
|
iconClassName: iconClassName,
|
|
element: content,
|
|
props: this.props,
|
|
visible: visible
|
|
};
|
|
return ObjectUtils.getJSXElement(this.props.buttonTemplate, defaultContentOptions);
|
|
}
|
|
|
|
return content;
|
|
}
|
|
}, {
|
|
key: "renderMask",
|
|
value: function renderMask() {
|
|
if (this.props.mask) {
|
|
var visible = this.isVisible();
|
|
var className = classNames('p-speeddial-mask', {
|
|
'p-speeddial-mask-visible': visible
|
|
}, this.props.maskClassName);
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: className,
|
|
style: this.props.maskStyle
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _classNames2,
|
|
_this7 = this;
|
|
|
|
var className = classNames("p-speeddial p-component p-speeddial-".concat(this.props.type), (_classNames2 = {}, _defineProperty(_classNames2, "p-speeddial-direction-".concat(this.props.direction), this.props.type !== 'circle'), _defineProperty(_classNames2, 'p-speeddial-opened', this.isVisible()), _defineProperty(_classNames2, 'p-disabled', this.props.disabled), _classNames2), this.props.className);
|
|
var button = this.renderButton();
|
|
var list = this.renderList();
|
|
var mask = this.renderMask();
|
|
return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this7.container = el;
|
|
},
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, button, list), mask);
|
|
}
|
|
}]);
|
|
|
|
return SpeedDial;
|
|
}(Component);
|
|
|
|
_defineProperty(SpeedDial, "defaultProps", {
|
|
id: null,
|
|
model: null,
|
|
visible: false,
|
|
style: null,
|
|
className: null,
|
|
direction: 'up',
|
|
transitionDelay: 30,
|
|
type: 'linear',
|
|
radius: 0,
|
|
mask: false,
|
|
disabled: false,
|
|
hideOnClickOutside: true,
|
|
buttonStyle: null,
|
|
buttonClassName: null,
|
|
buttonTemplate: null,
|
|
maskStyle: null,
|
|
maskClassName: null,
|
|
showIcon: 'pi pi-plus',
|
|
hideIcon: null,
|
|
rotateAnimation: true,
|
|
onVisibleChange: null,
|
|
onClick: null,
|
|
onShow: null,
|
|
onHide: null
|
|
});
|
|
|
|
function _createSuper$4(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$4(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$4() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var BlockUI = /*#__PURE__*/function (_Component) {
|
|
_inherits(BlockUI, _Component);
|
|
|
|
var _super = _createSuper$4(BlockUI);
|
|
|
|
function BlockUI(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, BlockUI);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
visible: props.blocked
|
|
};
|
|
_this.block = _this.block.bind(_assertThisInitialized(_this));
|
|
_this.unblock = _this.unblock.bind(_assertThisInitialized(_this));
|
|
_this.onPortalMounted = _this.onPortalMounted.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(BlockUI, [{
|
|
key: "block",
|
|
value: function block() {
|
|
this.setState({
|
|
visible: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "unblock",
|
|
value: function unblock() {
|
|
var _this2 = this;
|
|
|
|
var callback = function callback() {
|
|
_this2.setState({
|
|
visible: false
|
|
}, function () {
|
|
_this2.props.fullScreen && DomHandler.removeClass(document.body, 'p-overflow-hidden');
|
|
_this2.props.onUnblocked && _this2.props.onUnblocked();
|
|
});
|
|
};
|
|
|
|
if (this.mask) {
|
|
DomHandler.addClass(this.mask, 'p-component-overlay-leave');
|
|
this.mask.addEventListener('animationend', function () {
|
|
ZIndexUtils.clear(_this2.mask);
|
|
callback();
|
|
});
|
|
} else {
|
|
callback();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onPortalMounted",
|
|
value: function onPortalMounted() {
|
|
if (this.props.fullScreen) {
|
|
DomHandler.addClass(document.body, 'p-overflow-hidden');
|
|
document.activeElement.blur();
|
|
}
|
|
|
|
if (this.props.autoZIndex) {
|
|
var key = this.props.fullScreen ? 'modal' : 'overlay';
|
|
ZIndexUtils.set(key, this.mask, PrimeReact.autoZIndex, this.props.baseZIndex || PrimeReact.zIndex[key]);
|
|
}
|
|
|
|
this.props.onBlocked && this.props.onBlocked();
|
|
}
|
|
}, {
|
|
key: "renderMask",
|
|
value: function renderMask() {
|
|
var _this3 = this;
|
|
|
|
if (this.state.visible) {
|
|
var className = classNames('p-blockui p-component-overlay p-component-overlay-enter', {
|
|
'p-blockui-document': this.props.fullScreen
|
|
}, this.props.className);
|
|
var content = this.props.template ? ObjectUtils.getJSXElement(this.props.template, this.props) : null;
|
|
var mask = /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this3.mask = el;
|
|
},
|
|
className: className,
|
|
style: this.props.style
|
|
}, content);
|
|
return /*#__PURE__*/React.createElement(Portal, {
|
|
element: mask,
|
|
appendTo: this.props.fullScreen ? document.body : 'self',
|
|
onMounted: this.onPortalMounted
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
if (this.state.visible) {
|
|
this.block();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps, prevState) {
|
|
if (prevProps.blocked !== this.props.blocked) {
|
|
this.props.blocked ? this.block() : this.unblock();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.props.fullScreen) {
|
|
DomHandler.removeClass(document.body, 'p-overflow-hidden');
|
|
}
|
|
|
|
ZIndexUtils.clear(this.mask);
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this4 = this;
|
|
|
|
var mask = this.renderMask();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this4.container = el;
|
|
},
|
|
id: this.props.id,
|
|
className: "p-blockui-container"
|
|
}, this.props.children, mask);
|
|
}
|
|
}]);
|
|
|
|
return BlockUI;
|
|
}(Component);
|
|
|
|
_defineProperty(BlockUI, "defaultProps", {
|
|
id: null,
|
|
blocked: false,
|
|
fullScreen: false,
|
|
baseZIndex: 0,
|
|
autoZIndex: true,
|
|
style: null,
|
|
className: null,
|
|
template: null,
|
|
onBlocked: null,
|
|
onUnblocked: null
|
|
});
|
|
|
|
var TerminalService = EventBus();
|
|
|
|
function _createSuper$3(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$3(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$3() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Terminal = /*#__PURE__*/function (_Component) {
|
|
_inherits(Terminal, _Component);
|
|
|
|
var _super = _createSuper$3(Terminal);
|
|
|
|
function Terminal(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Terminal);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
commandText: '',
|
|
commands: [],
|
|
index: 0
|
|
};
|
|
_this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
|
|
_this.onInputChange = _this.onInputChange.bind(_assertThisInitialized(_this));
|
|
_this.onInputKeyDown = _this.onInputKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.response = _this.response.bind(_assertThisInitialized(_this));
|
|
_this.clear = _this.clear.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Terminal, [{
|
|
key: "onClick",
|
|
value: function onClick() {
|
|
this.input.focus();
|
|
}
|
|
}, {
|
|
key: "onInputChange",
|
|
value: function onInputChange(e) {
|
|
this.setState({
|
|
commandText: e.target.value
|
|
});
|
|
}
|
|
}, {
|
|
key: "onInputKeyDown",
|
|
value: function onInputKeyDown(e) {
|
|
var code = e.which || e.keyCode;
|
|
var commands = this.state.commands;
|
|
|
|
switch (code) {
|
|
//up
|
|
case 38:
|
|
if (commands && commands.length) {
|
|
var prevIndex = this.state.index - 1 < 0 ? commands.length - 1 : this.state.index - 1;
|
|
var command = commands[prevIndex];
|
|
this.setState({
|
|
index: prevIndex,
|
|
commandText: command.text
|
|
});
|
|
}
|
|
|
|
break;
|
|
//enter
|
|
|
|
case 13:
|
|
if (!!this.state.commandText) {
|
|
var newCommands = _toConsumableArray(commands);
|
|
|
|
var text = this.state.commandText;
|
|
newCommands.push({
|
|
text: text
|
|
});
|
|
this.setState(function (prevState) {
|
|
return {
|
|
index: prevState.index + 1,
|
|
commandText: '',
|
|
commands: newCommands
|
|
};
|
|
}, function () {
|
|
TerminalService.emit('command', text);
|
|
});
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}, {
|
|
key: "response",
|
|
value: function response(res) {
|
|
var commands = this.state.commands;
|
|
|
|
if (commands && commands.length > 0) {
|
|
var _commands = _toConsumableArray(commands);
|
|
|
|
_commands[_commands.length - 1].response = res;
|
|
this.setState({
|
|
commands: _commands
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "clear",
|
|
value: function clear() {
|
|
this.setState({
|
|
commands: [],
|
|
index: 0
|
|
});
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
TerminalService.on('response', this.response);
|
|
TerminalService.on('clear', this.clear);
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate() {
|
|
this.container.scrollTop = this.container.scrollHeight;
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
TerminalService.off('response', this.response);
|
|
TerminalService.off('clear', this.clear);
|
|
}
|
|
}, {
|
|
key: "renderWelcomeMessage",
|
|
value: function renderWelcomeMessage() {
|
|
if (this.props.welcomeMessage) {
|
|
return /*#__PURE__*/React.createElement("div", null, this.props.welcomeMessage);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderCommand",
|
|
value: function renderCommand(command, index) {
|
|
var text = command.text,
|
|
response = command.response;
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
key: "".concat(text).concat(index)
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-terminal-prompt"
|
|
}, this.props.prompt, "\xA0"), /*#__PURE__*/React.createElement("span", {
|
|
className: "p-terminal-command"
|
|
}, text), /*#__PURE__*/React.createElement("div", {
|
|
className: "p-terminal-response"
|
|
}, response));
|
|
}
|
|
}, {
|
|
key: "renderContent",
|
|
value: function renderContent() {
|
|
var _this2 = this;
|
|
|
|
var commands = this.state.commands.map(function (c, i) {
|
|
return _this2.renderCommand(c, i);
|
|
});
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-terminal-content"
|
|
}, commands);
|
|
}
|
|
}, {
|
|
key: "renderPromptContainer",
|
|
value: function renderPromptContainer() {
|
|
var _this3 = this;
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-terminal-prompt-container"
|
|
}, /*#__PURE__*/React.createElement("span", {
|
|
className: "p-terminal-prompt"
|
|
}, this.props.prompt, "\xA0"), /*#__PURE__*/React.createElement("input", {
|
|
ref: function ref(el) {
|
|
return _this3.input = el;
|
|
},
|
|
type: "text",
|
|
value: this.state.commandText,
|
|
className: "p-terminal-input",
|
|
autoComplete: "off",
|
|
onChange: this.onInputChange,
|
|
onKeyDown: this.onInputKeyDown
|
|
}));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this4 = this;
|
|
|
|
var className = classNames('p-terminal p-component', this.props.className);
|
|
var welcomeMessage = this.renderWelcomeMessage();
|
|
var content = this.renderContent();
|
|
var prompt = this.renderPromptContainer();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this4.container = el;
|
|
},
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style,
|
|
onClick: this.onClick
|
|
}, welcomeMessage, content, prompt);
|
|
}
|
|
}]);
|
|
|
|
return Terminal;
|
|
}(Component);
|
|
|
|
_defineProperty(Terminal, "defaultProps", {
|
|
id: null,
|
|
style: null,
|
|
className: null,
|
|
welcomeMessage: null,
|
|
prompt: null
|
|
});
|
|
|
|
function _createSuper$2(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$2(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$2() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Dock = /*#__PURE__*/function (_Component) {
|
|
_inherits(Dock, _Component);
|
|
|
|
var _super = _createSuper$2(Dock);
|
|
|
|
function Dock(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Dock);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
currentIndex: -3
|
|
};
|
|
_this.onListMouseLeave = _this.onListMouseLeave.bind(_assertThisInitialized(_this));
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Dock, [{
|
|
key: "onListMouseLeave",
|
|
value: function onListMouseLeave() {
|
|
this.setState({
|
|
currentIndex: -3
|
|
});
|
|
}
|
|
}, {
|
|
key: "onItemMouseEnter",
|
|
value: function onItemMouseEnter(index) {
|
|
this.setState({
|
|
currentIndex: index
|
|
});
|
|
}
|
|
}, {
|
|
key: "onItemClick",
|
|
value: function onItemClick(e, item) {
|
|
if (item.command) {
|
|
item.command({
|
|
originalEvent: e,
|
|
item: item
|
|
});
|
|
}
|
|
|
|
e.preventDefault();
|
|
}
|
|
}, {
|
|
key: "renderItem",
|
|
value: function renderItem(item, index) {
|
|
var _this2 = this;
|
|
|
|
var disabled = item.disabled,
|
|
_icon = item.icon,
|
|
label = item.label,
|
|
template = item.template,
|
|
url = item.url,
|
|
target = item.target;
|
|
var className = classNames('p-dock-item', {
|
|
'p-dock-item-second-prev': this.state.currentIndex - 2 === index,
|
|
'p-dock-item-prev': this.state.currentIndex - 1 === index,
|
|
'p-dock-item-current': this.state.currentIndex === index,
|
|
'p-dock-item-next': this.state.currentIndex + 1 === index,
|
|
'p-dock-item-second-next': this.state.currentIndex + 2 === index
|
|
});
|
|
var contentClassName = classNames('p-dock-action', {
|
|
'p-disabled': disabled
|
|
});
|
|
var iconClassName = classNames('p-dock-action-icon', _icon);
|
|
var icon = typeof _icon === 'string' ? /*#__PURE__*/React.createElement("span", {
|
|
className: iconClassName
|
|
}) : ObjectUtils.getJSXElement(_icon, this.props);
|
|
var content = /*#__PURE__*/React.createElement("a", {
|
|
href: url || '#',
|
|
role: "menuitem",
|
|
className: contentClassName,
|
|
target: target,
|
|
"data-pr-tooltip": label,
|
|
onClick: function onClick(e) {
|
|
return _this2.onItemClick(e, item);
|
|
}
|
|
}, icon, /*#__PURE__*/React.createElement(Ripple, null));
|
|
|
|
if (template) {
|
|
var defaultContentOptions = {
|
|
onClick: function onClick(e) {
|
|
return _this2.onItemClick(e, item);
|
|
},
|
|
className: contentClassName,
|
|
iconClassName: iconClassName,
|
|
element: content,
|
|
props: this.props,
|
|
index: index
|
|
};
|
|
content = ObjectUtils.getJSXElement(template, item, defaultContentOptions);
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: index,
|
|
className: className,
|
|
role: "none",
|
|
onMouseEnter: function onMouseEnter() {
|
|
return _this2.onItemMouseEnter(index);
|
|
}
|
|
}, content);
|
|
}
|
|
}, {
|
|
key: "renderItems",
|
|
value: function renderItems() {
|
|
var _this3 = this;
|
|
|
|
if (this.props.model) {
|
|
return this.props.model.map(function (item, index) {
|
|
return _this3.renderItem(item, index);
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderHeader",
|
|
value: function renderHeader() {
|
|
if (this.props.header) {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-dock-header"
|
|
}, ObjectUtils.getJSXElement(this.props.header, {
|
|
props: this.props
|
|
}));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderList",
|
|
value: function renderList() {
|
|
var _this4 = this;
|
|
|
|
var items = this.renderItems();
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
ref: function ref(el) {
|
|
return _this4.list = el;
|
|
},
|
|
className: "p-dock-list",
|
|
role: "menu",
|
|
onMouseLeave: this.onListMouseLeave
|
|
}, items);
|
|
}
|
|
}, {
|
|
key: "renderFooter",
|
|
value: function renderFooter() {
|
|
if (this.props.footer) {
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
className: "p-dock-footer"
|
|
}, ObjectUtils.getJSXElement(this.props.footer, {
|
|
props: this.props
|
|
}));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var className = classNames("p-dock p-component p-dock-".concat(this.props.position), {
|
|
'p-dock-magnification': this.props.magnification
|
|
}, this.props.className);
|
|
var header = this.renderHeader();
|
|
var list = this.renderList();
|
|
var footer = this.renderFooter();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
id: this.props.id,
|
|
className: className,
|
|
style: this.props.style
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-dock-container"
|
|
}, header, list, footer));
|
|
}
|
|
}]);
|
|
|
|
return Dock;
|
|
}(Component);
|
|
|
|
_defineProperty(Dock, "defaultProps", {
|
|
id: null,
|
|
style: null,
|
|
className: null,
|
|
model: null,
|
|
position: 'bottom',
|
|
magnification: true,
|
|
header: null,
|
|
footer: null
|
|
});
|
|
|
|
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; }
|
|
|
|
function _createSuper$1(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct$1() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Mention = /*#__PURE__*/function (_Component) {
|
|
_inherits(Mention, _Component);
|
|
|
|
var _super = _createSuper$1(Mention);
|
|
|
|
function Mention(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Mention);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
overlayVisible: false,
|
|
focused: false,
|
|
searching: false,
|
|
trigger: null
|
|
};
|
|
_this.onOverlayEnter = _this.onOverlayEnter.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEntering = _this.onOverlayEntering.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayEntered = _this.onOverlayEntered.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExit = _this.onOverlayExit.bind(_assertThisInitialized(_this));
|
|
_this.onOverlayExited = _this.onOverlayExited.bind(_assertThisInitialized(_this));
|
|
_this.onFocus = _this.onFocus.bind(_assertThisInitialized(_this));
|
|
_this.onBlur = _this.onBlur.bind(_assertThisInitialized(_this));
|
|
_this.onKeyDown = _this.onKeyDown.bind(_assertThisInitialized(_this));
|
|
_this.onChange = _this.onChange.bind(_assertThisInitialized(_this));
|
|
_this.onInput = _this.onInput.bind(_assertThisInitialized(_this));
|
|
_this.onKeyUp = _this.onKeyUp.bind(_assertThisInitialized(_this));
|
|
_this.onPanelClick = _this.onPanelClick.bind(_assertThisInitialized(_this));
|
|
_this.overlayRef = /*#__PURE__*/createRef();
|
|
_this.inputRef = /*#__PURE__*/createRef(_this.props.inputRef);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Mention, [{
|
|
key: "showOverlay",
|
|
value: function showOverlay() {
|
|
this.setState({
|
|
overlayVisible: true
|
|
});
|
|
}
|
|
}, {
|
|
key: "hideOverlay",
|
|
value: function hideOverlay() {
|
|
this.setState({
|
|
overlayVisible: false,
|
|
searching: false,
|
|
trigger: null
|
|
});
|
|
}
|
|
}, {
|
|
key: "onOverlayEnter",
|
|
value: function onOverlayEnter() {
|
|
ZIndexUtils.set('overlay', this.overlayRef.current, PrimeReact.autoZIndex, PrimeReact.zIndex['overlay']);
|
|
this.alignOverlay();
|
|
}
|
|
}, {
|
|
key: "onOverlayEntering",
|
|
value: function onOverlayEntering() {
|
|
if (this.props.autoHighlight && this.props.suggestions && this.props.suggestions.length) {
|
|
DomHandler.addClass(this.list.firstChild, 'p-highlight');
|
|
}
|
|
}
|
|
}, {
|
|
key: "onOverlayEntered",
|
|
value: function onOverlayEntered() {
|
|
this.bindDocumentClickListener();
|
|
this.bindScrollListener();
|
|
this.bindResizeListener();
|
|
this.props.onShow && this.props.onShow();
|
|
}
|
|
}, {
|
|
key: "onOverlayExit",
|
|
value: function onOverlayExit() {
|
|
this.unbindDocumentClickListener();
|
|
this.unbindScrollListener();
|
|
this.unbindResizeListener();
|
|
}
|
|
}, {
|
|
key: "onOverlayExited",
|
|
value: function onOverlayExited() {
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
this.props.onHide && this.props.onHide();
|
|
}
|
|
}, {
|
|
key: "alignOverlay",
|
|
value: function alignOverlay() {
|
|
var _this$state$trigger = this.state.trigger,
|
|
key = _this$state$trigger.key,
|
|
index = _this$state$trigger.index;
|
|
var value = this.inputRef.current.value;
|
|
var position = DomHandler.getCursorOffset(this.inputRef.current, value.substring(0, index - 1), value.substring(index), key);
|
|
this.overlayRef.current.style.transformOrigin = 'top';
|
|
this.overlayRef.current.style.left = "calc(".concat(position.left, "px + 1rem)");
|
|
this.overlayRef.current.style.top = "calc(".concat(position.top, "px + 1.2rem)");
|
|
}
|
|
}, {
|
|
key: "onPanelClick",
|
|
value: function onPanelClick(event) {
|
|
OverlayService.emit('overlay-click', {
|
|
originalEvent: event,
|
|
target: this.container
|
|
});
|
|
}
|
|
}, {
|
|
key: "getTrigger",
|
|
value: function getTrigger(value, key, start) {
|
|
if (!this.state.trigger) {
|
|
var triggerKey = Array.isArray(this.props.trigger) ? this.props.trigger.find(function (t) {
|
|
return t === key;
|
|
}) : this.props.trigger === key ? this.props.trigger : null;
|
|
|
|
if (triggerKey) {
|
|
return {
|
|
key: triggerKey,
|
|
index: start
|
|
};
|
|
}
|
|
|
|
var latestSpaceIndex = value.substring(0, start).lastIndexOf(' ');
|
|
var latestTrigger = this.getLatestTrigger(value, start);
|
|
|
|
if (latestTrigger.index > latestSpaceIndex) {
|
|
return latestTrigger;
|
|
}
|
|
}
|
|
|
|
return this.state.trigger;
|
|
}
|
|
}, {
|
|
key: "getLatestTrigger",
|
|
value: function getLatestTrigger(value, start) {
|
|
if (Array.isArray(this.props.trigger)) {
|
|
var latestTrigger = {};
|
|
this.props.trigger.forEach(function (t) {
|
|
var index = value.substring(0, start).lastIndexOf(t);
|
|
|
|
if (index !== -1 && (index > latestTrigger.index || !latestTrigger.index)) {
|
|
latestTrigger = {
|
|
key: t,
|
|
index: index !== -1 ? index + 1 : -1
|
|
};
|
|
}
|
|
});
|
|
return latestTrigger;
|
|
}
|
|
|
|
var index = value.substring(0, start).lastIndexOf(this.props.trigger);
|
|
return {
|
|
key: this.props.trigger,
|
|
index: index !== -1 ? index + 1 : -1
|
|
};
|
|
}
|
|
}, {
|
|
key: "onSearch",
|
|
value: function onSearch(event) {
|
|
var _this2 = this;
|
|
|
|
if (this.timeout) {
|
|
clearTimeout(this.timeout);
|
|
}
|
|
|
|
var _event$target = event.target,
|
|
value = _event$target.value,
|
|
selectionStart = _event$target.selectionStart;
|
|
var key = value.substring(selectionStart - 1, selectionStart);
|
|
|
|
if (key === ' ') {
|
|
this.hideOverlay();
|
|
return;
|
|
}
|
|
|
|
var currentTrigger = this.getTrigger(value, key, selectionStart);
|
|
|
|
if (currentTrigger && currentTrigger.index > -1) {
|
|
var query = value.substring(currentTrigger.index, selectionStart);
|
|
this.timeout = setTimeout(function () {
|
|
_this2.search(event, query, currentTrigger);
|
|
}, this.props.delay);
|
|
}
|
|
}
|
|
}, {
|
|
key: "search",
|
|
value: function search(event, query, trigger) {
|
|
if (this.props.onSearch) {
|
|
this.setState({
|
|
searching: true,
|
|
trigger: trigger
|
|
});
|
|
this.props.onSearch({
|
|
originalEvent: event,
|
|
trigger: trigger.key,
|
|
query: query
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "selectItem",
|
|
value: function selectItem(event, suggestion) {
|
|
var value = this.inputRef.current.value;
|
|
var selectionStart = event.target.selectionStart;
|
|
var trigger = this.state.trigger;
|
|
var spaceIndex = value.indexOf(' ', trigger.index);
|
|
var currentText = value.substring(trigger.index, spaceIndex > -1 ? spaceIndex : selectionStart);
|
|
var selectedText = this.formatValue(suggestion).replace(/\s+/g, '');
|
|
|
|
if (currentText.trim() !== selectedText) {
|
|
var diff = 0;
|
|
|
|
while (diff < selectedText.length) {
|
|
var s_c = selectedText.charAt(diff);
|
|
var c_c = currentText.charAt(diff);
|
|
if (s_c === c_c || c_c === ' ') diff++;else break;
|
|
}
|
|
|
|
var prevText = value.substring(0, trigger.index);
|
|
var nextText = value.substring(trigger.index + diff);
|
|
this.inputRef.current.value = "".concat(prevText).concat(selectedText, " ").concat(nextText);
|
|
this.props.onChange && this.props.onChange(event);
|
|
}
|
|
|
|
var cursorStart = trigger.index + selectedText.length + 1;
|
|
this.inputRef.current.setSelectionRange(cursorStart, cursorStart);
|
|
this.hideOverlay();
|
|
this.props.onSelect && this.props.onSelect({
|
|
originalEvent: event,
|
|
suggestion: suggestion
|
|
});
|
|
}
|
|
}, {
|
|
key: "formatValue",
|
|
value: function formatValue(value) {
|
|
var _this3 = this;
|
|
|
|
if (value) {
|
|
var field = Array.isArray(this.props.field) ? this.props.field[this.props.trigger.findIndex(function (f) {
|
|
return f === _this3.state.trigger.key;
|
|
})] : this.props.field;
|
|
return field ? ObjectUtils.resolveFieldData(value, field) : value;
|
|
}
|
|
|
|
return '';
|
|
}
|
|
}, {
|
|
key: "onItemClick",
|
|
value: function onItemClick(event, suggestion) {
|
|
this.inputRef.current.focus();
|
|
this.selectItem(event, suggestion);
|
|
}
|
|
}, {
|
|
key: "onFocus",
|
|
value: function onFocus(event) {
|
|
var _this4 = this;
|
|
|
|
event.persist();
|
|
this.setState({
|
|
focused: true
|
|
}, function () {
|
|
_this4.props.onFocus && _this4.props.onFocus(event);
|
|
});
|
|
}
|
|
}, {
|
|
key: "onBlur",
|
|
value: function onBlur(event) {
|
|
var _this5 = this;
|
|
|
|
event.persist();
|
|
this.setState({
|
|
focused: false
|
|
}, function () {
|
|
_this5.props.onBlur && _this5.props.onBlur(event);
|
|
});
|
|
}
|
|
}, {
|
|
key: "onInput",
|
|
value: function onInput(event) {
|
|
this.props.onInput && this.props.onInput(event);
|
|
if (event.target.value.length > 0) DomHandler.addClass(this.container, 'p-inputwrapper-filled');else DomHandler.removeClass(this.container, 'p-inputwrapper-filled');
|
|
}
|
|
}, {
|
|
key: "onKeyUp",
|
|
value: function onKeyUp(event) {
|
|
if (event.which === 37 || event.which === 39) {
|
|
this.onSearch(event);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onChange",
|
|
value: function onChange(event) {
|
|
this.props.onChange && this.props.onChange(event);
|
|
this.onSearch(event);
|
|
}
|
|
}, {
|
|
key: "onKeyDown",
|
|
value: function onKeyDown(event) {
|
|
if (this.state.overlayVisible) {
|
|
var highlightItem = DomHandler.findSingle(this.overlayRef.current, 'li.p-highlight');
|
|
|
|
switch (event.which) {
|
|
//down
|
|
case 40:
|
|
if (highlightItem) {
|
|
var nextElement = highlightItem.nextElementSibling;
|
|
|
|
if (nextElement) {
|
|
DomHandler.addClass(nextElement, 'p-highlight');
|
|
DomHandler.removeClass(highlightItem, 'p-highlight');
|
|
DomHandler.scrollInView(this.overlayRef.current, nextElement);
|
|
}
|
|
} else {
|
|
highlightItem = DomHandler.findSingle(this.overlayRef.current, 'li');
|
|
|
|
if (highlightItem) {
|
|
DomHandler.addClass(highlightItem, 'p-highlight');
|
|
}
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//up
|
|
|
|
case 38:
|
|
if (highlightItem) {
|
|
var previousElement = highlightItem.previousElementSibling;
|
|
|
|
if (previousElement) {
|
|
DomHandler.addClass(previousElement, 'p-highlight');
|
|
DomHandler.removeClass(highlightItem, 'p-highlight');
|
|
DomHandler.scrollInView(this.overlayRef.current, previousElement);
|
|
}
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//backspace
|
|
|
|
case 8:
|
|
var _event$target2 = event.target,
|
|
value = _event$target2.value,
|
|
selectionStart = _event$target2.selectionStart;
|
|
var key = value.substring(selectionStart - 1, selectionStart);
|
|
|
|
if (key === this.state.trigger.key) {
|
|
this.hideOverlay();
|
|
}
|
|
|
|
break;
|
|
//enter
|
|
|
|
case 13:
|
|
if (highlightItem) {
|
|
this.selectItem(event, this.props.suggestions[DomHandler.index(highlightItem)]);
|
|
}
|
|
|
|
event.preventDefault();
|
|
break;
|
|
//escape
|
|
|
|
case 27:
|
|
this.hideOverlay();
|
|
event.preventDefault();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindDocumentClickListener",
|
|
value: function bindDocumentClickListener() {
|
|
var _this6 = this;
|
|
|
|
if (!this.documentClickListener) {
|
|
this.documentClickListener = function (event) {
|
|
if (event.which === 3) {
|
|
// right click
|
|
return;
|
|
}
|
|
|
|
if (_this6.state.overlayVisible && _this6.isOutsideClicked(event)) {
|
|
_this6.hideOverlay();
|
|
}
|
|
};
|
|
|
|
document.addEventListener('click', this.documentClickListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindDocumentClickListener",
|
|
value: function unbindDocumentClickListener() {
|
|
if (this.documentClickListener) {
|
|
document.removeEventListener('click', this.documentClickListener);
|
|
this.documentClickListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindScrollListener",
|
|
value: function bindScrollListener() {
|
|
var _this7 = this;
|
|
|
|
if (!this.scrollHandler) {
|
|
this.scrollHandler = new ConnectedOverlayScrollHandler(this.container, function () {
|
|
if (_this7.state.overlayVisible) {
|
|
_this7.hideOverlay();
|
|
}
|
|
});
|
|
}
|
|
|
|
this.scrollHandler.bindScrollListener();
|
|
}
|
|
}, {
|
|
key: "unbindScrollListener",
|
|
value: function unbindScrollListener() {
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.unbindScrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: "bindResizeListener",
|
|
value: function bindResizeListener() {
|
|
var _this8 = this;
|
|
|
|
if (!this.resizeListener) {
|
|
this.resizeListener = function () {
|
|
if (_this8.state.overlayVisible && !DomHandler.isTouchDevice()) {
|
|
_this8.hideOverlay();
|
|
}
|
|
};
|
|
|
|
window.addEventListener('resize', this.resizeListener);
|
|
}
|
|
}
|
|
}, {
|
|
key: "unbindResizeListener",
|
|
value: function unbindResizeListener() {
|
|
if (this.resizeListener) {
|
|
window.removeEventListener('resize', this.resizeListener);
|
|
this.resizeListener = null;
|
|
}
|
|
}
|
|
}, {
|
|
key: "isOutsideClicked",
|
|
value: function isOutsideClicked(event) {
|
|
return this.container && this.overlayRef && this.overlayRef.current && !this.overlayRef.current.contains(event.target);
|
|
}
|
|
}, {
|
|
key: "isFilled",
|
|
value: function isFilled() {
|
|
return this.props.value != null && this.props.value.toString().length > 0 || this.props.defaultValue != null && this.props.defaultValue.toString().length > 0 || this.inputRef && this.inputRef.current && this.inputRef.current.value.toString().length > 0;
|
|
}
|
|
}, {
|
|
key: "updateInputRef",
|
|
value: function updateInputRef() {
|
|
var ref = this.props.inputRef;
|
|
|
|
if (ref) {
|
|
if (typeof ref === 'function') {
|
|
ref(this.inputRef.current);
|
|
} else {
|
|
ref.current = this.inputRef.current;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.updateInputRef();
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.suggestions !== this.props.suggestions && this.state.searching) {
|
|
this.props.suggestions && this.props.suggestions.length ? this.showOverlay() : this.hideOverlay();
|
|
|
|
if (this.state.overlayVisible) {
|
|
this.alignOverlay();
|
|
}
|
|
|
|
this.setState({
|
|
searching: false
|
|
});
|
|
}
|
|
|
|
if (!this.isFilled() && DomHandler.hasClass(this.container, 'p-inputwrapper-filled')) {
|
|
DomHandler.removeClass(this.container, 'p-inputwrapper-filled');
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.unbindDocumentClickListener();
|
|
this.unbindResizeListener();
|
|
|
|
if (this.scrollHandler) {
|
|
this.scrollHandler.destroy();
|
|
this.scrollHandler = null;
|
|
}
|
|
|
|
ZIndexUtils.clear(this.overlayRef.current);
|
|
}
|
|
}, {
|
|
key: "renderItem",
|
|
value: function renderItem(suggestion, index) {
|
|
var _this9 = this;
|
|
|
|
var content = this.props.itemTemplate ? ObjectUtils.getJSXElement(this.props.itemTemplate, suggestion, {
|
|
trigger: this.state.trigger ? this.state.trigger.key : '',
|
|
index: index
|
|
}) : this.formatValue(suggestion);
|
|
return /*#__PURE__*/React.createElement("li", {
|
|
key: index + '_item',
|
|
className: "p-mention-item",
|
|
onClick: function onClick(e) {
|
|
return _this9.onItemClick(e, suggestion);
|
|
}
|
|
}, content, /*#__PURE__*/React.createElement(Ripple, null));
|
|
}
|
|
}, {
|
|
key: "renderList",
|
|
value: function renderList() {
|
|
var _this10 = this;
|
|
|
|
if (this.props.suggestions) {
|
|
var items = this.props.suggestions.map(function (suggestion, index) {
|
|
return _this10.renderItem(suggestion, index);
|
|
});
|
|
return /*#__PURE__*/React.createElement("ul", {
|
|
ref: function ref(el) {
|
|
return _this10.list = el;
|
|
},
|
|
className: "p-mention-items"
|
|
}, items);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}, {
|
|
key: "renderPanel",
|
|
value: function renderPanel() {
|
|
var panelClassName = classNames('p-mention-panel p-component', this.props.panelClassName);
|
|
|
|
var panelStyle = _objectSpread({
|
|
maxHeight: this.props.scrollHeight
|
|
}, this.props.panelStyle);
|
|
|
|
var header = ObjectUtils.getJSXElement(this.props.headerTemplate, this.props);
|
|
var footer = ObjectUtils.getJSXElement(this.props.footerTemplate, this.props);
|
|
var list = this.renderList();
|
|
var panel = /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.overlayRef,
|
|
classNames: "p-connected-overlay",
|
|
"in": this.state.overlayVisible,
|
|
timeout: {
|
|
enter: 120,
|
|
exit: 100
|
|
},
|
|
options: this.props.transitionOptions,
|
|
unmountOnExit: true,
|
|
onEnter: this.onOverlayEnter,
|
|
onEntering: this.onOverlayEntering,
|
|
onEntered: this.onOverlayEntered,
|
|
onExit: this.onOverlayExit,
|
|
onExited: this.onOverlayExited
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.overlayRef,
|
|
className: panelClassName,
|
|
style: panelStyle,
|
|
onClick: this.onPanelClick
|
|
}, header, list, footer));
|
|
return /*#__PURE__*/React.createElement(Portal, {
|
|
element: panel,
|
|
appendTo: "self"
|
|
});
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this11 = this;
|
|
|
|
var containerClassName = classNames('p-mention p-component p-inputwrapper', {
|
|
'p-inputwrapper-filled': this.isFilled(),
|
|
'p-inputwrapper-focus': this.state.focused
|
|
}, this.props.className);
|
|
var inputClassName = classNames('p-mention-input', this.props.inputClassName);
|
|
var inputProps = ObjectUtils.findDiffKeys(this.props, Mention.defaultProps);
|
|
var panel = this.renderPanel();
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this11.container = el;
|
|
},
|
|
id: this.props.id,
|
|
className: containerClassName,
|
|
style: this.props.style
|
|
}, /*#__PURE__*/React.createElement(InputTextarea, _extends({
|
|
ref: this.inputRef,
|
|
id: this.props.inputId
|
|
}, inputProps, {
|
|
className: inputClassName,
|
|
style: this.props.inputStyle,
|
|
onFocus: this.onFocus,
|
|
onBlur: this.onBlur,
|
|
onKeyDown: this.onKeyDown,
|
|
onInput: this.onInput,
|
|
onKeyUp: this.onKeyUp,
|
|
onChange: this.onChange
|
|
})), panel);
|
|
}
|
|
}]);
|
|
|
|
return Mention;
|
|
}(Component);
|
|
|
|
_defineProperty(Mention, "defaultProps", {
|
|
id: null,
|
|
inputId: null,
|
|
inputRef: null,
|
|
style: null,
|
|
className: null,
|
|
trigger: '@',
|
|
suggestions: null,
|
|
field: null,
|
|
inputStyle: null,
|
|
inputClassName: null,
|
|
panelClassName: null,
|
|
panelStyle: null,
|
|
scrollHeight: '200px',
|
|
autoHighlight: true,
|
|
delay: 0,
|
|
headerTemplate: null,
|
|
footerTemplate: null,
|
|
itemTemplate: null,
|
|
transitionOptions: null,
|
|
onChange: null,
|
|
onInput: null,
|
|
onSearch: null,
|
|
onSelect: null,
|
|
onFocus: null,
|
|
onBlur: null,
|
|
onShow: null,
|
|
onHide: null
|
|
});
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
var Image = /*#__PURE__*/function (_Component) {
|
|
_inherits(Image, _Component);
|
|
|
|
var _super = _createSuper(Image);
|
|
|
|
function Image(props) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Image);
|
|
|
|
_this = _super.call(this, props);
|
|
_this.state = {
|
|
maskVisible: false,
|
|
previewVisible: false,
|
|
rotate: 0,
|
|
scale: 1
|
|
};
|
|
_this.onImageClick = _this.onImageClick.bind(_assertThisInitialized(_this));
|
|
_this.onMaskClick = _this.onMaskClick.bind(_assertThisInitialized(_this));
|
|
_this.onDownload = _this.onDownload.bind(_assertThisInitialized(_this));
|
|
_this.rotateRight = _this.rotateRight.bind(_assertThisInitialized(_this));
|
|
_this.rotateLeft = _this.rotateLeft.bind(_assertThisInitialized(_this));
|
|
_this.zoomIn = _this.zoomIn.bind(_assertThisInitialized(_this));
|
|
_this.zoomOut = _this.zoomOut.bind(_assertThisInitialized(_this));
|
|
_this.onEntering = _this.onEntering.bind(_assertThisInitialized(_this));
|
|
_this.onEntered = _this.onEntered.bind(_assertThisInitialized(_this));
|
|
_this.onPreviewImageClick = _this.onPreviewImageClick.bind(_assertThisInitialized(_this));
|
|
_this.onExit = _this.onExit.bind(_assertThisInitialized(_this));
|
|
_this.onExiting = _this.onExiting.bind(_assertThisInitialized(_this));
|
|
_this.onExited = _this.onExited.bind(_assertThisInitialized(_this));
|
|
_this.previewRef = /*#__PURE__*/React.createRef();
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Image, [{
|
|
key: "onImageClick",
|
|
value: function onImageClick() {
|
|
var _this2 = this;
|
|
|
|
if (this.props.preview) {
|
|
this.setState({
|
|
maskVisible: true
|
|
});
|
|
setTimeout(function () {
|
|
_this2.setState({
|
|
previewVisible: true
|
|
});
|
|
}, 25);
|
|
}
|
|
}
|
|
}, {
|
|
key: "onPreviewImageClick",
|
|
value: function onPreviewImageClick() {
|
|
this.previewClick = true;
|
|
}
|
|
}, {
|
|
key: "onMaskClick",
|
|
value: function onMaskClick() {
|
|
if (!this.previewClick) {
|
|
this.setState({
|
|
previewVisible: false
|
|
});
|
|
this.setState({
|
|
rotate: 0
|
|
});
|
|
this.setState({
|
|
scale: 1
|
|
});
|
|
}
|
|
|
|
this.previewClick = false;
|
|
}
|
|
}, {
|
|
key: "onDownload",
|
|
value: function onDownload() {
|
|
var _this$props = this.props,
|
|
name = _this$props.alt,
|
|
src = _this$props.src;
|
|
DomHandler.saveAs({
|
|
name: name,
|
|
src: src
|
|
});
|
|
this.previewClick = true;
|
|
}
|
|
}, {
|
|
key: "rotateRight",
|
|
value: function rotateRight() {
|
|
this.setState(function (prevState) {
|
|
return {
|
|
rotate: prevState.rotate + 90
|
|
};
|
|
});
|
|
this.previewClick = true;
|
|
}
|
|
}, {
|
|
key: "rotateLeft",
|
|
value: function rotateLeft() {
|
|
this.setState(function (prevState) {
|
|
return {
|
|
rotate: prevState.rotate - 90
|
|
};
|
|
});
|
|
this.previewClick = true;
|
|
}
|
|
}, {
|
|
key: "zoomIn",
|
|
value: function zoomIn() {
|
|
this.setState(function (prevState) {
|
|
return {
|
|
scale: prevState.scale + 0.1
|
|
};
|
|
});
|
|
this.previewClick = true;
|
|
}
|
|
}, {
|
|
key: "zoomOut",
|
|
value: function zoomOut() {
|
|
this.setState(function (prevState) {
|
|
return {
|
|
scale: prevState.scale - 0.1
|
|
};
|
|
});
|
|
this.previewClick = true;
|
|
}
|
|
}, {
|
|
key: "onEntering",
|
|
value: function onEntering() {
|
|
ZIndexUtils.set('modal', this.mask, PrimeReact.autoZIndex, PrimeReact.zIndex['modal']);
|
|
}
|
|
}, {
|
|
key: "onEntered",
|
|
value: function onEntered() {
|
|
if (this.props.onShow) {
|
|
this.props.onShow();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onExit",
|
|
value: function onExit() {
|
|
DomHandler.addClass(this.mask, 'p-component-overlay-leave');
|
|
}
|
|
}, {
|
|
key: "onExiting",
|
|
value: function onExiting() {
|
|
if (this.props.onHide) {
|
|
this.props.onHide();
|
|
}
|
|
}
|
|
}, {
|
|
key: "onExited",
|
|
value: function onExited(el) {
|
|
ZIndexUtils.clear(el);
|
|
this.setState({
|
|
maskVisible: false
|
|
});
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
if (this.mask) {
|
|
ZIndexUtils.clear(this.container);
|
|
}
|
|
}
|
|
}, {
|
|
key: "renderElement",
|
|
value: function renderElement() {
|
|
var _this3 = this;
|
|
|
|
var downloadable = this.props.downloadable;
|
|
var imagePreviewStyle = {
|
|
transform: 'rotate(' + this.state.rotate + 'deg) scale(' + this.state.scale + ')'
|
|
};
|
|
var zoomDisabled = this.state.scale <= 0.5 || this.state.scale >= 1.5; // const rotateClassName = 'p-image-preview-rotate-' + this.state.rotate;
|
|
|
|
return /*#__PURE__*/React.createElement("div", {
|
|
ref: function ref(el) {
|
|
return _this3.mask = el;
|
|
},
|
|
className: "p-image-mask p-component-overlay p-component-overlay-enter",
|
|
onClick: this.onMaskClick
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
className: "p-image-toolbar"
|
|
}, downloadable && /*#__PURE__*/React.createElement("button", {
|
|
className: "p-image-action p-link",
|
|
onClick: this.onDownload,
|
|
type: "button"
|
|
}, /*#__PURE__*/React.createElement("i", {
|
|
className: "pi pi-download"
|
|
})), /*#__PURE__*/React.createElement("button", {
|
|
className: "p-image-action p-link",
|
|
onClick: this.rotateRight,
|
|
type: "button"
|
|
}, /*#__PURE__*/React.createElement("i", {
|
|
className: "pi pi-refresh"
|
|
})), /*#__PURE__*/React.createElement("button", {
|
|
className: "p-image-action p-link",
|
|
onClick: this.rotateLeft,
|
|
type: "button"
|
|
}, /*#__PURE__*/React.createElement("i", {
|
|
className: "pi pi-undo"
|
|
})), /*#__PURE__*/React.createElement("button", {
|
|
className: "p-image-action p-link",
|
|
onClick: this.zoomOut,
|
|
type: "button",
|
|
disabled: zoomDisabled
|
|
}, /*#__PURE__*/React.createElement("i", {
|
|
className: "pi pi-search-minus"
|
|
})), /*#__PURE__*/React.createElement("button", {
|
|
className: "p-image-action p-link",
|
|
onClick: this.zoomIn,
|
|
type: "button",
|
|
disabled: zoomDisabled
|
|
}, /*#__PURE__*/React.createElement("i", {
|
|
className: "pi pi-search-plus"
|
|
})), /*#__PURE__*/React.createElement("button", {
|
|
className: "p-image-action p-link",
|
|
type: "button",
|
|
onClick: this.hidePreview
|
|
}, /*#__PURE__*/React.createElement("i", {
|
|
className: "pi pi-times"
|
|
}))), /*#__PURE__*/React.createElement(CSSTransition, {
|
|
nodeRef: this.previewRef,
|
|
classNames: "p-image-preview",
|
|
"in": this.state.previewVisible,
|
|
timeout: {
|
|
enter: 150,
|
|
exit: 150
|
|
},
|
|
unmountOnExit: true,
|
|
onEntering: this.onEntering,
|
|
onEntered: this.onEntered,
|
|
onExit: this.onExit,
|
|
onExiting: this.onExiting,
|
|
onExited: this.onExited
|
|
}, /*#__PURE__*/React.createElement("div", {
|
|
ref: this.previewRef
|
|
}, /*#__PURE__*/React.createElement("img", {
|
|
src: this.props.src,
|
|
className: "p-image-preview",
|
|
style: imagePreviewStyle,
|
|
onClick: this.onPreviewImageClick,
|
|
alt: this.props.alt
|
|
}))));
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _this4 = this;
|
|
|
|
var containerClassName = classNames('p-image p-component', this.props.className, {
|
|
'p-image-preview-container': this.props.preview
|
|
});
|
|
var element = this.renderElement();
|
|
var content = this.props.template ? ObjectUtils.getJSXElement(this.props.template, this.props) : /*#__PURE__*/React.createElement("i", {
|
|
className: "p-image-preview-icon pi pi-eye"
|
|
});
|
|
var _this$props2 = this.props,
|
|
src = _this$props2.src,
|
|
alt = _this$props2.alt,
|
|
width = _this$props2.width,
|
|
height = _this$props2.height;
|
|
return /*#__PURE__*/React.createElement("span", {
|
|
ref: function ref(el) {
|
|
return _this4.container = el;
|
|
},
|
|
className: containerClassName,
|
|
style: this.props.style
|
|
}, /*#__PURE__*/React.createElement("img", {
|
|
src: src,
|
|
className: this.props.imageClassName,
|
|
width: width,
|
|
height: height,
|
|
style: this.props.imageStyle,
|
|
alt: alt
|
|
}), this.props.preview && /*#__PURE__*/React.createElement("div", {
|
|
className: "p-image-preview-indicator",
|
|
onClick: this.onImageClick
|
|
}, content), this.state.maskVisible && /*#__PURE__*/React.createElement(Portal, {
|
|
element: element,
|
|
appendTo: document.body
|
|
}));
|
|
}
|
|
}]);
|
|
|
|
return Image;
|
|
}(Component);
|
|
|
|
_defineProperty(Image, "defaultProps", {
|
|
preview: false,
|
|
className: null,
|
|
downloadable: false,
|
|
style: null,
|
|
imageStyle: null,
|
|
imageClassName: null,
|
|
template: null,
|
|
src: null,
|
|
alt: null,
|
|
width: null,
|
|
height: null
|
|
});
|
|
|
|
export { Accordion, AccordionTab, AutoComplete, Avatar, AvatarGroup, Badge, BlockUI, BreadCrumb, Button, ButtonComponent, CSSTransition, Calendar, Captcha, Card, Carousel, CascadeSelect, Chart, Checkbox, Chip, Chips, ColorPicker, Column, ColumnGroup, ConfirmDialog, ConfirmPopup, ConnectedOverlayScrollHandler, ContextMenu, DataScroller, DataTable, DataView, DataViewLayoutOptions, DeferredContent, Dialog, Divider, Dock, DomHandler, Dropdown, Editor, EventBus, Fieldset, FileUpload, FilterMatchMode, FilterOperator, FilterService, FullCalendar, GMap, Galleria, IconUtils, Image, Inplace, InplaceContent, InplaceDisplay, InputMask, InputNumber, InputSwitch, InputText, InputTextarea, KeyFilter, Knob, ListBox, MegaMenu, Mention, Menu, Menubar, Message, MessageSeverity, Messages, MultiSelect, MultiStateCheckbox, ObjectUtils, OrderList, OrganizationChart, OrganizationChartNode, OverlayPanel, OverlayService, Paginator, Panel, PanelMenu, Password, PickList, Portal, PrimeIcons, ProgressBar, ProgressSpinner, RadioButton, Rating, Ripple, Row, ScrollPanel, ScrollTop, SelectButton, Sidebar, Skeleton, SlideMenu, SlideMenuSub, Slider, SpeedDial, SplitButton, Splitter, SplitterPanel, Steps, TabMenu, TabPanel, TabView, Tag, Terminal, TerminalService, TieredMenu, Timeline, Toast, ToggleButton, Toolbar, Tooltip, Tree, TreeSelect, TreeTable, TriStateCheckbox, UniqueComponentId, VirtualScroller, ZIndexUtils, addLocale, classNames, confirmDialog, confirmPopup, PrimeReact as default, locale, localeOption, localeOptions, mask, tip, updateLocaleOption, updateLocaleOptions };
|