cloudhubui
Version:
Various components to use in react projects
1,219 lines (1,162 loc) • 145 kB
JavaScript
/**
* Bundle of @devexpress/dx-grid-core
* Generated: 2021-03-04
* Version: 2.7.5
* License: https://js.devexpress.com/Licensing
*/
import { slice, easeOutCubic } from '@devexpress/dx-core';
var GRID_GROUP_TYPE = Symbol('group');
var GRID_GROUP_CHECK = Symbol(GRID_GROUP_TYPE.toString() + "_check");
var GRID_GROUP_LEVEL_KEY = Symbol(GRID_GROUP_TYPE.toString() + "_levelKey");
var GRID_GROUP_COLLAPSED_ROWS = Symbol(GRID_GROUP_TYPE.toString() + "_collapsedRows");
var warnIfRowIdUndefined = function (getRowId) { return function (row) {
var result = getRowId(row);
if (!row[GRID_GROUP_CHECK] && result === undefined) {
// tslint:disable-next-line: no-console
console.warn('The row id is undefined. Check the getRowId function. The row is', row);
}
return result;
}; };
var rowIdGetter = function (getRowId, rows) {
if (!getRowId) {
var map_1 = new Map(rows.map(function (row, rowIndex) { return [row, rowIndex]; }));
return function (row) { return map_1.get(row); };
}
return warnIfRowIdUndefined(getRowId);
};
var defaultGetCellValue = function (row, columnName) { return row[columnName]; };
var cellValueGetter = function (getCellValue, columns) {
if (getCellValue === void 0) { getCellValue = defaultGetCellValue; }
var useFastAccessor = true;
var map = columns.reduce(function (acc, column) {
if (column.getCellValue) {
useFastAccessor = false;
acc[column.name] = column.getCellValue;
}
return acc;
}, {});
if (useFastAccessor) {
return getCellValue;
}
return function (row, columnName) { return (map[columnName]
? map[columnName](row, columnName)
: getCellValue(row, columnName)); };
};
var changeColumnSorting = function (state, _a) {
var columnName = _a.columnName, direction = _a.direction, keepOther = _a.keepOther, sortIndex = _a.sortIndex;
var sorting = state.sorting;
var nextSorting = [];
if (keepOther === true) {
nextSorting = sorting;
}
if (Array.isArray(keepOther)) {
nextSorting = slice(sorting)
.filter(function (s) {
return keepOther.indexOf(s.columnName) > -1;
});
}
var columnSortingIndex = sorting.findIndex(function (s) { return s.columnName === columnName; });
var columnSorting = sorting[columnSortingIndex];
var newColumnSorting = {
columnName: columnName,
direction: direction
|| (!columnSorting || columnSorting.direction === 'desc' ? 'asc' : 'desc'),
};
if (columnSortingIndex > -1) {
nextSorting = slice(nextSorting);
nextSorting.splice(columnSortingIndex, 1);
}
if (direction !== null) {
var newIndexFallback = columnSortingIndex > -1 ? columnSortingIndex : nextSorting.length;
var newIndex = sortIndex !== undefined ? sortIndex : newIndexFallback;
nextSorting = slice(nextSorting);
nextSorting.splice(newIndex, 0, newColumnSorting);
}
return {
sorting: nextSorting,
};
};
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
var __assign = function() {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __rest(s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
}
/** @deprecated */
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
var unique = function (arr) { return __spread(Array.from(new Set(arr))); };
var getColumnSortingDirection = function (sorting, columnName) {
var columnSorting = sorting.filter(function (s) { return s.columnName === columnName; })[0];
return columnSorting ? columnSorting.direction : null;
};
var getPersistentSortedColumns = function (sorting, columnExtensions) {
if (columnExtensions === void 0) { columnExtensions = []; }
return columnExtensions.reduce(function (acc, _a) {
var columnName = _a.columnName, sortingEnabled = _a.sortingEnabled;
if (sortingEnabled === false) {
if (sorting.findIndex(function (sortItem) { return sortItem.columnName === columnName; }) > -1) {
acc.push(columnName);
}
}
return acc;
}, []);
};
var calculateKeepOther = function (sorting, keepOther, persistentSortedColumns) {
if (persistentSortedColumns === void 0) { persistentSortedColumns = []; }
if (!persistentSortedColumns.length)
return keepOther;
if (!keepOther)
return persistentSortedColumns;
return Array.isArray(keepOther)
? unique(__spread(keepOther, persistentSortedColumns))
: unique(__spread(sorting.map(function (item) { return item.columnName; }), persistentSortedColumns));
};
/* eslint-disable no-plusplus, no-param-reassign, no-use-before-define, no-constant-condition */
/* tslint:disable no-increment-decrement */
var merge = function (array, auxiliary, lo, mid, hi, compare) {
var i = lo;
var j = mid + 1;
var k = lo;
while (true) {
var cmp = compare(array[i], array[j]);
if (cmp <= 0) {
auxiliary[k++] = array[i++];
if (i > mid) {
do {
auxiliary[k++] = array[j++];
} while (j <= hi);
break;
}
}
else {
auxiliary[k++] = array[j++];
if (j > hi) {
do {
auxiliary[k++] = array[i++];
} while (i <= mid);
break;
}
}
}
};
var sortArrayToAuxiliary = function (array, auxiliary, lo, hi, compare) {
if (hi < lo)
return;
if (hi === lo) {
auxiliary[lo] = array[lo];
return;
}
var mid = Math.floor(lo + ((hi - lo) / 2));
sortAuxiliaryToArray(array, auxiliary, lo, mid, compare);
sortAuxiliaryToArray(array, auxiliary, mid + 1, hi, compare);
merge(array, auxiliary, lo, mid, hi, compare);
};
var sortAuxiliaryToArray = function (array, auxiliary, lo, hi, compare) {
if (hi <= lo)
return;
var mid = Math.floor(lo + ((hi - lo) / 2));
sortArrayToAuxiliary(array, auxiliary, lo, mid, compare);
sortArrayToAuxiliary(array, auxiliary, mid + 1, hi, compare);
merge(auxiliary, array, lo, mid, hi, compare);
};
var mergeSort = (function (array, compare) {
if (compare === void 0) { compare = function (a, b) {
if (a < b)
return -1;
if (a > b)
return 1;
return 0;
}; }
var result = slice(array);
var auxiliary = slice(array);
sortAuxiliaryToArray(result, auxiliary, 0, result.length - 1, compare);
return result;
});
var NODE_CHECK = Symbol('node');
var rowsToTree = function (rows, getRowLevelKey) {
if (!rows.length)
return rows;
var levels = [{ children: [] }];
rows.forEach(function (row) {
var _a;
var levelKey = getRowLevelKey(row);
if (levelKey) {
var levelIndex = levels.slice(1)
.findIndex(function (level) { return getRowLevelKey(level.root) === levelKey; }) + 1;
if (levelIndex > 0) {
levels.splice(levelIndex, levels.length - levelIndex);
}
var node = (_a = {}, _a[NODE_CHECK] = true, _a.root = row, _a.children = [], _a);
levels[levels.length - 1].children.push(node);
levels.push(node);
}
else {
levels[levels.length - 1].children.push(row);
}
});
return levels[0].children;
};
var treeToRows = function (tree, rows) {
if (rows === void 0) { rows = []; }
if (!tree.length)
return tree;
return tree.reduce(function (acc, node) {
if (node[NODE_CHECK]) {
acc.push(node.root);
treeToRows(node.children, rows);
}
else {
acc.push(node);
}
return acc;
}, rows);
};
var defaultCompare = function (a, b) {
if (a === b)
return 0;
if (a === null) {
return b === undefined ? -1 : 1;
}
if (a === undefined) {
return 1;
}
if (b === null || b === undefined) {
return -1;
}
return a < b ? -1 : 1;
};
var createCompare = function (sorting, getColumnCompare, getComparableValue) { return sorting.reduceRight(function (prevCompare, columnSorting) {
var columnName = columnSorting.columnName;
var inverse = columnSorting.direction === 'desc';
var columnCompare = (getColumnCompare && getColumnCompare(columnName)) || defaultCompare;
return function (aRow, bRow) {
var a = getComparableValue(aRow, columnName);
var b = getComparableValue(bRow, columnName);
var result = columnCompare(a, b);
if (result !== 0) {
return inverse ? -result : result;
}
return prevCompare(aRow, bRow);
};
}, function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return 0;
}); };
var sortTree = function (tree, compare) {
var sortedTree = tree.map(function (node) {
if (node[NODE_CHECK]) {
return __assign(__assign({}, node), { children: sortTree(node.children, compare) });
}
return node;
});
return mergeSort(sortedTree, function (a, b) { return compare(a[NODE_CHECK] ? a.root : a, b[NODE_CHECK] ? b.root : b); });
};
var sortHierarchicalRows = function (rows, compare, getRowLevelKey) {
var tree = rowsToTree(rows, getRowLevelKey);
var sortedTree = sortTree(tree, compare);
return treeToRows(sortedTree);
};
var sortedRows = function (rows, sorting, getCellValue, getColumnCompare, isGroupRow, getRowLevelKey) {
if (!sorting.length || !rows.length)
return rows;
var compare;
if (!getRowLevelKey) {
compare = createCompare(sorting, getColumnCompare, getCellValue);
return mergeSort(rows.slice(), compare);
}
compare = createCompare(sorting, getColumnCompare, function (row, columnName) {
if (isGroupRow && isGroupRow(row)) {
if (row.groupedBy === columnName) {
return row.value;
}
return undefined;
}
return getCellValue(row, columnName);
});
return sortHierarchicalRows(rows, compare, getRowLevelKey);
};
var changeColumnFilter = function (filters, _a) {
var columnName = _a.columnName, config = _a.config;
var filterIndex = filters.findIndex(function (f) { return f.columnName === columnName; });
var nextState = slice(filters);
if (config) {
var filter = __assign({ columnName: columnName }, config);
if (filterIndex > -1) {
nextState.splice(filterIndex, 1, filter);
}
else {
nextState.push(filter);
}
}
else if (filterIndex > -1) {
nextState.splice(filterIndex, 1);
}
return nextState;
};
var getColumnFilterConfig = function (filters, columnName) { return (filters.length && filters.filter(function (s) { return s.columnName === columnName; })[0] || null); };
var filterExpression = function (filters, expression) {
// tslint:disable-next-line: no-object-literal-type-assertion
var selfFilterExpr = { filters: filters, operator: 'and' };
if (!expression) {
return selfFilterExpr;
}
return {
operator: 'and',
filters: [expression, selfFilterExpr],
};
};
var operators = {
or: function (predicates) { return function (row) { return (predicates.reduce(function (acc, predicate) { return acc || predicate(row); }, false)); }; },
and: function (predicates) { return function (row) { return (predicates.reduce(function (acc, predicate) { return acc && predicate(row); }, true)); }; },
};
var toLowerCase = function (value) { return String(value).toLowerCase(); };
var operationPredicates = {
contains: function (value, filter) { return toLowerCase(value)
.indexOf(toLowerCase(filter.value)) > -1; },
notContains: function (value, filter) { return toLowerCase(value)
.indexOf(toLowerCase(filter.value)) === -1; },
startsWith: function (value, filter) { return toLowerCase(value)
.startsWith(toLowerCase(filter.value)); },
endsWith: function (value, filter) { return toLowerCase(value)
.endsWith(toLowerCase(filter.value)); },
equal: function (value, filter) { return String(value) === String(filter.value); },
notEqual: function (value, filter) { return String(value) !== String(filter.value); },
greaterThan: function (value, filter) { return value > filter.value; },
greaterThanOrEqual: function (value, filter) { return value >= filter.value; },
lessThan: function (value, filter) { return value < filter.value; },
lessThanOrEqual: function (value, filter) { return value <= filter.value; },
};
var defaultFilterPredicate = function (value, filter) {
var operation = filter.operation || 'contains';
return operationPredicates[operation](value, filter);
};
var filterTree = function (tree, predicate) { return tree.reduce(function (acc, node) {
if (node[NODE_CHECK]) {
var filteredChildren = filterTree(node.children, predicate);
if (filteredChildren.length > 0) {
acc.push(__assign(__assign({}, node), { children: filteredChildren }));
return acc;
}
if (predicate(node.root, true)) {
acc.push(node.root);
return acc;
}
return acc;
}
if (predicate(node)) {
acc.push(node);
return acc;
}
return acc;
}, []); };
var filterHierarchicalRows = function (rows, predicate, getRowLevelKey, getCollapsedRows) {
var tree = rowsToTree(rows, getRowLevelKey);
var collapsedRowsMeta = [];
var filteredTree = filterTree(tree, function (row, isNode) {
if (isNode) {
var collapsedRows = getCollapsedRows && getCollapsedRows(row);
if (collapsedRows && collapsedRows.length) {
var filteredCollapsedRows = collapsedRows.filter(predicate);
collapsedRowsMeta.push([row, filteredCollapsedRows]);
return !!filteredCollapsedRows.length || predicate(row);
}
if (predicate(row)) {
collapsedRowsMeta.push([row, []]);
return true;
}
return false;
}
return predicate(row);
});
return { rows: treeToRows(filteredTree), collapsedRowsMeta: new Map(collapsedRowsMeta) };
};
var buildPredicate = function (initialFilterExpression, getCellValue, getColumnPredicate) {
var getSimplePredicate = function (filter) {
var columnName = filter.columnName;
var customPredicate = getColumnPredicate && getColumnPredicate(columnName);
var predicate = customPredicate || defaultFilterPredicate;
return function (row) { return predicate(getCellValue(row, columnName), filter, row); };
};
var getOperatorPredicate = function (filterExpression) {
var build = operators[toLowerCase(filterExpression.operator)];
return build && build(filterExpression.filters.map(getPredicate));
};
var getPredicate = function (filterExpression) { return (getOperatorPredicate(filterExpression)
|| getSimplePredicate(filterExpression)); };
return getPredicate(initialFilterExpression);
};
var filteredRows = function (rows, filterExpression, getCellValue, getColumnPredicate, getRowLevelKey, getCollapsedRows) {
if (!(filterExpression && Object.keys(filterExpression).length && rows.length)) {
// tslint:disable-next-line:no-object-literal-type-assertion
return { rows: rows };
}
var predicate = buildPredicate(filterExpression, getCellValue, getColumnPredicate);
return getRowLevelKey
? filterHierarchicalRows(rows, predicate, getRowLevelKey, getCollapsedRows)
: { rows: rows.filter(predicate) };
};
var filteredCollapsedRowsGetter = function (_a) {
var collapsedRowsMeta = _a.collapsedRowsMeta;
return function (row) { return collapsedRowsMeta && collapsedRowsMeta.get(row); };
};
var unwrappedFilteredRows = function (_a) {
var rows = _a.rows;
return rows;
};
var GROUP_KEY_SEPARATOR = '|';
var applyColumnGrouping = function (grouping, _a) {
var columnName = _a.columnName, groupIndex = _a.groupIndex;
var nextGrouping = grouping;
var groupingIndex = nextGrouping.findIndex(function (g) { return g.columnName === columnName; });
var targetIndex = groupIndex;
if (groupingIndex > -1) {
nextGrouping = slice(grouping);
nextGrouping.splice(groupingIndex, 1);
}
else if (groupIndex === undefined) {
targetIndex = nextGrouping.length;
}
if (targetIndex > -1) {
nextGrouping = slice(nextGrouping);
nextGrouping.splice(targetIndex, 0, {
columnName: columnName,
});
}
return nextGrouping;
};
var changeColumnGrouping = function (_a, _b) {
var grouping = _a.grouping, expandedGroups = _a.expandedGroups;
var columnName = _b.columnName, groupIndex = _b.groupIndex;
var nextGrouping = applyColumnGrouping(grouping, { columnName: columnName, groupIndex: groupIndex });
var ungroupedColumnIndex = grouping.findIndex(function (group, index) { return !nextGrouping[index] || group.columnName !== nextGrouping[index].columnName; });
if (ungroupedColumnIndex === -1) {
return {
grouping: nextGrouping,
};
}
var filteredExpandedGroups = expandedGroups.filter(function (group) { return group.split(GROUP_KEY_SEPARATOR).length <= ungroupedColumnIndex; });
if (filteredExpandedGroups.length === expandedGroups.length) {
return {
grouping: nextGrouping,
};
}
return {
grouping: nextGrouping,
expandedGroups: filteredExpandedGroups,
};
};
var toggleExpandedGroups = function (state, _a) {
var groupKey = _a.groupKey;
var expandedGroups = slice(state.expandedGroups);
var groupKeyIndex = expandedGroups.indexOf(groupKey);
if (groupKeyIndex > -1) {
expandedGroups.splice(groupKeyIndex, 1);
}
else {
expandedGroups.push(groupKey);
}
return {
expandedGroups: expandedGroups,
};
};
var draftColumnGrouping = function (_a, _b) {
var grouping = _a.grouping, draftGrouping = _a.draftGrouping;
var columnName = _b.columnName, groupIndex = _b.groupIndex;
return ({
draftGrouping: applyColumnGrouping(draftGrouping || grouping, { columnName: columnName, groupIndex: groupIndex }),
});
};
var cancelColumnGroupingDraft = function () { return ({
draftGrouping: null,
}); };
var adjustSortIndex = function (groupingIndex, grouping, sorting) { return Math.max(grouping.slice(0, groupingIndex).reduce(function (acc, columnGrouping) {
var columnSortingIndex = sorting.findIndex(function (columnSorting) { return columnSorting.columnName === columnGrouping.columnName; });
return (columnSortingIndex === -1 ? acc - 1 : acc);
}, groupingIndex), 0); };
var defaultColumnCriteria = function (value) { return ({
value: value,
key: String(value),
}); };
var getGroupRows = function (rows, grouping, groupsGetter) {
if (grouping.length === 0) {
return rows;
}
var keyPrefixes = [{ prefix: '', level: 0, rows: rows }];
var resultRows = [];
var compoundKeys = {};
var _loop_1 = function () {
var _a = keyPrefixes.pop(), keyPrefix = _a.prefix, level = _a.level, currentRows = _a.rows;
var currentCompoundKey = keyPrefix.slice(0, keyPrefix.length - 1);
var groupIndex = (_a = compoundKeys[currentCompoundKey]) !== null && _a !== void 0 ? _a : -1;
var groupRows = grouping[level] && currentRows.length
? groupsGetter(currentRows, grouping[level], keyPrefix)
.map(function (_a, rowIndex) {
var childRows = _a.childRows, params = __rest(_a, ["childRows"]);
var compoundKey = params.compoundKey;
compoundKeys[compoundKey] = groupIndex + rowIndex + 1;
keyPrefixes.push({
prefix: "" + compoundKey + GROUP_KEY_SEPARATOR,
level: level + 1,
rows: childRows || [],
});
return params;
})
: currentRows;
if (groupIndex > -1) {
resultRows.splice.apply(resultRows, __spread([groupIndex + 1, 0], groupRows));
}
else {
groupRows.forEach(function (row) { return resultRows.push(row); });
}
};
while (keyPrefixes.length) {
_loop_1();
}
return resultRows;
};
var getIntegratedGroups = function (rows, grouping, keyPrefix, getCellValue, getColumnCriteria) {
var columnName = grouping.columnName;
var groupCriteria = (getColumnCriteria && getColumnCriteria(columnName))
|| defaultColumnCriteria;
var groups = new Map();
rows.forEach(function (row) {
var rawValue = getCellValue(row, columnName);
var _a = groupCriteria(rawValue, row), key = _a.key, value = _a.value;
var sameKeyItems = groups.get(key);
if (!sameKeyItems) {
var groupingValue = value === rawValue ? value : value || key;
groups.set(key, [groupingValue, key, [row]]);
}
else {
sameKeyItems[2].push(row);
}
});
var groupedBy = columnName;
return __spread(groups.values()).map(function (_a) {
var _b;
var _c = __read(_a, 3), value = _c[0], key = _c[1], childRows = _c[2];
return (_b = {
groupedBy: groupedBy,
compoundKey: "" + keyPrefix + key,
key: key,
value: value
},
_b[GRID_GROUP_CHECK] = true,
_b[GRID_GROUP_LEVEL_KEY] = GRID_GROUP_TYPE.toString() + "_" + groupedBy,
_b.childRows = childRows,
_b);
});
};
var groupRowChecker = function (row) { return row[GRID_GROUP_CHECK]; };
var groupRowLevelKeyGetter = function (row) { return (row ? row[GRID_GROUP_LEVEL_KEY] : undefined); };
var groupedRows = function (rows, grouping, getCellValue, getColumnCriteria) {
var groupsGetter = function (currentRows, currentGrouping, prefix) {
return getIntegratedGroups(currentRows, currentGrouping, prefix, getCellValue, getColumnCriteria);
};
return getGroupRows(rows, grouping, groupsGetter);
};
var expandedGroupRows = function (rows, grouping, expandedGroups, isExporting) {
if (!grouping.length)
return rows;
var groupingColumnNames = grouping.map(function (columnGrouping) { return columnGrouping.columnName; });
var expandedGroupsSet = new Set(expandedGroups);
var currentGroupExpanded = true;
var currentGroupLevel = 0;
return rows.reduce(function (acc, row) {
var _a;
if (!row[GRID_GROUP_CHECK]) {
if (currentGroupExpanded) {
acc.push(row);
}
else {
acc[acc.length - 1][GRID_GROUP_COLLAPSED_ROWS].push(row);
}
return acc;
}
var groupLevel = groupingColumnNames.indexOf(row.groupedBy);
if (groupLevel > currentGroupLevel && !currentGroupExpanded) {
return acc;
}
currentGroupExpanded = expandedGroupsSet.has(row.compoundKey) || isExporting;
currentGroupLevel = groupLevel;
if (currentGroupExpanded) {
acc.push(row);
}
else {
acc.push(__assign(__assign({}, row), (_a = {}, _a[GRID_GROUP_COLLAPSED_ROWS] = [], _a)));
}
return acc;
}, []);
};
var groupCollapsedRowsGetter = function (getCollapsedRows) { return function (row) { return (row[GRID_GROUP_COLLAPSED_ROWS] || (getCollapsedRows && getCollapsedRows(row))); }; };
var getCustomGroups = function (rows, grouping, keyPrefix, getChildGroups, rootRows) {
var groupedBy = grouping.columnName;
return getChildGroups(rows, grouping, rootRows)
.map(function (_a) {
var _b;
var key = _a.key, _c = _a.value, value = _c === void 0 ? key : _c, childRows = _a.childRows;
return (_b = {
groupedBy: groupedBy,
compoundKey: "" + keyPrefix + key,
key: key,
value: value
},
_b[GRID_GROUP_CHECK] = true,
_b[GRID_GROUP_LEVEL_KEY] = GRID_GROUP_TYPE.toString() + "_" + groupedBy,
_b.childRows = childRows,
_b);
});
};
var customGroupedRows = function (rows, grouping, getChildGroups, rootRows) {
if (rootRows === void 0) { rootRows = rows; }
var groupsGetter = function (currentRows, currentGrouping, prefix) {
return getCustomGroups(currentRows, currentGrouping, prefix, getChildGroups, rootRows);
};
return getGroupRows(rows, grouping, groupsGetter);
};
var customGroupingRowIdGetter = function (getRowId, rows) {
var firstRow = rows.find(function (row) { return !row[GRID_GROUP_CHECK]; });
if (!firstRow || getRowId(firstRow) !== undefined) {
return getRowId;
}
var map = new Map(rows
.filter(function (row) { return !row[GRID_GROUP_CHECK]; })
.map(function (row, rowIndex) { return [row, rowIndex]; }));
return function (row) { return map.get(row); };
};
var groupingPanelItems = function (columns, grouping, draftGrouping) {
var items = draftGrouping.map(function (_a) {
var columnName = _a.columnName;
return ({
column: columns.find(function (c) { return c.name === columnName; }),
draft: !grouping.some(function (columnGrouping) { return columnGrouping.columnName === columnName; }),
});
});
grouping.forEach(function (_a, index) {
var columnName = _a.columnName;
if (draftGrouping.some(function (columnGrouping) { return columnGrouping.columnName === columnName; }))
return;
items.splice(index, 0, {
column: columns.find(function (c) { return c.name === columnName; }),
draft: true,
});
});
return items;
};
var setCurrentPage = function (prevPage, page) { return page; };
var setPageSize = function (prevPageSize, size) { return size; };
var clamp = function (value, max) { return (Math.max(Math.min(value, max), 0)); };
// tslint:disable-next-line:max-line-length
var PAGE_HEADERS_OVERFLOW_ERROR = 'Max row level exceeds the page size. Consider increasing the page size.';
var paginatedRows = function (rows, pageSize, page) { return (pageSize
? rows.slice(pageSize * page, pageSize * (page + 1))
: rows); };
var rowsWithPageHeaders = function (rows, pageSize, getRowLevelKey) {
if (!pageSize || !getRowLevelKey)
return rows;
var result = rows.slice();
var headerRows = [];
var currentIndex = 0;
var _loop_1 = function () {
var row = result[currentIndex];
var levelKey = getRowLevelKey(row);
if (levelKey) {
var headerIndex = headerRows.findIndex(function (headerRow) { return getRowLevelKey(headerRow) === levelKey; });
// tslint:disable-next-line:prefer-conditional-expression
if (headerIndex === -1) {
headerRows = __spread(headerRows, [row]);
}
else {
headerRows = __spread(headerRows.slice(0, headerIndex), [row]);
}
if (headerRows.length >= pageSize) {
throw new Error(PAGE_HEADERS_OVERFLOW_ERROR);
}
}
var indexInPage = currentIndex % pageSize;
if (indexInPage < headerRows.length && row !== headerRows[indexInPage]) {
result = __spread(result.slice(0, currentIndex), [
headerRows[indexInPage]
], result.slice(currentIndex));
}
currentIndex += 1;
};
while (result.length > currentIndex) {
_loop_1();
}
return result;
};
var rowCount = function (rows) { return rows.length; };
var pageCount = function (count, pageSize) { return (pageSize ? Math.ceil(count / pageSize) : 1); };
var currentPage = function (page, totalCount, pageSize, setCurrentPage) {
var totalPages = pageCount(totalCount, pageSize);
var adjustedCurrentPage = clamp(page, totalPages - 1);
if (page !== adjustedCurrentPage) {
setTimeout(function () { return setCurrentPage(adjustedCurrentPage); });
}
return adjustedCurrentPage;
};
var firstRowOnPage = function (currentPage, pageSize, totalCount) {
if (totalCount === 0) {
return 0;
}
return pageSize ? (currentPage * pageSize) + 1 : 1;
};
var lastRowOnPage = function (currentPage, pageSize, totalRowCount) {
var result = totalRowCount;
if (pageSize) {
var index = (currentPage + 1) * pageSize;
result = index > totalRowCount ? totalRowCount : index;
}
return result;
};
var calculateStartPage = function (currentPage, maxButtonCount, totalPageCount) { return (Math.max(Math.min(currentPage - Math.floor(maxButtonCount / 2), (totalPageCount - maxButtonCount) + 1), 1)); };
var toggle = function (source, items, state) {
var itemsSet = new Set(items);
var sourceState = state;
if (sourceState === undefined) {
var availableSelection = source.filter(function (item) { return itemsSet.has(item); });
sourceState = availableSelection.length !== itemsSet.size;
}
if (sourceState) {
var sourceSet_1 = new Set(source);
return __spread(source, items.filter(function (item) { return !sourceSet_1.has(item); }));
}
return source.filter(function (item) { return !itemsSet.has(item); });
};
var toggleSelection = function (selection, _a) {
var rowIds = _a.rowIds, state = _a.state;
return toggle(selection, rowIds, state);
};
var rowsWithAvailableToSelect = function (rows, getRowId, isGroupRow) {
var dataRows = rows;
if (isGroupRow) {
dataRows = dataRows.filter(function (row) { return !isGroupRow(row); });
}
return { rows: rows, availableToSelect: dataRows.map(function (row) { return getRowId(row); }) };
};
var someSelected = function (_a, selection) {
var availableToSelect = _a.availableToSelect;
var selectionSet = new Set(selection);
return availableToSelect.length !== 0 && selectionSet.size !== 0
&& availableToSelect.some(function (elem) { return selectionSet.has(elem); })
&& availableToSelect.some(function (elem) { return !selectionSet.has(elem); });
};
var allSelected = function (_a, selection) {
var availableToSelect = _a.availableToSelect;
var selectionSet = new Set(selection);
return selectionSet.size !== 0 && availableToSelect.length !== 0
&& !availableToSelect.some(function (elem) { return !selectionSet.has(elem); });
};
var unwrapSelectedRows = function (_a) {
var rows = _a.rows;
return rows;
};
var startEditRows = function (prevEditingRowIds, _a) {
var rowIds = _a.rowIds;
return __spread(prevEditingRowIds, rowIds);
};
var stopEditRows = function (prevEditingRowIds, _a) {
var rowIds = _a.rowIds;
var rowIdSet = new Set(rowIds);
return prevEditingRowIds.filter(function (id) { return !rowIdSet.has(id); });
};
var startEditCells = function (prevEditingCells, _a) {
var editingCells = _a.editingCells;
return __spread(prevEditingCells, editingCells);
};
var stopEditCells = function (prevEditingCells, _a) {
var editingCells = _a.editingCells;
return prevEditingCells.filter(function (_a) {
var rowId = _a.rowId, columnName = _a.columnName;
return (!editingCells.some(function (_a) {
var currentRowId = _a.rowId, currentColumnName = _a.columnName;
return (currentRowId === rowId && currentColumnName === columnName);
}));
});
};
var addRow = function (addedRows, _a) {
var _b = _a === void 0 ? { row: {} } : _a, row = _b.row;
return __spread(addedRows, [row]);
};
var changeAddedRow = function (addedRows, _a) {
var rowId = _a.rowId, change = _a.change;
var result = addedRows.slice();
result[rowId] = __assign(__assign({}, result[rowId]), change);
return result;
};
var cancelAddedRows = function (addedRows, _a) {
var rowIds = _a.rowIds;
var result = [];
var indexSet = new Set(rowIds);
addedRows.forEach(function (row, index) {
if (!indexSet.has(index)) {
result.push(row);
}
});
return result;
};
var changeRow = function (prevRowChanges, _a) {
var _b;
var rowId = _a.rowId, change = _a.change;
var prevChange = prevRowChanges[rowId] || {};
return __assign(__assign({}, prevRowChanges), (_b = {}, _b[rowId] = __assign(__assign({}, prevChange), change), _b));
};
var cancelChanges = function (prevRowChanges, _a) {
var rowIds = _a.rowIds;
var result = __assign({}, prevRowChanges);
rowIds.forEach(function (rowId) {
delete result[rowId];
});
return result;
};
var deleteRows = function (deletedRowIds, _a) {
var rowIds = _a.rowIds;
return __spread(deletedRowIds, rowIds);
};
var cancelDeletedRows = function (deletedRowIds, _a) {
var rowIds = _a.rowIds;
var rowIdSet = new Set(rowIds);
return deletedRowIds.filter(function (rowId) { return !rowIdSet.has(rowId); });
};
var changedRowsByIds = function (changes, rowIds) {
var result = {};
rowIds.forEach(function (rowId) {
result[rowId] = changes[rowId];
});
return result;
};
var addedRowsByIds = function (addedRows, rowIds) {
var rowIdSet = new Set(rowIds);
var result = [];
addedRows.forEach(function (row, index) {
if (rowIdSet.has(index)) {
result.push(row);
}
});
return result;
};
var defaultCreateRowChange = function (row, value, columnName) {
var _a;
return (_a = {}, _a[columnName] = value, _a);
};
var createRowChangeGetter = function (createRowChange, columnExtensions) {
if (createRowChange === void 0) { createRowChange = defaultCreateRowChange; }
if (columnExtensions === void 0) { columnExtensions = []; }
var map = columnExtensions.reduce(function (acc, columnExtension) {
if (columnExtension.createRowChange) {
acc[columnExtension.columnName] = columnExtension.createRowChange;
}
return acc;
}, {});
return function (row, value, columnName) {
if (map[columnName]) {
return map[columnName](row, value, columnName);
}
return createRowChange(row, value, columnName);
};
};
var getRowChange = function (rowChanges, rowId) { return rowChanges[rowId] || {}; };
var TABLE_REORDERING_TYPE = Symbol('reordering');
var changeColumnOrder = function (order, _a) {
var sourceColumnName = _a.sourceColumnName, targetColumnName = _a.targetColumnName;
var sourceColumnIndex = order.indexOf(sourceColumnName);
var targetColumnIndex = order.indexOf(targetColumnName);
var newOrder = slice(order);
newOrder.splice(sourceColumnIndex, 1);
newOrder.splice(targetColumnIndex, 0, sourceColumnName);
return newOrder;
};
var TABLE_DATA_TYPE = Symbol('data');
var TABLE_NODATA_TYPE = Symbol('nodata');
var TABLE_FLEX_TYPE = Symbol('flex');
var orderedColumns = function (tableColumns, order) {
if (tableColumns === void 0) { tableColumns = []; }
return mergeSort(tableColumns, function (a, b) {
if (a.type !== TABLE_DATA_TYPE || b.type !== TABLE_DATA_TYPE)
return 0;
var aPos = order.indexOf(a.column.name);
var bPos = order.indexOf(b.column.name);
return aPos - bPos;
});
};
var tableHeaderRowsWithReordering = function (tableHeaderRows) { return __spread(tableHeaderRows, [
{
key: TABLE_REORDERING_TYPE.toString(),
type: TABLE_REORDERING_TYPE,
height: 0,
},
]); };
var draftOrder = function (order, sourceColumnIndex, targetColumnIndex) {
if (sourceColumnIndex === -1
|| targetColumnIndex === -1
|| sourceColumnIndex === targetColumnIndex) {
return order;
}
var result = slice(order);
var sourceColumn = order[sourceColumnIndex];
result.splice(sourceColumnIndex, 1);
result.splice(targetColumnIndex, 0, sourceColumn);
return result;
};
var getColumnWidth = function (columnWidths, name, _a) {
var columnName = _a.columnName, cachedWidths = _a.cachedWidths, shift = _a.shift, minColumnWidth = _a.minColumnWidth, maxColumnWidth = _a.maxColumnWidth, _b = _a.columnExtensions, columnExtensions = _b === void 0 ? [] : _b;
var change = name === columnName ? shift : -shift;
var column = columnWidths.find(function (elem) { return elem.columnName === name; });
var extension = columnExtensions.find(function (elem) { return elem.columnName === name; });
var width = typeof column.width === 'number'
? column.width
: cachedWidths[name];
var minWidth = extension && extension.minWidth >= 0
? extension.minWidth
: minColumnWidth;
var maxWidth = extension && extension.maxWidth >= 0
? extension.maxWidth
: maxColumnWidth;
var size = Math.max(minWidth, Math.min(width + change, maxWidth));
return ({ width: width, size: size });
};
var getColumnSizes = function (columnWidths, payload) {
var columnName = payload.columnName, nextColumnName = payload.nextColumnName, resizingMode = payload.resizingMode, shift = payload.shift;
var _a = getColumnWidth(columnWidths, columnName, payload), width = _a.width, size = _a.size;
if (resizingMode === 'nextColumn') {
var _b = getColumnWidth(columnWidths, nextColumnName, payload), nextWidth = _b.width, nextSize = _b.size;
if (size + nextSize !== width + nextWidth) {
var moreThanLimit = size + nextSize > width + nextWidth;
var columnExpand = shift > 0;
if (moreThanLimit !== columnExpand) {
return { size: size, nextSize: width + nextWidth - size };
}
return { size: width + nextWidth - nextSize, nextSize: nextSize };
}
return { size: size, nextSize: nextSize };
}
return { size: size };
};
var isValidValue = function (value, validUnits) {
var numb = parseInt(value, 10);
var unit = numb ? value.substr(numb.toString().length) : value;
var sizeIsAuto = isNaN(numb) && unit === 'auto';
var sizeIsValid = numb >= 0 && validUnits.some(function (validUnit) { return validUnit === unit; });
return sizeIsAuto || sizeIsValid;
};
var convertWidth = function (value) {
if (typeof value === 'string') {
var numb = parseInt(value, 10);
if (value.substr(numb.toString().length).length > 0) {
return value;
}
return numb;
}
return value;
};
var VALID_UNITS = ['px', '%', 'em', 'rem', 'vm', 'vh', 'vmin', 'vmax', ''];
var NOT_FOR_WIDGET_UNITS = ['%'];
/* tslint:disable max-line-length */
var COLUMN_RESIZING_ERROR = 'The columnWidths property of the TableColumnResizing plugin is given an invalid value.';
var specifyWidths = function (tableColumns, widths, resizingMode, onError) {
if (resizingMode !== 'widget' && resizingMode !== 'nextColumn') {
onError();
}
if (!widths.length)
return tableColumns;
return tableColumns
.reduce(function (acc, tableColumn) {
if (tableColumn.type === TABLE_DATA_TYPE) {
var columnName_1 = tableColumn.column.name;
var column = widths.find(function (el) { return el.columnName === columnName_1; });
var width = column && column.width;
if (typeof width !== 'number') {
if (width === undefined) {
onError();
}
else if (!isValidValue(width, VALID_UNITS)) {
onError();
}
else if (resizingMode === 'widget' && isValidValue(width, NOT_FOR_WIDGET_UNITS)) {
onError();
}
}
else if (width < 0) {
onError();
}
if (width === undefined) {
acc.push(tableColumn);
}
else {
acc.push(__assign(__assign({}, tableColumn), { width: convertWidth(width) }));
}
}
else {
acc.push(tableColumn);
}
return acc;
}, []);
};
var tableColumnsWithWidths = function (tableColumns, columnWidths, resizingMode) { return specifyWidths(tableColumns, columnWidths, resizingMode, throwError); };
var tableColumnsWithDraftWidths = function (tableColumns, draftColumnWidths, resizingMode) { return specifyWidths(tableColumns, draftColumnWidths, resizingMode, function () { }); };
var throwError = function () {
throw new Error(COLUMN_RESIZING_ERROR);
};
var changeTableColumnWidth = function (state, payload) {
var columnWidths = state.columnWidths;
var columnName = payload.columnName, nextColumnName = payload.nextColumnName, resizingMode = payload.resizingMode;
var nextColumnWidth = slice(columnWidths);
var index = nextColumnWidth.findIndex(function (elem) { return elem.columnName === columnName; });
var nextIndex = nextColumnWidth.findIndex(function (elem) { return elem.columnName === nextColumnName; });
var _a = getColumnSizes(columnWidths, payload), size = _a.size, nextSize = _a.nextSize;
nextColumnWidth.splice(index, 1, { columnName: columnName, width: size });
if (resizingMode === 'nextColumn') {
nextColumnWidth.splice(nextIndex, 1, { columnName: nextColumnName, width: nextSize });
}
return {
columnWidths: nextColumnWidth,
};
};
var draftTableColumnWidth = function (state, payload) {
var columnWidths = state.columnWidths;
var columnName = payload.columnName, nextColumnName = payload.nextColumnName, resizingMode = payload.resizingMode;
var _a = getColumnSizes(columnWidths, payload), size = _a.size, nextSize = _a.nextSize;
if (resizingMode === 'nextColumn') {
return { draftColumnWidths: [
{ columnName: columnName, width: size }, { columnName: nextColumnName, width: nextSize },
] };
}
return { draftColumnWidths: [{ columnName: columnName, width: size }] };
};
var cancelTableColumnWidthDraft = function () { return ({
draftColumnWidths: [],
}); };
var TABLE_EDIT_COMMAND_TYPE = Symbol('editCommand');
var TABLE_ADDED_TYPE = Symbol('added');
var TABLE_EDIT_TYPE = Symbol('edit');
var TABLE_HEADING_TYPE = Symbol('heading');
var isHeadingEditCommandsTableCell = function (tableRow, tableColumn) { return tableRow.type === TABLE_HEADING_TYPE && tableColumn.type === TABLE_EDIT_COMMAND_TYPE; };
var isEditCommandsTableCell = function (tableRow, tableColumn) { return (tableRow.type === TABLE_DATA_TYPE || tableRow.type === TABLE_ADDED_TYPE
|| tableRow.type === TABLE_EDIT_TYPE) && tableColumn.type === TABLE_EDIT_COMMAND_TYPE; };
var tableColumnsWithEditing = function (tableColumns, width) { return __spread([
{ width: convertWidth(width),
key: TABLE_EDIT_COMMAND_TYPE.toString(), type: TABLE_EDIT_COMMAND_TYPE }
], tableColumns); };
var isEditTableCell = function (tableRow, tableColumn) { return (tableRow.type === TABLE_ADDED_TYPE || tableRow.type === TABLE_EDIT_TYPE)
&& tableColumn.type === TABLE_DATA_TYPE; };
var isAddedTableRow = function (tableRow) { return tableRow.type === TABLE_ADDED_TYPE; };
var isEditTableRow = function (tableRow) { return tableRow.type === TABLE_EDIT_TYPE; };
var tableRowsWithEditing = function (tableRows, editingRowIds, addedRows, rowHeight) {
var rowIds = new Set(editingRowIds);
var editedTableRows = tableRows
.map(function (tableRow) { return (tableRow.type === TABLE_DATA_TYPE && rowIds.has(tableRow.rowId)
? __assign(__assign({}, tableRow), { type: TABLE_EDIT_TYPE, height: rowHeight }) : tableRow); });
var addedTableRows = addedRows
.map(function (row, rowIndex) { return ({
row: row,
key: TABLE_ADDED_TYPE.toString() + "_" + rowIndex,
type: TABLE_ADDED_TYPE,
rowId: rowIndex,
height: rowHeight,
}); });
return __spread(slice(addedTableRows).reverse(), editedTableRows);
};
var rowsWithEditingCells = function (tableBodyRows, editingCells) { return tableBodyRows.map(function (row) {
var rowId = row.rowId, type = row.type;
if (rowId !== undefined &&
type === TABLE_DATA_TYPE &&
editingCells.some(function (elem) { return elem.rowId === rowId; })) {
return __assign(__assign({}, row), { hasEditCell: true });
}
return row;
}); };
var columnsWithEditingCells = function (tableColumns, editingCells) { return tableColumns.map(function (tableColumn) {
var columnName = tableColumn.column ? tableColumn.column.name : undefined;
if (columnName !== undefined && editingCells.some(function (elem) { return elem.columnName === columnName; })) {
return __assign(__assign({}, tableColumn), { hasEditCell: true });
}
return tableColumn;
}); };
var TABLE_FILTER_TYPE = Symbol('filter');
var DEFAULT_FILTER_OPERATIONS = [
'contains',
'notContains',
'startsWith',
'endsWith',
'equal',
'notEqual',
];
var isFilterTableCell = function (tableRow, tableColumn) { return tableRow.type === TABLE_FILTER_TYPE && tableColumn.type === TABLE_DATA_TYPE; };
var isFilterTableRow = function (tableRow) { return tableRow.type === TABLE_FILTER_TYPE; };
var getColumnFilterOperations = function (getAvailableFilterOperations, columnName) { return (getAvailableFilterOperations && getAvailableFilterOperations(columnName))
|| DEFAULT_FILTER_OPERATIONS; };
var isFilterValueEmpty = function (value) { return value === undefined || !String(value).length; };
var getSelectedFilterOperation = function (filterOperations, columnName, columnFilter, columnFilterOperations) {
if (columnFilter && columnFilter.operation) {
return columnFilter.operation;
}
if (filterOperations[columnName]) {
return filterOperations[columnName];
}
return columnFilterOperations[0];
};
var tableHeaderRowsWithFilter = function (headerRows, rowHeight) { return __spread(headerRows, [
{ key: TABLE_FILTER_TYPE.toString(), type: TABLE_FILTER_TYPE, height: rowHeight }
]); };
var TABLE_GROUP_TYPE = Symbol('group');
var TABLE_STUB_TYPE = Symbol('stub');
var getVisibleBoundaryWithFixed = function (visibleBoundary, items) { return items.reduce(function (acc, item, index) {
if (item.fixed && (index < visibleBoundary[0] || index > visibleBoundary[1])) {
acc.push([index, index]);
}
return acc;
}, [visibleBoundary]); };
var getVisibleBoundary = function (items, viewportStart, viewportSize, getItemSize, offset, itemSize) {
if (offset === void 0) { offset = 0; }
if (itemSize === void 0) { i