primevue
Version:
[](https://opensource.org/licenses/MIT) [](https://badge.fury.io/js/primevue) [ • 315 kB
JavaScript
this.primevue = this.primevue || {};
this.primevue.utils = (function (exports) {
'use strict';
var DomHandler = {
innerWidth(el) {
let width = el.offsetWidth;
let style = getComputedStyle(el);
width += parseFloat(style.paddingLeft) + parseFloat(style.paddingRight);
return width;
},
width(el) {
let width = el.offsetWidth;
let style = getComputedStyle(el);
width -= parseFloat(style.paddingLeft) + parseFloat(style.paddingRight);
return width;
},
getWindowScrollTop() {
let doc = document.documentElement;
return (window.pageYOffset || doc.scrollTop) - (doc.clientTop || 0);
},
getWindowScrollLeft() {
let doc = document.documentElement;
return (window.pageXOffset || doc.scrollLeft) - (doc.clientLeft || 0);
},
getOuterWidth(el, margin) {
if (el) {
let width = el.offsetWidth;
if (margin) {
let style = getComputedStyle(el);
width += parseFloat(style.marginLeft) + parseFloat(style.marginRight);
}
return width;
}
else {
return 0;
}
},
getOuterHeight(el, margin) {
if (el) {
let height = el.offsetHeight;
if (margin) {
let style = getComputedStyle(el);
height += parseFloat(style.marginTop) + parseFloat(style.marginBottom);
}
return height;
}
else {
return 0;
}
},
getClientHeight(el, margin) {
if (el) {
let height = el.clientHeight;
if (margin) {
let style = getComputedStyle(el);
height += parseFloat(style.marginTop) + parseFloat(style.marginBottom);
}
return height;
} else {
return 0;
}
},
getViewport() {
let 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};
},
getOffset(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),
};
},
index(element) {
let children = element.parentNode.childNodes;
let num = 0;
for (var i = 0; i < children.length; i++) {
if (children[i] === element) return num;
if (children[i].nodeType === 1) num++;
}
return -1;
},
addMultipleClasses(element, className) {
if (element.classList) {
let styles = className.split(' ');
for (let i = 0; i < styles.length; i++) {
element.classList.add(styles[i]);
}
}
else {
let styles = className.split(' ');
for (let i = 0; i < styles.length; i++) {
element.className += ' ' + styles[i];
}
}
},
addClass(element, className) {
if (element.classList)
element.classList.add(className);
else
element.className += ' ' + className;
},
removeClass(element, className) {
if (element.classList)
element.classList.remove(className);
else
element.className = element.className.replace(new RegExp('(^|\\b)' + className.split(' ').join('|') + '(\\b|$)', 'gi'), ' ');
},
hasClass(element, className) {
if (element) {
if (element.classList)
return element.classList.contains(className);
else
return new RegExp('(^| )' + className + '( |$)', 'gi').test(element.className);
}
return false;
},
find(element, selector) {
return element.querySelectorAll(selector);
},
findSingle(element, selector) {
return element.querySelector(selector);
},
getHeight(el) {
let height = el.offsetHeight;
let style = getComputedStyle(el);
height -= parseFloat(style.paddingTop) + parseFloat(style.paddingBottom) + parseFloat(style.borderTopWidth) + parseFloat(style.borderBottomWidth);
return height;
},
getWidth(el) {
let width = el.offsetWidth;
let style = getComputedStyle(el);
width -= parseFloat(style.paddingLeft) + parseFloat(style.paddingRight) + parseFloat(style.borderLeftWidth) + parseFloat(style.borderRightWidth);
return width;
},
absolutePosition(element, target) {
let elementDimensions = element.offsetParent ? { width: element.offsetWidth, height: element.offsetHeight } : this.getHiddenElementDimensions(element);
let elementOuterHeight = elementDimensions.height;
let elementOuterWidth = elementDimensions.width;
let targetOuterHeight = target.offsetHeight;
let targetOuterWidth = target.offsetWidth;
let targetOffset = target.getBoundingClientRect();
let windowScrollTop = this.getWindowScrollTop();
let windowScrollLeft = this.getWindowScrollLeft();
let viewport = this.getViewport();
let top, left;
if (targetOffset.top + targetOuterHeight + elementOuterHeight > viewport.height) {
top = targetOffset.top + windowScrollTop - elementOuterHeight;
element.style.transformOrigin = 'bottom';
if (top < 0) {
top = windowScrollTop;
}
}
else {
top = targetOuterHeight + targetOffset.top + windowScrollTop;
element.style.transformOrigin = 'top';
}
if (targetOffset.left + 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';
},
relativePosition(element, target) {
let elementDimensions = element.offsetParent ? { width: element.offsetWidth, height: element.offsetHeight } : this.getHiddenElementDimensions(element);
const targetHeight = target.offsetHeight;
const targetOffset = target.getBoundingClientRect();
const viewport = this.getViewport();
let top, left;
if ((targetOffset.top + targetHeight + elementDimensions.height) > viewport.height) {
top = -1 * (elementDimensions.height);
element.style.transformOrigin = 'bottom';
if (targetOffset.top + top < 0) {
top = -1 * targetOffset.top;
}
}
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';
},
getParents(element, parents = []) {
return element['parentNode'] === null ? parents : this.getParents(element.parentNode, parents.concat([element.parentNode]));
},
getScrollableParents(element) {
let scrollableParents = [];
if (element) {
let parents = this.getParents(element);
const overflowRegex = /(auto|scroll)/;
const overflowCheck = (node) => {
let styleDeclaration = window['getComputedStyle'](node, null);
return overflowRegex.test(styleDeclaration.getPropertyValue('overflow')) || overflowRegex.test(styleDeclaration.getPropertyValue('overflowX')) || overflowRegex.test(styleDeclaration.getPropertyValue('overflowY'));
};
for (let parent of parents) {
let scrollSelectors = parent.nodeType === 1 && parent.dataset['scrollselectors'];
if (scrollSelectors) {
let selectors = scrollSelectors.split(',');
for (let selector of selectors) {
let el = this.findSingle(parent, selector);
if (el && overflowCheck(el)) {
scrollableParents.push(el);
}
}
}
if (parent.nodeType !== 9 && overflowCheck(parent)) {
scrollableParents.push(parent);
}
}
}
return scrollableParents;
},
getHiddenElementOuterHeight(element) {
element.style.visibility = 'hidden';
element.style.display = 'block';
let elementHeight = element.offsetHeight;
element.style.display = 'none';
element.style.visibility = 'visible';
return elementHeight;
},
getHiddenElementOuterWidth(element) {
element.style.visibility = 'hidden';
element.style.display = 'block';
let elementWidth = element.offsetWidth;
element.style.display = 'none';
element.style.visibility = 'visible';
return elementWidth;
},
getHiddenElementDimensions(element) {
var dimensions = {};
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;
},
fadeIn(element, duration) {
element.style.opacity = 0;
var last = +new Date();
var opacity = 0;
var tick = function () {
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();
},
fadeOut(element, ms) {
var opacity = 1,
interval = 50,
duration = ms,
gap = interval / duration;
let fading = setInterval(() => {
opacity -= gap;
if (opacity <= 0) {
opacity = 0;
clearInterval(fading);
}
element.style.opacity = opacity;
}, interval);
},
getUserAgent() {
return navigator.userAgent;
},
appendChild(element, target) {
if(this.isElement(target))
target.appendChild(element);
else if(target.el && target.elElement)
target.elElement.appendChild(element);
else
throw new Error('Cannot append ' + target + ' to ' + element);
},
scrollInView(container, item) {
let borderTopValue = getComputedStyle(container).getPropertyValue('borderTopWidth');
let borderTop = borderTopValue ? parseFloat(borderTopValue) : 0;
let paddingTopValue = getComputedStyle(container).getPropertyValue('paddingTop');
let paddingTop = paddingTopValue ? parseFloat(paddingTopValue) : 0;
let containerRect = container.getBoundingClientRect();
let itemRect = item.getBoundingClientRect();
let offset = (itemRect.top + document.body.scrollTop) - (containerRect.top + document.body.scrollTop) - borderTop - paddingTop;
let scroll = container.scrollTop;
let elementHeight = container.clientHeight;
let itemHeight = this.getOuterHeight(item);
if (offset < 0) {
container.scrollTop = scroll + offset;
}
else if ((offset + itemHeight) > elementHeight) {
container.scrollTop = scroll + offset - elementHeight + itemHeight;
}
},
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
}
}
},
calculateScrollbarWidth() {
if(this.calculatedScrollbarWidth != null)
return this.calculatedScrollbarWidth;
let scrollDiv = document.createElement("div");
scrollDiv.className = "p-scrollbar-measure";
document.body.appendChild(scrollDiv);
let scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth;
document.body.removeChild(scrollDiv);
this.calculatedScrollbarWidth = scrollbarWidth;
return scrollbarWidth;
},
getBrowser() {
if(!this.browser) {
let 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;
},
resolveUserAgent() {
let ua = navigator.userAgent.toLowerCase();
let 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"
};
},
isVisible(element) {
return element.offsetParent != null;
},
invokeElementMethod(element, methodName, args) {
(element)[methodName].apply(element, args);
},
getFocusableElements(element) {
let focusableElements = this.find(element, `button:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden]),
[href][clientHeight][clientWidth]:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden]),
input:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden]), select:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden]),
textarea:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden]), [tabIndex]:not([tabIndex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden]),
[contenteditable]:not([tabIndex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])`
);
let visibleFocusableElements = [];
for (let focusableElement of focusableElements) {
if (getComputedStyle(focusableElement).display != "none" && getComputedStyle(focusableElement).visibility != "hidden")
visibleFocusableElements.push(focusableElement);
}
return visibleFocusableElements;
},
getFirstFocusableElement(element) {
const focusableElements = this.getFocusableElements(element);
return focusableElements.length > 0 ? focusableElements[0] : null;
},
isClickable(element) {
const targetNode = element.nodeName;
const parentNode = element.parentElement && element.parentElement.nodeName;
return (targetNode == 'INPUT' || targetNode == 'BUTTON' || targetNode == 'A' ||
parentNode == 'INPUT' || 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')
);
},
applyStyle(element, style) {
if (typeof style === 'string') {
element.style.cssText = this.style;
}
else {
for (let prop in this.style) {
element.style[prop] = style[prop];
}
}
},
isIOS() {
return /iPad|iPhone|iPod/.test(navigator.userAgent) && !window['MSStream'];
},
isAndroid() {
return /(android)/i.test(navigator.userAgent);
},
isTouchDevice() {
return (('ontouchstart' in window) || (navigator.maxTouchPoints > 0) || (navigator.msMaxTouchPoints > 0));
}
};
class ConnectedOverlayScrollHandler {
constructor(element, listener = () => {}) {
this.element = element;
this.listener = listener;
}
bindScrollListener() {
this.scrollableParents = DomHandler.getScrollableParents(this.element);
for (let i = 0; i < this.scrollableParents.length; i++) {
this.scrollableParents[i].addEventListener('scroll', this.listener);
}
}
unbindScrollListener() {
if (this.scrollableParents) {
for (let i = 0; i < this.scrollableParents.length; i++) {
this.scrollableParents[i].removeEventListener('scroll', this.listener);
}
}
}
destroy() {
this.unbindScrollListener();
this.element = null;
this.listener = null;
this.scrollableParents = null;
}
}
var ObjectUtils = {
equals(obj1, obj2, field) {
if (field)
return (this.resolveFieldData(obj1, field) === this.resolveFieldData(obj2, field));
else
return this.deepEquals(obj1, obj2);
},
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;
}
return a !== a && b !== b;
},
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 {
let fields = field.split('.');
let 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;
}
},
isFunction(obj) {
return !!(obj && obj.constructor && obj.call && obj.apply);
},
filter(value, fields, filterValue) {
var filteredItems = [];
if (value) {
for (let item of value) {
for (let field of fields) {
if (String(this.resolveFieldData(item, field)).toLowerCase().indexOf(filterValue.toLowerCase()) > -1) {
filteredItems.push(item);
break;
}
}
}
}
return filteredItems;
},
reorderArray(value, from, to) {
let 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]);
}
},
findIndexInList(value, list) {
let index = -1;
if (list) {
for (let i = 0; i < list.length; i++) {
if (list[i] === value) {
index = i;
break;
}
}
}
return index;
},
contains(value, list) {
if (value != null && list && list.length) {
for (let val of list) {
if (this.equals(value, val))
return true;
}
}
return false;
},
insertIntoOrderedArray(item, index, arr, sourceArr) {
if (arr.length > 0) {
let injected = false;
for (let i = 0; i < arr.length; i++) {
let currentItemIndex = this.findIndexInList(arr[i], sourceArr);
if (currentItemIndex > index) {
arr.splice(i, 0, item);
injected = true;
break;
}
}
if (!injected) {
arr.push(item);
}
}
else {
arr.push(item);
}
},
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;
},
getVNodeProp(vnode, prop) {
let props = vnode.props;
if (props) {
let kebapProp = prop.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
let propName = Object.prototype.hasOwnProperty.call(props, kebapProp) ? kebapProp : prop;
return ((vnode.type.props[prop].type === Boolean && props[propName] === '') ? true : props[propName]);
}
return null;
}
};
function handler() {
let zIndexes = [];
const generateZIndex = (key, baseZIndex) => {
let lastZIndex = zIndexes.length > 0 ? zIndexes[zIndexes.length - 1] : { key, value: baseZIndex };
let newZIndex = lastZIndex.value + (lastZIndex.key === key ? 0 : baseZIndex) + 1;
zIndexes.push({ key, value: newZIndex });
return newZIndex;
};
const revertZIndex = (zIndex) => {
zIndexes = zIndexes.filter(obj => obj.value !== zIndex);
};
const getCurrentZIndex = () => {
return zIndexes.length > 0 ? zIndexes[zIndexes.length - 1].value : 0;
};
const getZIndex = (el) => {
return el ? parseInt(el.style.zIndex, 10) || 0 : 0
};
return {
get: getZIndex,
set: (key, el, baseZIndex) => {
if (el) {
el.style.zIndex = String(generateZIndex(key, baseZIndex));
}
},
clear: (el) => {
if (el) {
revertZIndex(getZIndex(el));
el.style.zIndex = '';
}
},
getCurrent: () => getCurrentZIndex()
};
}
var ZIndexUtils = handler();
var lastId = 0;
function UniqueComponentId (prefix = 'pv_id_') {
lastId++;
return `${prefix}${lastId}`;
}
function primebus() {
const allHandlers = new Map();
return {
on(type, handler) {
let handlers = allHandlers.get(type);
if (!handlers)
handlers = [handler];
else
handlers.push(handler);
allHandlers.set(type, handlers);
},
off(type, handler) {
let handlers = allHandlers.get(type);
if (handlers) {
handlers.splice(handlers.indexOf(handler) >>> 0, 1);
}
},
emit(type, evt) {
let handlers = allHandlers.get(type);
if (handlers) {
handlers.slice().map((handler) => { handler(evt);});
}
}
};
}
exports.ConnectedOverlayScrollHandler = ConnectedOverlayScrollHandler;
exports.DomHandler = DomHandler;
exports.EventBus = primebus;
exports.ObjectUtils = ObjectUtils;
exports.UniqueComponentId = UniqueComponentId;
exports.ZIndexUtils = ZIndexUtils;
Object.defineProperty(exports, '__esModule', { value: true });
return exports;
}({}));
this.primevue = this.primevue || {};
this.primevue.api = (function (exports, utils) {
'use strict';
const FilterMatchMode = {
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'
};
const FilterOperator = {
AND: 'and',
OR: 'or'
};
const FilterService = {
filter(value, fields, filterValue, filterMatchMode, filterLocale) {
let filteredItems = [];
if (value) {
for (let item of value) {
for (let field of fields) {
let fieldValue = utils.ObjectUtils.resolveFieldData(item, field);
if (this.filters[filterMatchMode](fieldValue, filterValue, filterLocale)) {
filteredItems.push(item);
break;
}
}
}
}
return filteredItems;
},
filters: {
startsWith(value, filter, filterLocale) {
if (filter === undefined || filter === null || filter.trim() === '') {
return true;
}
if (value === undefined || value === null) {
return false;
}
let filterValue = utils.ObjectUtils.removeAccents(filter.toString()).toLocaleLowerCase(filterLocale);
let stringValue = utils.ObjectUtils.removeAccents(value.toString()).toLocaleLowerCase(filterLocale);
return stringValue.slice(0, filterValue.length) === filterValue;
},
contains(value, filter, filterLocale) {
if (filter === undefined || filter === null || (typeof filter === 'string' && filter.trim() === '')) {
return true;
}
if (value === undefined || value === null) {
return false;
}
let filterValue = utils.ObjectUtils.removeAccents(filter.toString()).toLocaleLowerCase(filterLocale);
let stringValue = utils.ObjectUtils.removeAccents(value.toString()).toLocaleLowerCase(filterLocale);
return stringValue.indexOf(filterValue) !== -1;
},
notContains(value, filter, filterLocale) {
if (filter === undefined || filter === null || (typeof filter === 'string' && filter.trim() === '')) {
return true;
}
if (value === undefined || value === null) {
return false;
}
let filterValue = utils.ObjectUtils.removeAccents(filter.toString()).toLocaleLowerCase(filterLocale);
let stringValue = utils.ObjectUtils.removeAccents(value.toString()).toLocaleLowerCase(filterLocale);
return stringValue.indexOf(filterValue) === -1;
},
endsWith(value, filter, filterLocale) {
if (filter === undefined || filter === null || filter.trim() === '') {
return true;
}
if (value === undefined || value === null) {
return false;
}
let filterValue = utils.ObjectUtils.removeAccents(filter.toString()).toLocaleLowerCase(filterLocale);
let stringValue = utils.ObjectUtils.removeAccents(value.toString()).toLocaleLowerCase(filterLocale);
return stringValue.indexOf(filterValue, stringValue.length - filterValue.length) !== -1;
},
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 utils.ObjectUtils.removeAccents(value.toString()).toLocaleLowerCase(filterLocale) == utils.ObjectUtils.removeAccents(filter.toString()).toLocaleLowerCase(filterLocale);
},
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 utils.ObjectUtils.removeAccents(value.toString()).toLocaleLowerCase(filterLocale) != utils.ObjectUtils.removeAccents(filter.toString()).toLocaleLowerCase(filterLocale);
},
in(value, filter) {
if (filter === undefined || filter === null || filter.length === 0) {
return true;
}
for (let i = 0; i < filter.length; i++) {
if (utils.ObjectUtils.equals(value, filter[i])) {
return true;
}
}
return false;
},
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(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(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(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(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(value, filter) {
if (filter === undefined || filter === null) {
return true;
}
if (value === undefined || value === null) {
return false;
}
return value.toDateString() === filter.toDateString();
},
dateIsNot(value, filter) {
if (filter === undefined || filter === null) {
return true;
}
if (value === undefined || value === null) {
return false;
}
return value.toDateString() !== filter.toDateString();
},
dateBefore(value, filter) {
if (filter === undefined || filter === null) {
return true;
}
if (value === undefined || value === null) {
return false;
}
return value.getTime() < filter.getTime();
},
dateAfter(value, filter) {
if (filter === undefined || filter === null) {
return true;
}
if (value === undefined || value === null) {
return false;
}
return value.getTime() > filter.getTime();
}
},
register(rule, fn) {
this.filters[rule] = fn;
}
};
const PrimeIcons = {
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_LEFT:'pi pi-arrow-left',
ARROW_RIGHT:'pi pi-arrow-right',
ARROW_UP:'pi pi-arrow-up',
BACKWARD:'pi pi-backward',
BAN:'pi pi-ban',
BARS:'pi pi-bars',
BELL:'pi pi-bell',
BOOK:'pi pi-book',
BOOKMARK:'pi pi-bookmark',
BRIEFCASE:'pi pi-briefcase',
CALENDAR_MINUS:'pi pi-calendar-minus',
CALENDAR_PLUS:'pi pi-calendar-plus',
CALENDAR_TIMES:'pi pi-calendar-times',
CALENDAR:'pi pi-calendar',
CAMERA:'pi pi-camera',
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',
CHECK_CIRCLE:'pi pi-check-circle',
CHECK_SQUARE:'pi pi-check-square',
CHECK:'pi pi-check',
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',
CLOCK:'pi pi-clock',
CLONE:'pi pi-clone',
CLOUD_DOWNLOAD:'pi pi-cloud-download',
CLOUD_UPLOAD:'pi pi-cloud-upload',
CLOUD:'pi pi-cloud',
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',
DESKTOP:'pi pi-desktop',
DISCORD:'pi pi-discord',
DIRECTIONS_ALT:'pi pi-directions-alt',
DIRECTIONS:'pi pi-directions',
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',
EXCLAMATION_CIRCLE:'pi pi-exclamation-circle',
EXCLAMATION_TRIANGLE :'pi pi-exclamation-triangle ',
EXTERNAL_LINK:'pi pi-external-link',
EYE_SLASH:'pi pi-eye-slash',
EYE:'pi pi-eye',
FACEBOOK:'pi pi-facebook',
FAST_BACKWARD:'pi pi-fast-backward',
FAST_FORWARD:'pi pi-fast-forward',
FILE_EXCEL:'pi pi-file-excel',
FILE_O:'pi pi-file-o',
FILE_PDF:'pi pi-file-pdf',
FILE:'pi pi-file',
FILTER:'pi pi-filter',
FILTER_SLASH:'pi pi-filter-slash',
FLAG:'pi pi-flag',
FOLDER_OPEN:'pi pi-folder-open',
FOLDER:'pi pi-folder',
FORWARD:'pi pi-forward',
GITHUB:'pi pi-github',
GLOBE:'pi pi-globe',
GOOGLE:'pi pi-google',
HEART:'pi pi-heart',
HOME:'pi pi-home',
ID_CARD:'pi pi-id-card',
IMAGE:'pi pi-image',
IMAGES:'pi pi-images',
INBOX:'pi pi-inbox',
INFO_CIRCLE:'pi pi-info-circle',
INFO:'pi pi-info',
KEY:'pi pi-key',
LINK:'pi pi-link',
LIST:'pi pi-list',
LOCK_OPEN:'pi pi-lock-open',
LOCK:'pi pi-lock',
MAP:'pi pi-map',
MAP_MARKER:'pi pi-map-marker',
MICROSOFT:'pi pi-microsoft',
MINUS_CIRCLE:'pi pi-minus-circle',
MINUS:'pi pi-minus',
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_CIRCLE:'pi pi-plus-circle',
PLUS:'pi pi-plus',
POWER_OFF:'pi pi-power-off',
PRINT:'pi pi-print',
QUESTION_CIRCLE:'pi pi-question-circle',
QUESTION:'pi pi-question',
RADIO_OFF:'pi pi-radio-off',
RADIO_ON:'pi pi-radio-on',
REFRESH:'pi pi-refresh',
REPLAY:'pi pi-replay',
REPLY:'pi pi-reply',
SAVE:'pi pi-save',
SEARCH_MINUS:'pi pi-search-minus',
SEARCH_PLUS:'pi pi-search-plus',
SEARCH:'pi pi-search',
SEND:'pi pi-send',
SHARE_ALT:'pi pi-share-alt',
SHIELD:'pi pi-shield',
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_ALPHA_ALT_DOWN:'pi pi-sort-alpha-alt-down',
SORT_ALPHA_ALT_UP:'pi pi-sort-alpha-alt-up',
SORT_ALPHA_DOWN:'pi pi-sort-alpha-down',
SORT_ALPHA_UP:'pi pi-sort-alpha-up',
SORT_ALT:'pi pi-sort-alt',
SORT_AMOUNT_DOWN_ALT:'pi pi-sort-amount-down-alt',
SORT_AMOUNT_DOWN:'pi pi-sort-amount-down',
SORT_AMOUNT_UP_ALT:'pi pi-sort-amount-up-alt',
SORT_AMOUNT_UP:'pi pi-sort-amount-up',
SORT_DOWN:'pi pi-sort-down',
SORT_NUMERIC_ALT_DOWN:'pi pi-sort-numeric-alt-down',
SORT_NUMERIC_ALT_UP:'pi pi-sort-numeric-alt-up',
SORT_NUMERIC_DOWN:'pi pi-sort-numeric-down',
SORT_NUMERIC_UP:'pi pi-sort-numeric-up',
SORT_UP:'pi pi-sort-up',
SORT:'pi pi-sort',
SPINNER:'pi pi-spinner',
STAR_O:'pi pi-star-o',
STAR:'pi pi-star',
STEP_BACKWARD_ALT:'pi pi-step-backward-alt',
STEP_BACKWARD:'pi pi-step-backward',
STEP_FORWARD_ALT:'pi pi-step-forward-alt',
STEP_FORWARD:'pi pi-step-forward',
SUN:'pi pi-sun',
TABLE:'pi pi-table',
TABLET:'pi pi-tablet',
TAG:'pi pi-tag',
TAGS:'pi pi-tags',
TH_LARGE:'pi pi-th-large',
THUMBS_DOWN:'pi pi-thumbs-down',
THUMBS_UP:'pi pi-thumbs-up',
TICKET:'pi pi-ticket',
TIMES_CIRCLE:'pi pi-times-circle',
TIMES:'pi pi-times',
TRASH:'pi pi-trash',
TWITTER:'pi pi-twitter',
UNDO:'pi pi-undo',
UNLOCK:'pi pi-unlock',
UPLOAD:'pi pi-upload',
USER_EDIT:'pi pi-user-edit',
USER_MINUS:'pi pi-user-minus',
USER_PLUS:'pi pi-user-plus',
USER:'pi pi-user',
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',
YOUTUBE:'pi pi-youtube',
WALLET:'pi pi-wallet',
WIFI:'pi pi-wifi',
WINDOW_MAXIMIZE:'pi pi-window-maximize',
WINDOW_MINIMIZE:'pi pi-window-minimize'
};
const ToastSeverities = {
INFO: 'info',
WARN: 'warn',
ERROR: 'error',
SUCCESS: 'success'
};
exports.FilterMatchMode = FilterMatchMode;
exports.FilterOperator = FilterOperator;
exports.FilterService = FilterService;
exports.PrimeIcons = PrimeIcons;
exports.ToastSeverity = ToastSeverities;
Object.defineProperty(exports, '__esModule', { value: true });
return exports;
}({}, primevue.utils));
this.primevue = this.primevue || {};
this.primevue.config = (function (exports, vue, api) {
'use strict';
const defaultOptions = {
ripple: false,
inputStyle: 'outlined',
locale: {
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',
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'
},
filterMatchModeOptions: {
text: [
api.FilterMatchMode.STARTS_WITH,
api.FilterMatchMode.CONTAINS,
api.FilterMatchMode.NOT_CONTAINS,
api.FilterMatchMode.ENDS_WITH,
api.FilterMatchMode.EQUALS,
api.FilterMatchMode.NOT_EQUALS
],
numeric: [
api.FilterMatchMode.EQUALS,
api.FilterMatchMode.NOT_EQUALS,
api.