");
(0, _size.setWidth)($div, "100%");
(0, _size.setHeight)($div, scrollBarWidth - 1);
this._groupElement.after($div)
}
this._scrollBarWidth = scrollBarWidth
},
getScrollPath: function(offset) {
var tableElement = this.tableElement();
var cell;
offset -= parseInt(tableElement[0].style.top, 10) || 0;
(0, _iterator.each)(tableElement.find("tr"), (function(_, tr) {
var td = tr.childNodes[tr.childNodes.length - 1];
if (td && 1 === td.rowSpan && td.offsetTop <= offset && td.offsetHeight + td.offsetTop > offset) {
cell = td;
return false
}
return
}));
return getCellPath(tableElement, cell)
},
_moveFakeTable: function(scrollPos) {
this._moveFakeTableTop(scrollPos);
this.callBase()
},
_getRowClassNames: function(rowIndex, cell, rowClassNames) {
if (0 !== rowIndex & cell.expanded && !rowClassNames.includes("dx-expand-border")) {
rowClassNames.push("dx-expand-border")
}
},
_getMainElementMarkup: function() {
var tbody = _dom_adapter.default.createElement("tbody");
tbody.classList.add(this._getAreaClassName());
return tbody
},
_getCloseMainElementMarkup: function() {
return ""
},
updateColspans: function(columnCount) {
var rows = this.tableElement()[0].rows;
var columnOffset = 0;
var columnOffsetResetIndexes = [];
if (this.getColumnsCount() - columnCount > 0) {
return
}
for (var i = 0; i < rows.length; i += 1) {
for (var j = 0; j < rows[i].cells.length; j += 1) {
var cell = rows[i].cells[j];
var rowSpan = cell.rowSpan;
if (columnOffsetResetIndexes[i]) {
columnOffset -= columnOffsetResetIndexes[i];
columnOffsetResetIndexes[i] = 0
}
var diff = columnCount - (columnOffset + cell.colSpan);
if (j === rows[i].cells.length - 1 && diff > 0) {
cell.colSpan += diff
}
columnOffsetResetIndexes[i + rowSpan] = (columnOffsetResetIndexes[i + rowSpan] || 0) + cell.colSpan;
columnOffset += cell.colSpan
}
}
}
});
exports.VerticalHeadersArea = VerticalHeadersArea;
var _default = {
HorizontalHeadersArea: HorizontalHeadersArea,
VerticalHeadersArea: VerticalHeadersArea
};
exports.default = _default
},
16564:
/*!******************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/pivot_grid/local_store/m_local_store.js ***!
\******************************************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = exports.LocalStore = void 0;
var _class = _interopRequireDefault(__webpack_require__( /*! ../../../../core/class */ 38377));
var _common = __webpack_require__( /*! ../../../../core/utils/common */ 20576);
var _data = __webpack_require__( /*! ../../../../core/utils/data */ 47617);
var _date_serialization = _interopRequireDefault(__webpack_require__( /*! ../../../../core/utils/date_serialization */ 69434));
var _deferred = __webpack_require__( /*! ../../../../core/utils/deferred */ 62754);
var _iterator = __webpack_require__( /*! ../../../../core/utils/iterator */ 95479);
var _type = __webpack_require__( /*! ../../../../core/utils/type */ 35922);
var _array_store = _interopRequireDefault(__webpack_require__( /*! ../../../../data/array_store */ 26562));
var _custom_store = _interopRequireDefault(__webpack_require__( /*! ../../../../data/custom_store */ 88036));
var _data_source = __webpack_require__( /*! ../../../../data/data_source/data_source */ 85273);
var _query = _interopRequireDefault(__webpack_require__( /*! ../../../../data/query */ 96687));
var _utils = __webpack_require__( /*! ../../../../data/utils */ 16454);
var _m_widget_utils = __webpack_require__( /*! ../m_widget_utils */ 28580);
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var LocalStore = _class.default.inherit(function() {
var DATE_INTERVAL_SELECTORS = {
year: function(date) {
return date && date.getFullYear()
},
quarter: function(date) {
return date && Math.floor(date.getMonth() / 3) + 1
},
month: function(date) {
return date && date.getMonth() + 1
},
day: function(date) {
return date && date.getDate()
},
dayOfWeek: function(date) {
return date && date.getDay()
}
};
function getDataSelector(dataField) {
return -1 !== dataField.indexOf(".") ? (0, _data.compileGetter)(dataField) : function(data) {
return data[dataField]
}
}
function getDateValue(dataSelector) {
return function(data) {
var value = dataSelector(data);
if (value && !(value instanceof Date)) {
value = _date_serialization.default.deserializeDate(value)
}
return value
}
}
function prepareFields(fields) {
(0, _iterator.each)(fields || [], (function(_, field) {
var fieldSelector;
var intervalSelector;
var dataField = field.dataField;
var groupInterval;
var levels = field.levels;
var dataSelector;
if (!field.selector) {
if (!dataField) {
dataSelector = function(data) {
return data
}
} else {
dataSelector = getDataSelector(dataField)
}
if (levels) {
prepareFields(levels)
}
if ("date" === field.dataType) {
intervalSelector = DATE_INTERVAL_SELECTORS[field.groupInterval];
var valueSelector = getDateValue(dataSelector);
fieldSelector = function(data) {
var value = valueSelector(data);
return intervalSelector ? intervalSelector(value) : value
}
} else if ("number" === field.dataType) {
groupInterval = (0, _type.isNumeric)(field.groupInterval) && field.groupInterval > 0 && field.groupInterval;
fieldSelector = function(data) {
var value = dataSelector(data);
if ((0, _type.isString)(value)) {
value = Number(value)
}
return groupInterval ? Math.floor(value / groupInterval) * groupInterval : value
}
} else {
fieldSelector = dataSelector
}(0, _m_widget_utils.setDefaultFieldValueFormatting)(field);
(0, _m_widget_utils.setFieldProperty)(field, "selector", fieldSelector)
}
}))
}
function generateHierarchyItems(data, loadOptions, headers, headerName) {
var result = [0];
var expandIndex = loadOptions.headerName === headerName ? loadOptions.path.length : 0;
var expandedPaths = "rows" === headerName ? loadOptions.rowExpandedPaths : loadOptions.columnExpandedPaths;
var options = {
data: data,
childrenHash: headers["".concat(headerName, "Hash")],
dimensions: loadOptions[headerName],
expandedPathsHash: loadOptions.headerName !== headerName && expandedPaths && expandedPaths.hash
};
! function fillHierarchyItemIndexesCore(indexes, options, children, expandIndex, pathHash) {
var dimension = options.dimensions[expandIndex];
var expandedPathsHash = options.expandedPathsHash;
var dimensionValue;
var hierarchyItem;
if (dimension) {
dimensionValue = dimension.selector(options.data);
pathHash = void 0 !== pathHash ? pathHash + "/./" + dimensionValue : "".concat(dimensionValue);
hierarchyItem = function(value, hierarchyItems, pathHash, childrenHash) {
var hierarchyItem = childrenHash[pathHash];
if (!hierarchyItem) {
hierarchyItem = {
value: value,
index: childrenHash.length++
};
childrenHash[pathHash] = hierarchyItem;
hierarchyItems.push(hierarchyItem)
}
return hierarchyItem
}(dimensionValue, children, pathHash, options.childrenHash);
indexes.push(hierarchyItem.index);
if (expandedPathsHash && expandedPathsHash[pathHash] || dimension.expanded) {
if (!hierarchyItem.children) {
hierarchyItem.children = []
}
fillHierarchyItemIndexesCore(indexes, options, hierarchyItem.children, expandIndex + 1, pathHash)
}
}
}(result, options, headers[headerName], expandIndex);
return result
}
function generateAggregationCells(data, cells, headers, options) {
var cellSet = [];
var x;
var y;
var rowIndex;
var columnIndex;
var rowIndexes = generateHierarchyItems(data, options, headers, "rows");
var columnIndexes = generateHierarchyItems(data, options, headers, "columns");
for (y = 0; y < rowIndexes.length; y += 1) {
rowIndex = rowIndexes[y];
cells[rowIndex] = cells[rowIndex] || [];
for (x = 0; x < columnIndexes.length; x += 1) {
columnIndex = columnIndexes[x];
cellSet.push(cells[rowIndex][columnIndex] = cells[rowIndex][columnIndex] || [])
}
}
return cellSet
}
function fillHashExpandedPath(expandedPaths) {
if (expandedPaths) {
var hash = expandedPaths.hash = {};
expandedPaths.forEach((function(path) {
var pathValue = path.map((function(value) {
return "".concat(value)
})).join("/./");
hash[pathValue] = true
}))
}
}
function prepareLoadOption(options) {
options.rows = options.rows || [];
options.columns = options.columns || [];
options.filters = options.filters || [];
fillHashExpandedPath(options.columnExpandedPaths);
fillHashExpandedPath(options.rowExpandedPaths);
prepareFields(options.columns);
prepareFields(options.rows);
prepareFields(options.values);
prepareFields(options.filters)
}
function getAggregator(field) {
if ("custom" === field.summaryType) {
field.calculateCustomSummary = field.calculateCustomSummary || _common.noop;
return {
seed: function() {
var options = {
summaryProcess: "start",
totalValue: void 0
};
field.calculateCustomSummary(options);
return options
},
step: function(options, value) {
options.summaryProcess = "calculate";
options.value = value;
field.calculateCustomSummary(options);
return options
},
finalize: function(options) {
options.summaryProcess = "finalize";
delete options.value;
field.calculateCustomSummary(options);
return options.totalValue
}
}
}
return _utils.aggregators[field.summaryType] || _utils.aggregators.count
}
function aggregationStep(measures, aggregationCells, data) {
for (var aggregatorIndex = 0; aggregatorIndex < measures.length; aggregatorIndex += 1) {
var cellField = measures[aggregatorIndex];
var cellValue = cellField.selector(data);
var aggregator = getAggregator(cellField);
var isAggregatorSeedFunction = "function" === typeof aggregator.seed;
for (var cellSetIndex = 0; cellSetIndex < aggregationCells.length; cellSetIndex += 1) {
var cell = aggregationCells[cellSetIndex];
if (cell.length <= aggregatorIndex) {
cell[aggregatorIndex] = isAggregatorSeedFunction ? aggregator.seed() : aggregator.seed
}
if (void 0 === cell[aggregatorIndex]) {
cell[aggregatorIndex] = cellValue
} else if ((0, _type.isDefined)(cellValue)) {
cell[aggregatorIndex] = aggregator.step(cell[aggregatorIndex], cellValue)
}
}
}
}
function areValuesEqual(filterValue, fieldValue) {
var valueOfFilter = filterValue && filterValue.valueOf();
var valueOfField = fieldValue && fieldValue.valueOf();
if (Array.isArray(filterValue)) {
fieldValue = fieldValue || [];
for (var i = 0; i < filterValue.length; i += 1) {
valueOfFilter = filterValue[i] && filterValue[i].valueOf();
valueOfField = fieldValue[i] && fieldValue[i].valueOf();
if (valueOfFilter !== valueOfField) {
return false
}
}
return true
}
return valueOfFilter === valueOfField
}
function createDimensionFilters(dimension) {
var filters = [];
(0, _iterator.each)(dimension, (function(_, field) {
var filterValues = field.filterValues || [];
var groupName = field.groupName;
if (groupName && (0, _type.isNumeric)(field.groupIndex)) {
return
}
filterValues.length && filters.push((function(dataItem) {
var value = field.levels ? function(levels, data) {
var value = [];
(0, _iterator.each)(levels, (function(_, field) {
value.push(field.selector(data))
}));
return value
}(field.levels, dataItem) : field.selector(dataItem);
var result = false;
for (var i = 0; i < filterValues.length; i += 1) {
if (areValuesEqual(filterValues[i], value)) {
result = true;
break
}
}
return "exclude" === field.filterType ? !result : result
}))
}));
return filters
}
function createFilter(options) {
var filters = createDimensionFilters(options.rows).concat(createDimensionFilters(options.columns)).concat(createDimensionFilters(options.filters));
var expandedDimensions = options[options.headerName];
var path = options.path;
if (expandedDimensions) {
filters.push((function(dataItem) {
var expandValue;
for (var i = 0; i < path.length; i += 1) {
expandValue = expandedDimensions[i].selector(dataItem);
if ((0, _data.toComparable)(expandValue, true) !== (0, _data.toComparable)(path[i], true)) {
return false
}
}
return true
}))
}
return function(dataItem) {
for (var i = 0; i < filters.length; i += 1) {
if (!filters[i](dataItem)) {
return false
}
}
return true
}
}
function loadCore(items, options, notifyProgress) {
var headers = {
columns: [],
rows: [],
columnsHash: {
length: 1
},
rowsHash: {
length: 1
}
};
var values = [];
var aggregationCells;
var data;
var d = new _deferred.Deferred;
var i = 0;
var filter = createFilter(options);
! function processData() {
var t = new Date;
var startIndex = i;
for (; i < items.length; i += 1) {
if (i > startIndex && i % 1e4 === 0) {
if (new Date - t >= 300) {
notifyProgress(i / items.length);
setTimeout(processData, 0);
return
}
}
data = items[i];
if (filter(data)) {
aggregationCells = generateAggregationCells(data, values, headers, options);
aggregationStep(options.values, aggregationCells, data)
}
}
measures = options.values, cells = values, void(0, _iterator.each)(measures, (function(aggregatorIndex, cellField) {
var aggregator = getAggregator(cellField);
if (aggregator.finalize) {
(0, _iterator.each)(cells, (function(_, row) {
(0, _iterator.each)(row, (function(_, cell) {
if (cell && void 0 !== cell[aggregatorIndex]) {
cell[aggregatorIndex] = aggregator.finalize(cell[aggregatorIndex])
}
}))
}))
}
}));
var measures, cells;
notifyProgress(1);
d.resolve({
rows: headers.rows,
columns: headers.columns,
values: values,
grandTotalRowIndex: 0,
grandTotalColumnIndex: 0
})
}();
return d
}
function filterDataSource(dataSource, fieldSelectors) {
var filter = dataSource.filter();
if (dataSource.store() instanceof _custom_store.default && filter) {
filter = processFilter(filter, fieldSelectors);
return (0, _query.default)(dataSource.items()).filter(filter).toArray()
}
return dataSource.items()
}
function loadDataSource(dataSource, fieldSelectors, reload) {
var d = new _deferred.Deferred;
var customizeStoreLoadOptionsHandler = function(options) {
if (dataSource.store() instanceof _array_store.default) {
options.storeLoadOptions.filter = processFilter(options.storeLoadOptions.filter, fieldSelectors)
}
};
dataSource.on("customizeStoreLoadOptions", customizeStoreLoadOptionsHandler);
if (!dataSource.isLoaded() || reload) {
var loadDeferred = reload ? dataSource.load() : dataSource.reload();
(0, _deferred.when)(loadDeferred).done((function() {
loadDataSource(dataSource, fieldSelectors).done((function() {
d.resolve(filterDataSource(dataSource, fieldSelectors))
})).fail(d.reject)
})).fail(d.reject)
} else {
d.resolve(filterDataSource(dataSource, fieldSelectors))
}
return d.always((function() {
dataSource.off("customizeStoreLoadOptions", customizeStoreLoadOptionsHandler)
}))
}
function fillSelectorsByFields(selectors, fields) {
fields.forEach((function(field) {
if (field.dataField && "date" === field.dataType) {
var valueSelector = getDateValue(getDataSelector(field.dataField));
selectors[field.dataField] = function(data) {
return valueSelector(data)
}
}
}))
}
function getFieldSelectors(options) {
var selectors = {};
if (Array.isArray(options)) {
fillSelectorsByFields(selectors, options)
} else if (options) {
["rows", "columns", "filters"].forEach((function(area) {
options[area] && fillSelectorsByFields(selectors, options[area])
}))
}
return selectors
}
function processFilter(filter, fieldSelectors) {
if (!Array.isArray(filter)) {
return filter
}
filter = filter.slice(0);
if ((0, _type.isString)(filter[0]) && (filter[1] instanceof Date || filter[2] instanceof Date)) {
filter[0] = fieldSelectors[filter[0]]
}
for (var i = 0; i < filter.length; i += 1) {
filter[i] = processFilter(filter[i], fieldSelectors)
}
return filter
}
return {
ctor: function(options) {
this._progressChanged = options.onProgressChanged || _common.noop;
this._dataSource = new _data_source.DataSource(options);
this._dataSource.paginate(false)
},
getFields: function(fields) {
var dataSource = this._dataSource;
var d = new _deferred.Deferred;
loadDataSource(dataSource, getFieldSelectors(fields)).done((function(data) {
d.resolve((0, _m_widget_utils.discoverObjectFields)(data, fields))
})).fail(d.reject);
return d
},
key: function() {
return this._dataSource.key()
},
load: function(options) {
var that = this;
var dataSource = that._dataSource;
var d = new _deferred.Deferred;
prepareLoadOption(options);
loadDataSource(dataSource, getFieldSelectors(options), options.reload).done((function(data) {
(0, _deferred.when)(loadCore(data, options, that._progressChanged)).done(d.resolve)
})).fail(d.reject);
return d
},
filter: function() {
var dataSource = this._dataSource;
return dataSource.filter.apply(dataSource, arguments)
},
supportPaging: function() {
return false
},
getDrillDownItems: function(loadOptions, params) {
loadOptions = loadOptions || {};
params = params || {};
prepareLoadOption(loadOptions);
var drillDownItems = [];
var items = this._dataSource.items();
var item;
var _params = params,
maxRowCount = _params.maxRowCount;
var _params2 = params,
customColumns = _params2.customColumns;
var filter = createFilter(loadOptions);
var pathFilter = createFilter({
rows: (0, _m_widget_utils.getFiltersByPath)(loadOptions.rows, params.rowPath),
columns: (0, _m_widget_utils.getFiltersByPath)(loadOptions.columns, params.columnPath),
filters: []
});
for (var i = 0; i < items.length; i += 1) {
if (pathFilter(items[i]) && filter(items[i])) {
if (customColumns) {
item = {};
for (var j = 0; j < customColumns.length; j += 1) {
item[customColumns[j]] = items[i][customColumns[j]]
}
} else {
item = items[i]
}
drillDownItems.push(item)
}
if (maxRowCount > 0 && drillDownItems.length === maxRowCount) {
break
}
}
return drillDownItems
}
}
}()).include(_m_widget_utils.storeDrillDownMixin);
exports.LocalStore = LocalStore;
var _default = {
LocalStore: LocalStore
};
exports.default = _default
},
61550:
/*!*************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/pivot_grid/m_widget.js ***!
\*************************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = exports.PivotGrid = void 0;
var _component_registrator = _interopRequireDefault(__webpack_require__( /*! ../../../core/component_registrator */ 99393));
var _element = __webpack_require__( /*! ../../../core/element */ 6415);
var _renderer = _interopRequireDefault(__webpack_require__( /*! ../../../core/renderer */ 68374));
var _common = __webpack_require__( /*! ../../../core/utils/common */ 20576);
var _deferred = __webpack_require__( /*! ../../../core/utils/deferred */ 62754);
var _extend = __webpack_require__( /*! ../../../core/utils/extend */ 13306);
var _iterator = __webpack_require__( /*! ../../../core/utils/iterator */ 95479);
var _size = __webpack_require__( /*! ../../../core/utils/size */ 58664);
var _string = __webpack_require__( /*! ../../../core/utils/string */ 68752);
var _type = __webpack_require__( /*! ../../../core/utils/type */ 35922);
var _window = __webpack_require__( /*! ../../../core/utils/window */ 58201);
var _click = __webpack_require__( /*! ../../../events/click */ 95429);
var _events_engine = _interopRequireDefault(__webpack_require__( /*! ../../../events/core/events_engine */ 55994));
var _index = __webpack_require__( /*! ../../../events/utils/index */ 39611);
var _message = _interopRequireDefault(__webpack_require__( /*! ../../../localization/message */ 28109));
var _context_menu = _interopRequireDefault(__webpack_require__( /*! ../../../ui/context_menu */ 10042));
var _ui = _interopRequireDefault(__webpack_require__( /*! ../../../ui/popup/ui.popup */ 51495));
var _ui2 = _interopRequireDefault(__webpack_require__( /*! ../../../ui/widget/ui.widget */ 14390));
var _m_utils = _interopRequireDefault(__webpack_require__( /*! ../../grids/grid_core/m_utils */ 60082));
var _m_chart_integration = __webpack_require__( /*! ./chart_integration/m_chart_integration */ 85654);
var _m_data_area = _interopRequireDefault(__webpack_require__( /*! ./data_area/m_data_area */ 64318));
var _m_data_controller = _interopRequireDefault(__webpack_require__( /*! ./data_controller/m_data_controller */ 9517));
var _m_export = __webpack_require__( /*! ./export/m_export */ 75705);
var _m_field_chooser = __webpack_require__( /*! ./field_chooser/m_field_chooser */ 63857);
var _m_field_chooser_base = __webpack_require__( /*! ./field_chooser/m_field_chooser_base */ 16491);
var _m_fields_area = __webpack_require__( /*! ./fields_area/m_fields_area */ 70513);
var _m_headers_area = _interopRequireDefault(__webpack_require__( /*! ./headers_area/m_headers_area */ 95578));
var _m_widget_utils = __webpack_require__( /*! ./m_widget_utils */ 28580);
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var window = (0, _window.getWindow)();
var TR = "
";
var TD = "";
var DIV = "";
var FIELD_CALCULATED_OPTIONS = ["allowSorting", "allowSortingBySummary", "allowFiltering", "allowExpandAll"];
function getArraySum(array) {
var sum = 0;
(0, _iterator.each)(array, (function(_, value) {
sum += value || 0
}));
return sum
}
function adjustSizeArray(sizeArray, space) {
var delta = space / sizeArray.length;
for (var i = 0; i < sizeArray.length; i += 1) {
sizeArray[i] -= delta
}
}
function unsubscribeScrollEvents(area) {
area.off("scroll").off("stop")
}
function getCommonBorderWidth(elements, direction) {
var borderStyleNames = "width" === direction ? ["borderLeftWidth", "borderRightWidth"] : ["borderTopWidth", "borderBottomWidth"];
var width = 0;
(0, _iterator.each)(elements, (function(_, elem) {
var computedStyle = window.getComputedStyle(elem.get(0));
borderStyleNames.forEach((function(borderStyleName) {
width += parseFloat(computedStyle[borderStyleName]) || 0
}))
}));
return width
}
var PivotGrid = _ui2.default.inherit({
_getDefaultOptions: function() {
return (0, _extend.extend)(this.callBase(), {
scrolling: {
timeout: 300,
renderingThreshold: 150,
minTimeout: 10,
mode: "standard",
useNative: "auto",
removeInvisiblePages: true,
virtualRowHeight: 50,
virtualColumnWidth: 100,
loadTwoPagesOnStart: true
},
encodeHtml: true,
dataSource: null,
activeStateEnabled: false,
fieldChooser: {
minWidth: 250,
minHeight: 250,
enabled: true,
allowSearch: false,
searchTimeout: 500,
layout: 0,
title: _message.default.format("dxPivotGrid-fieldChooserTitle"),
width: 600,
height: 600,
applyChangesMode: "instantly"
},
onContextMenuPreparing: null,
allowSorting: false,
allowSortingBySummary: false,
allowFiltering: false,
allowExpandAll: false,
wordWrapEnabled: true,
fieldPanel: {
showColumnFields: true,
showFilterFields: true,
showDataFields: true,
showRowFields: true,
allowFieldDragging: true,
visible: false,
texts: {
columnFieldArea: _message.default.format("dxPivotGrid-columnFieldArea"),
rowFieldArea: _message.default.format("dxPivotGrid-rowFieldArea"),
filterFieldArea: _message.default.format("dxPivotGrid-filterFieldArea"),
dataFieldArea: _message.default.format("dxPivotGrid-dataFieldArea")
}
},
dataFieldArea: "column",
export: {
enabled: false,
fileName: "PivotGrid"
},
showRowTotals: true,
showRowGrandTotals: true,
showColumnTotals: true,
showColumnGrandTotals: true,
hideEmptySummaryCells: true,
showTotalsPrior: "none",
rowHeaderLayout: "standard",
loadPanel: {
enabled: true,
text: _message.default.format("Loading"),
width: 200,
height: 70,
showIndicator: true,
indicatorSrc: "",
showPane: true
},
texts: {
grandTotal: _message.default.format("dxPivotGrid-grandTotal"),
total: _message.default.getFormatter("dxPivotGrid-total"),
noData: _message.default.format("dxDataGrid-noDataText"),
showFieldChooser: _message.default.format("dxPivotGrid-showFieldChooser"),
expandAll: _message.default.format("dxPivotGrid-expandAll"),
collapseAll: _message.default.format("dxPivotGrid-collapseAll"),
sortColumnBySummary: _message.default.getFormatter("dxPivotGrid-sortColumnBySummary"),
sortRowBySummary: _message.default.getFormatter("dxPivotGrid-sortRowBySummary"),
removeAllSorting: _message.default.format("dxPivotGrid-removeAllSorting"),
exportToExcel: _message.default.format("dxDataGrid-exportToExcel"),
dataNotAvailable: _message.default.format("dxPivotGrid-dataNotAvailable")
},
onCellClick: null,
onCellPrepared: null,
showBorders: false,
stateStoring: {
enabled: false,
storageKey: null,
type: "localStorage",
customLoad: null,
customSave: null,
savingTimeout: 2e3
},
onExpandValueChanging: null,
renderCellCountLimit: 2e4,
onExporting: null,
headerFilter: {
width: 252,
height: 325,
allowSelectAll: true,
showRelevantValues: false,
search: {
enabled: false,
timeout: 500,
editorOptions: {},
mode: "contains"
},
texts: {
emptyValue: _message.default.format("dxDataGrid-headerFilterEmptyValue"),
ok: _message.default.format("dxDataGrid-headerFilterOK"),
cancel: _message.default.format("dxDataGrid-headerFilterCancel")
}
}
})
},
_updateCalculatedOptions: function(fields) {
var that = this;
(0, _iterator.each)(fields, (function(_, field) {
(0, _iterator.each)(FIELD_CALCULATED_OPTIONS, (function(_, optionName) {
var isCalculated = field._initProperties && optionName in field._initProperties && void 0 === field._initProperties[optionName];
var needUpdate = void 0 === field[optionName] || isCalculated;
if (needUpdate) {
(0, _m_widget_utils.setFieldProperty)(field, optionName, that.option(optionName))
}
}))
}))
},
_getDataControllerOptions: function() {
var that = this;
return {
component: that,
dataSource: that.option("dataSource"),
texts: that.option("texts"),
showRowTotals: that.option("showRowTotals"),
showRowGrandTotals: that.option("showRowGrandTotals"),
showColumnTotals: that.option("showColumnTotals"),
showTotalsPrior: that.option("showTotalsPrior"),
showColumnGrandTotals: that.option("showColumnGrandTotals"),
dataFieldArea: that.option("dataFieldArea"),
rowHeaderLayout: that.option("rowHeaderLayout"),
hideEmptySummaryCells: that.option("hideEmptySummaryCells"),
onFieldsPrepared: function(fields) {
that._updateCalculatedOptions(fields)
}
}
},
_initDataController: function() {
var that = this;
that._dataController && that._dataController.dispose();
that._dataController = new _m_data_controller.default.DataController(that._getDataControllerOptions());
if ((0, _window.hasWindow)()) {
that._dataController.changed.add((function() {
that._render()
}))
}
that._dataController.scrollChanged.add((function(options) {
that._scrollLeft = options.left;
that._scrollTop = options.top
}));
that._dataController.loadingChanged.add((function() {
that._updateLoading()
}));
that._dataController.progressChanged.add(that._updateLoading.bind(that));
that._dataController.dataSourceChanged.add((function() {
that._trigger("onChanged")
}));
var expandValueChanging = that.option("onExpandValueChanging");
if (expandValueChanging) {
that._dataController.expandValueChanging.add((function(e) {
expandValueChanging(e)
}))
}
},
_init: function() {
this.callBase();
this._initDataController();
_m_utils.default.logHeaderFilterDeprecatedWarningIfNeed(this);
this._scrollLeft = this._scrollTop = null;
this._initActions()
},
_initActions: function() {
this._actions = {
onChanged: this._createActionByOption("onChanged"),
onContextMenuPreparing: this._createActionByOption("onContextMenuPreparing"),
onCellClick: this._createActionByOption("onCellClick"),
onExporting: this._createActionByOption("onExporting"),
onCellPrepared: this._createActionByOption("onCellPrepared")
}
},
_trigger: function(eventName, eventArg) {
this._actions[eventName](eventArg)
},
_optionChanged: function(args) {
if (FIELD_CALCULATED_OPTIONS.includes(args.name)) {
var fields = this.getDataSource().fields();
this._updateCalculatedOptions(fields)
}
switch (args.name) {
case "dataSource":
case "allowSorting":
case "allowFiltering":
case "allowExpandAll":
case "allowSortingBySummary":
case "scrolling":
case "stateStoring":
this._initDataController();
this._fieldChooserPopup.hide();
this._renderFieldChooser();
this._invalidate();
break;
case "texts":
case "showTotalsPrior":
case "showRowTotals":
case "showRowGrandTotals":
case "showColumnTotals":
case "showColumnGrandTotals":
case "hideEmptySummaryCells":
case "dataFieldArea":
this._dataController.updateViewOptions(this._getDataControllerOptions());
break;
case "useNativeScrolling":
case "encodeHtml":
case "renderCellCountLimit":
break;
case "rtlEnabled":
this.callBase(args);
this._renderFieldChooser();
this._renderContextMenu();
(0, _window.hasWindow)() && this._renderLoadPanel(this._dataArea.groupElement(), this.$element());
this._invalidate();
break;
case "export":
this._renderDescriptionArea();
break;
case "onExpandValueChanging":
break;
case "onCellClick":
case "onContextMenuPreparing":
case "onExporting":
case "onExported":
case "onFileSaving":
case "onCellPrepared":
this._actions[args.name] = this._createActionByOption(args.name);
break;
case "fieldChooser":
this._renderFieldChooser();
this._renderDescriptionArea();
break;
case "loadPanel":
if ((0, _window.hasWindow)()) {
if ("loadPanel.enabled" === args.fullName) {
clearTimeout(this._hideLoadingTimeoutID);
this._renderLoadPanel(this._dataArea.groupElement(), this.$element())
} else {
this._renderLoadPanel(this._dataArea.groupElement(), this.$element());
this._invalidate()
}
}
break;
case "fieldPanel":
this._renderDescriptionArea();
this._invalidate();
break;
case "headerFilter":
this._renderFieldChooser();
this._invalidate();
break;
case "showBorders":
this._tableElement().toggleClass("dx-pivotgrid-border", !!args.value);
this.updateDimensions();
break;
case "wordWrapEnabled":
this._tableElement().toggleClass("dx-word-wrap", !!args.value);
this.updateDimensions();
break;
case "rowHeaderLayout":
this._tableElement().find(".".concat("dx-area-row-cell")).toggleClass("dx-area-tree-view", "tree" === args.value);
this._dataController.updateViewOptions(this._getDataControllerOptions());
break;
case "height":
case "width":
this._hasHeight = null;
this.callBase(args);
this.resize();
break;
default:
this.callBase(args)
}
},
_updateScrollPosition: function(columnsArea, rowsArea, dataArea) {
var force = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : false;
var that = this;
var scrollTop;
var scrollLeft;
var scrolled = that._scrollTop || that._scrollLeft;
if (that._scrollUpdating) {
return
}
that._scrollUpdating = true;
if (rowsArea && !rowsArea.hasScroll() && that._hasHeight) {
that._scrollTop = null
}
if (columnsArea && !columnsArea.hasScroll()) {
that._scrollLeft = null
}
if (null !== that._scrollTop || null !== that._scrollLeft || scrolled || that.option("rtlEnabled")) {
scrollTop = that._scrollTop || 0;
scrollLeft = that._scrollLeft || 0;
dataArea.scrollTo({
left: scrollLeft,
top: scrollTop
}, force);
columnsArea.scrollTo({
left: scrollLeft
}, force);
rowsArea.scrollTo({
top: scrollTop
}, force);
that._dataController.updateWindowScrollPosition(that._scrollTop)
}
that._scrollUpdating = false
},
_subscribeToEvents: function(columnsArea, rowsArea, dataArea) {
var that = this;
(0, _iterator.each)([columnsArea, rowsArea, dataArea], (function(_, area) {
! function(area, handler) {
unsubscribeScrollEvents(area);
area.on("scroll", handler).on("stop", handler)
}(area, (function(e) {
return function(e, area) {
var scrollOffset = e.scrollOffset;
var scrollable = area._getScrollable();
var leftOffset = "vertical" !== scrollable.option("direction") ? scrollOffset.left : that._scrollLeft;
var topOffset = "horizontal" !== scrollable.option("direction") && that._hasHeight ? scrollOffset.top : that._scrollTop;
if ((that._scrollLeft || 0) !== (leftOffset || 0) || (that._scrollTop || 0) !== (topOffset || 0)) {
that._scrollLeft = leftOffset;
that._scrollTop = topOffset;
that._updateScrollPosition(columnsArea, rowsArea, dataArea);
if ("virtual" === that.option("scrolling.mode")) {
that._dataController.setViewportPosition(that._scrollLeft, that._scrollTop)
}
}
}(e, area)
}))
}));
!that._hasHeight && that._dataController.subscribeToWindowScrollEvents(dataArea.groupElement())
},
_clean: _common.noop,
_needDelayResizing: function(cellsInfo) {
var cellsCount = cellsInfo.length * (cellsInfo.length ? cellsInfo[0].length : 0);
return cellsCount > this.option("renderCellCountLimit")
},
_renderFieldChooser: function() {
var _a;
var that = this;
var container = that._pivotGridContainer;
var fieldChooserOptions = that.option("fieldChooser") || {};
var toolbarItems = "onDemand" === fieldChooserOptions.applyChangesMode ? [{
toolbar: "bottom",
location: "after",
widget: "dxButton",
options: {
text: _message.default.format("OK"),
onClick: function() {
that._fieldChooserPopup.$content().dxPivotGridFieldChooser("applyChanges");
that._fieldChooserPopup.hide()
}
}
}, {
toolbar: "bottom",
location: "after",
widget: "dxButton",
options: {
text: _message.default.format("Cancel"),
onClick: function() {
that._fieldChooserPopup.hide()
}
}
}] : [];
var fieldChooserComponentOptions = {
layout: fieldChooserOptions.layout,
texts: fieldChooserOptions.texts || {},
dataSource: that.getDataSource(),
allowSearch: fieldChooserOptions.allowSearch,
searchTimeout: fieldChooserOptions.searchTimeout,
width: void 0,
height: void 0,
headerFilter: that.option("headerFilter"),
encodeHtml: null !== (_a = that.option("fieldChooser.encodeHtml")) && void 0 !== _a ? _a : that.option("encodeHtml"),
applyChangesMode: fieldChooserOptions.applyChangesMode,
onContextMenuPreparing: function(e) {
that._trigger("onContextMenuPreparing", e)
}
};
var popupOptions = {
shading: false,
title: fieldChooserOptions.title,
width: fieldChooserOptions.width,
height: fieldChooserOptions.height,
showCloseButton: true,
resizeEnabled: true,
minWidth: fieldChooserOptions.minWidth,
minHeight: fieldChooserOptions.minHeight,
toolbarItems: toolbarItems,
onResize: function(e) {
e.component.$content().dxPivotGridFieldChooser("updateDimensions")
},
onShown: function(e) {
that._createComponent(e.component.content(), _m_field_chooser.FieldChooser, fieldChooserComponentOptions)
},
onHidden: function(e) {
var fieldChooser = e.component.$content().dxPivotGridFieldChooser("instance");
fieldChooser.resetTreeView();
fieldChooser.cancelChanges()
}
};
if (that._fieldChooserPopup) {
that._fieldChooserPopup.option(popupOptions);
that._fieldChooserPopup.$content().dxPivotGridFieldChooser(fieldChooserComponentOptions)
} else {
that._fieldChooserPopup = that._createComponent((0, _renderer.default)(DIV).addClass("dx-fieldchooser-popup").appendTo(container), _ui.default, popupOptions)
}
},
_renderContextMenu: function() {
var that = this;
var $container = that._pivotGridContainer;
if (that._contextMenu) {
that._contextMenu.$element().remove()
}
that._contextMenu = that._createComponent((0, _renderer.default)(DIV).appendTo($container), _context_menu.default, {
onPositioning: function(actionArgs) {
var event = actionArgs.event;
actionArgs.cancel = true;
if (!event) {
return
}
var targetElement = event.target.cellIndex >= 0 ? event.target : (0, _renderer.default)(event.target).closest("td").get(0);
if (!targetElement) {
return
}
var args = that._createEventArgs(targetElement, event);
var items = that._getContextMenuItems(args);
if (items) {
actionArgs.component.option("items", items);
actionArgs.cancel = false
}
},
onItemClick: function(params) {
params.itemData.onItemClick && params.itemData.onItemClick(params)
},
cssClass: "dx-pivotgrid",
target: that.$element()
})
},
_getContextMenuItems: function(e) {
var that = this;
var items = [];
var texts = that.option("texts");
if ("row" === e.area || "column" === e.area) {
var areaFields = e["".concat(e.area, "Fields")];
var oppositeAreaFields = e["column" === e.area ? "rowFields" : "columnFields"];
var field = e.cell.path && areaFields[e.cell.path.length - 1];
var dataSource = that.getDataSource();
if (field && field.allowExpandAll && e.cell.path.length < e["".concat(e.area, "Fields")].length && !dataSource.paginate()) {
items.push({
beginGroup: true,
icon: "none",
text: texts.expandAll,
onItemClick: function() {
dataSource.expandAll(field.index)
}
});
items.push({
text: texts.collapseAll,
icon: "none",
onItemClick: function() {
dataSource.collapseAll(field.index)
}
})
}
if (e.cell.isLast && !dataSource.paginate()) {
var sortingBySummaryItemCount = 0;
(0, _iterator.each)(oppositeAreaFields, (function(_, field) {
if (!field.allowSortingBySummary) {
return
}(0, _iterator.each)(e.dataFields, (function(dataIndex, dataField) {
if ((0, _type.isDefined)(e.cell.dataIndex) && e.cell.dataIndex !== dataIndex) {
return
}
var showDataFieldCaption = !(0, _type.isDefined)(e.cell.dataIndex) && e.dataFields.length > 1;
var textFormat = "column" === e.area ? texts.sortColumnBySummary : texts.sortRowBySummary;
var checked = (0, _m_widget_utils.findField)(e.dataFields, field.sortBySummaryField) === dataIndex && (e.cell.path || []).join("/") === (field.sortBySummaryPath || []).join("/");
var text = (0, _string.format)(textFormat, showDataFieldCaption ? "".concat(field.caption, " - ").concat(dataField.caption) : field.caption);
items.push({
beginGroup: 0 === sortingBySummaryItemCount,
icon: checked ? "desc" === field.sortOrder ? "sortdowntext" : "sortuptext" : "none",
text: text,
onItemClick: function() {
dataSource.field(field.index, {
sortBySummaryField: dataField.name || dataField.caption || dataField.dataField,
sortBySummaryPath: e.cell.path,
sortOrder: "desc" === field.sortOrder ? "asc" : "desc"
});
dataSource.load()
}
});
sortingBySummaryItemCount += 1
}))
}));
(0, _iterator.each)(oppositeAreaFields, (function(_, field) {
if (!field.allowSortingBySummary || !(0, _type.isDefined)(field.sortBySummaryField)) {
return
}
items.push({
beginGroup: 0 === sortingBySummaryItemCount,
icon: "none",
text: texts.removeAllSorting,
onItemClick: function() {
(0, _iterator.each)(oppositeAreaFields, (function(_, field) {
dataSource.field(field.index, {
sortBySummaryField: void 0,
sortBySummaryPath: void 0,
sortOrder: void 0
})
}));
dataSource.load()
}
});
return false
}))
}
}
if (that.option("fieldChooser.enabled")) {
items.push({
beginGroup: true,
icon: "columnchooser",
text: texts.showFieldChooser,
onItemClick: function() {
that._fieldChooserPopup.show()
}
})
}
if (that.option("export.enabled")) {
items.push({
beginGroup: true,
icon: "xlsxfile",
text: texts.exportToExcel,
onItemClick: function() {
that.exportTo()
}
})
}
e.items = items;
that._trigger("onContextMenuPreparing", e);
items = e.items;
if (items && items.length) {
return items
}
return
},
_createEventArgs: function(targetElement, dxEvent) {
var dataSource = this.getDataSource();
var args = {
rowFields: dataSource.getAreaFields("row"),
columnFields: dataSource.getAreaFields("column"),
dataFields: dataSource.getAreaFields("data"),
event: dxEvent
};
if ($targetElement = (0, _renderer.default)(targetElement), $targetElement.closest(".".concat("dx-area-fields")).length || $targetElement.find(".".concat("dx-area-fields")).length) {
return (0, _extend.extend)(this._createFieldArgs(targetElement), args)
}
var $targetElement;
return (0, _extend.extend)(this._createCellArgs(targetElement), args)
},
_createFieldArgs: function(targetElement) {
var field = (0, _renderer.default)(targetElement).children().data("field");
var args = {
field: field
};
return (0, _type.isDefined)(field) ? args : {}
},
_createCellArgs: function(cellElement) {
var $cellElement = (0, _renderer.default)(cellElement);
var columnIndex = cellElement.cellIndex;
var rowIndex = cellElement.parentElement.rowIndex;
var $table = $cellElement.closest("table");
var data = $table.data("data");
var cell = data && data[rowIndex] && data[rowIndex][columnIndex];
var args = {
area: $table.data("area"),
rowIndex: rowIndex,
columnIndex: columnIndex,
cellElement: (0, _element.getPublicElement)($cellElement),
cell: cell
};
return args
},
_handleCellClick: function(e) {
var that = this;
var args = that._createEventArgs(e.currentTarget, e);
var cell = args.cell;
if (!cell || !args.area && (args.rowIndex || args.columnIndex)) {
return
}
that._trigger("onCellClick", args);
cell && !args.cancel && (0, _type.isDefined)(cell.expanded) && setTimeout((function() {
that._dataController[cell.expanded ? "collapseHeaderItem" : "expandHeaderItem"](args.area, cell.path)
}))
},
_getNoDataText: function() {
return this.option("texts.noData")
},
_renderNoDataText: _m_utils.default.renderNoDataText,
_renderLoadPanel: _m_utils.default.renderLoadPanel,
_updateLoading: function(progress) {
var that = this;
var isLoading = that._dataController.isLoading();
if (!that._loadPanel) {
return
}
var loadPanelVisible = that._loadPanel.option("visible");
if (!loadPanelVisible) {
that._startLoadingTime = new Date
}
if (isLoading) {
if (progress) {
if (new Date - that._startLoadingTime >= 1e3) {
that._loadPanel.option("message", "".concat(Math.floor(100 * progress), "%"))
}
} else {
that._loadPanel.option("message", that.option("loadPanel.text"))
}
}
clearTimeout(that._hideLoadingTimeoutID);
if (loadPanelVisible && !isLoading) {
that._hideLoadingTimeoutID = setTimeout((function() {
that._loadPanel.option("visible", false);
that.$element().removeClass("dx-overflow-hidden")
}))
} else {
var visibilityOptions = {
visible: isLoading
};
if (isLoading) {
visibilityOptions.position = _m_utils.default.calculateLoadPanelPosition(that._dataArea.groupElement())
}
that._loadPanel.option(visibilityOptions);
that.$element().toggleClass("dx-overflow-hidden", !isLoading)
}
},
_renderDescriptionArea: function() {
var _this = this;
var $element = this.$element();
var $descriptionCell = $element.find(".".concat("dx-area-description-cell"));
var $toolbarContainer = (0, _renderer.default)(DIV).addClass("dx-pivotgrid-toolbar");
var fieldPanel = this.option("fieldPanel");
var $filterHeader = $element.find(".dx-filter-header");
var $columnHeader = $element.find(".dx-column-header");
var $targetContainer;
if (fieldPanel.visible && fieldPanel.showFilterFields) {
$targetContainer = $filterHeader
} else if (fieldPanel.visible && (fieldPanel.showDataFields || fieldPanel.showColumnFields)) {
$targetContainer = $columnHeader
} else {
$targetContainer = $descriptionCell
}
$columnHeader.toggleClass("dx-bottom-border", !!(fieldPanel.visible && (fieldPanel.showDataFields || fieldPanel.showColumnFields)));
$filterHeader.toggleClass("dx-bottom-border", !!(fieldPanel.visible && fieldPanel.showFilterFields));
$descriptionCell.toggleClass("dx-pivotgrid-background", fieldPanel.visible && (fieldPanel.showDataFields || fieldPanel.showColumnFields || fieldPanel.showRowFields));
this.$element().find(".dx-pivotgrid-toolbar").remove();
$toolbarContainer.prependTo($targetContainer);
if (this.option("fieldChooser.enabled")) {
var $buttonElement = (0, _renderer.default)(DIV).appendTo($toolbarContainer).addClass("dx-pivotgrid-field-chooser-button");
var buttonOptions = {
icon: "columnchooser",
hint: this.option("texts.showFieldChooser"),
onClick: function() {
_this.getFieldChooserPopup().show()
}
};
this._createComponent($buttonElement, "dxButton", buttonOptions)
}
if (this.option("export.enabled")) {
var _$buttonElement = (0, _renderer.default)(DIV).appendTo($toolbarContainer).addClass("dx-pivotgrid-export-button");
var _buttonOptions = {
icon: "xlsxfile",
hint: this.option("texts.exportToExcel"),
onClick: function() {
_this.exportTo()
}
};
this._createComponent(_$buttonElement, "dxButton", _buttonOptions)
}
},
_detectHasContainerHeight: function() {
var element = this.$element();
if ((0, _type.isDefined)(this._hasHeight)) {
var height = this.option("height") || this.$element().get(0).style.height;
if (height && this._hasHeight ^ "auto" !== height) {
this._hasHeight = null
}
}
if ((0, _type.isDefined)(this._hasHeight) || element.is(":hidden")) {
return
}
this._pivotGridContainer.addClass("dx-hidden");
var testElement = (0, _renderer.default)(DIV);
(0, _size.setHeight)(testElement, 66666);
element.append(testElement);
this._hasHeight = 66666 !== (0, _size.getHeight)(element);
this._pivotGridContainer.removeClass("dx-hidden");
testElement.remove()
},
_renderHeaders: function(rowHeaderContainer, columnHeaderContainer, filterHeaderContainer, dataHeaderContainer) {
var dataSource = this.getDataSource();
this._rowFields = this._rowFields || new _m_fields_area.FieldsArea(this, "row");
this._rowFields.render(rowHeaderContainer, dataSource.getAreaFields("row"));
this._columnFields = this._columnFields || new _m_fields_area.FieldsArea(this, "column");
this._columnFields.render(columnHeaderContainer, dataSource.getAreaFields("column"));
this._filterFields = this._filterFields || new _m_fields_area.FieldsArea(this, "filter");
this._filterFields.render(filterHeaderContainer, dataSource.getAreaFields("filter"));
this._dataFields = this._dataFields || new _m_fields_area.FieldsArea(this, "data");
this._dataFields.render(dataHeaderContainer, dataSource.getAreaFields("data"));
this.$element().dxPivotGridFieldChooserBase("instance").renderSortable()
},
_createTableElement: function() {
var $table = (0, _renderer.default)(" ").css({
width: "100%"
}).toggleClass("dx-pivotgrid-border", !!this.option("showBorders")).toggleClass("dx-word-wrap", !!this.option("wordWrapEnabled"));
_events_engine.default.on($table, (0, _index.addNamespace)(_click.name, "dxPivotGrid"), "td", this._handleCellClick.bind(this));
return $table
},
_renderDataArea: function(dataAreaElement) {
var dataArea = this._dataArea || new _m_data_area.default.DataArea(this);
this._dataArea = dataArea;
dataArea.render(dataAreaElement, this._dataController.getCellsInfo());
return dataArea
},
_renderRowsArea: function(rowsAreaElement) {
var rowsArea = this._rowsArea || new _m_headers_area.default.VerticalHeadersArea(this);
this._rowsArea = rowsArea;
rowsArea.render(rowsAreaElement, this._dataController.getRowsInfo());
return rowsArea
},
_renderColumnsArea: function(columnsAreaElement) {
var columnsArea = this._columnsArea || new _m_headers_area.default.HorizontalHeadersArea(this);
this._columnsArea = columnsArea;
columnsArea.render(columnsAreaElement, this._dataController.getColumnsInfo());
return columnsArea
},
_initMarkup: function() {
var that = this;
that.callBase.apply(this, arguments);
that.$element().addClass("dx-pivotgrid")
},
_renderContentImpl: function() {
var columnsAreaElement;
var rowsAreaElement;
var dataAreaElement;
var tableElement;
var isFirstDrawing = !this._pivotGridContainer;
var rowHeaderContainer;
var columnHeaderContainer;
var filterHeaderContainer;
var dataHeaderContainer;
tableElement = !isFirstDrawing && this._tableElement();
if (!tableElement) {
this.$element().addClass("dx-row-lines").addClass("dx-pivotgrid-fields-container");
this._pivotGridContainer = (0, _renderer.default)(DIV).addClass("dx-pivotgrid-container");
this._renderFieldChooser();
this._renderContextMenu();
columnsAreaElement = (0, _renderer.default)(TD).addClass("dx-area-column-cell");
rowsAreaElement = (0, _renderer.default)(TD).addClass("dx-area-row-cell");
dataAreaElement = (0, _renderer.default)(TD).addClass("dx-area-data-cell");
tableElement = this._createTableElement();
dataHeaderContainer = (0, _renderer.default)(TD).addClass("dx-data-header");
filterHeaderContainer = (0, _renderer.default)("").attr("colspan", "2").addClass("dx-filter-header");
columnHeaderContainer = (0, _renderer.default)(TD).addClass("dx-column-header");
rowHeaderContainer = (0, _renderer.default)(TD).addClass("dx-area-description-cell");
(0, _renderer.default)(TR).append(filterHeaderContainer).appendTo(tableElement);
(0, _renderer.default)(TR).append(dataHeaderContainer).append(columnHeaderContainer).appendTo(tableElement);
(0, _renderer.default)(TR).append(rowHeaderContainer).append(columnsAreaElement).appendTo(tableElement);
(0, _renderer.default)(TR).addClass("dx-bottom-row").append(rowsAreaElement).append(dataAreaElement).appendTo(tableElement);
this._pivotGridContainer.append(tableElement);
this.$element().append(this._pivotGridContainer);
if ("tree" === this.option("rowHeaderLayout")) {
rowsAreaElement.addClass("dx-area-tree-view")
}
}
this.$element().addClass("dx-overflow-hidden");
this._createComponent(this.$element(), _m_field_chooser_base.FieldChooserBase, {
dataSource: this.getDataSource(),
encodeHtml: this.option("encodeHtml"),
allowFieldDragging: this.option("fieldPanel.allowFieldDragging"),
headerFilter: this.option("headerFilter"),
visible: this.option("visible"),
remoteSort: "virtual" === this.option("scrolling.mode")
});
var dataArea = this._renderDataArea(dataAreaElement);
var rowsArea = this._renderRowsArea(rowsAreaElement);
var columnsArea = this._renderColumnsArea(columnsAreaElement);
dataArea.tableElement().prepend(columnsArea.headElement());
if (isFirstDrawing) {
this._renderLoadPanel(dataArea.groupElement().parent(), this.$element());
this._renderDescriptionArea();
rowsArea.renderScrollable();
columnsArea.renderScrollable();
dataArea.renderScrollable()
} [dataArea, rowsArea, columnsArea].forEach((function(area) {
unsubscribeScrollEvents(area)
}));
this._renderHeaders(rowHeaderContainer, columnHeaderContainer, filterHeaderContainer, dataHeaderContainer);
this._update(isFirstDrawing)
},
_update: function(isFirstDrawing) {
var that = this;
var updateHandler = function() {
that.updateDimensions()
};
if (that._needDelayResizing(that._dataArea.getData()) && isFirstDrawing) {
setTimeout(updateHandler)
} else {
updateHandler()
}
},
_fireContentReadyAction: function() {
if (!this._dataController.isLoading()) {
this.callBase()
}
},
getScrollPath: function(area) {
if ("column" === area) {
return this._columnsArea.getScrollPath(this._scrollLeft)
}
return this._rowsArea.getScrollPath(this._scrollTop)
},
getDataSource: function() {
return this._dataController.getDataSource()
},
getFieldChooserPopup: function() {
return this._fieldChooserPopup
},
hasScroll: function(area) {
return "column" === area ? this._columnsArea.hasScroll() : this._rowsArea.hasScroll()
},
_dimensionChanged: function() {
this.updateDimensions()
},
_visibilityChanged: function(visible) {
if (visible) {
this.updateDimensions()
}
},
_dispose: function() {
var that = this;
clearTimeout(that._hideLoadingTimeoutID);
that.callBase.apply(that, arguments);
if (that._dataController) {
that._dataController.dispose()
}
},
_tableElement: function() {
return this.$element().find("table").first()
},
addWidgetPrefix: function(className) {
return "dx-pivotgrid-".concat(className)
},
resize: function() {
this.updateDimensions()
},
isReady: function() {
return this.callBase() && !this._dataController.isLoading()
},
updateDimensions: function() {
var that = this;
var groupWidth;
var tableElement = that._tableElement();
var bordersWidth;
var totalWidth = 0;
var totalHeight = 0;
var rowsAreaWidth = 0;
var hasRowsScroll;
var hasColumnsScroll;
var dataAreaCell = tableElement.find(".".concat("dx-area-data-cell"));
var rowAreaCell = tableElement.find(".".concat("dx-area-row-cell"));
var columnAreaCell = tableElement.find(".".concat("dx-area-column-cell"));
var descriptionCell = tableElement.find(".".concat("dx-area-description-cell"));
var filterHeaderCell = tableElement.find(".dx-filter-header");
var columnHeaderCell = tableElement.find(".dx-column-header");
var rowFieldsHeader = that._rowFields;
var d = new _deferred.Deferred;
if (!(0, _window.hasWindow)()) {
return
}
var needSynchronizeFieldPanel = rowFieldsHeader.isVisible() && "tree" !== that.option("rowHeaderLayout");
that._detectHasContainerHeight();
if (!that._dataArea.headElement().length) {
that._dataArea.tableElement().prepend(that._columnsArea.headElement())
}
if (needSynchronizeFieldPanel) {
that._rowsArea.updateColspans(rowFieldsHeader.getColumnsCount());
that._rowsArea.tableElement().prepend(rowFieldsHeader.headElement())
}
tableElement.addClass("dx-incompressible-fields");
that._dataArea.reset();
that._rowsArea.reset();
that._columnsArea.reset();
rowFieldsHeader.reset();
var calculateHasScroll = function(areaSize, totalSize) {
return totalSize - areaSize >= 1
};
var calculateGroupHeight = function(dataAreaHeight, totalHeight, hasRowsScroll, hasColumnsScroll, scrollBarWidth) {
return hasRowsScroll ? dataAreaHeight : totalHeight + (hasColumnsScroll ? scrollBarWidth : 0)
};
(0, _common.deferUpdate)((function() {
var rowHeights = that._rowsArea.getRowsHeight();
var descriptionCellHeight = (0, _size.getOuterHeight)(descriptionCell[0], true) + (needSynchronizeFieldPanel ? rowHeights[0] : 0);
var filterAreaHeight = 0;
var dataAreaHeight = 0;
if (that._hasHeight) {
filterAreaHeight = (0, _size.getHeight)(filterHeaderCell);
var $dataHeader = tableElement.find(".dx-data-header");
var dataHeaderHeight = (0, _size.getHeight)($dataHeader);
bordersWidth = getCommonBorderWidth([columnAreaCell, dataAreaCell, tableElement, columnHeaderCell, filterHeaderCell], "height");
dataAreaHeight = (0, _size.getHeight)(that.$element()) - filterAreaHeight - dataHeaderHeight - (Math.max((0, _size.getHeight)(that._dataArea.headElement()), (0, _size.getHeight)(columnAreaCell), descriptionCellHeight) + bordersWidth)
}
var scrollBarWidth = that._dataArea.getScrollbarWidth();
var hasVerticalScrollbar = calculateHasScroll(dataAreaHeight, (0, _size.getHeight)(that._dataArea.tableElement()));
that._dataArea.tableElement().css({
width: that._hasHeight && hasVerticalScrollbar && scrollBarWidth ? "calc(100% - ".concat(scrollBarWidth, "px)") : "100%"
});
var resultWidths = that._dataArea.getColumnsWidth();
var rowsAreaHeights = needSynchronizeFieldPanel ? rowHeights.slice(1) : rowHeights;
var dataAreaHeights = that._dataArea.getRowsHeight();
var columnsAreaRowCount = that._dataController.getColumnsInfo().length;
var resultHeights = (0, _m_widget_utils.mergeArraysByMaxValue)(rowsAreaHeights, dataAreaHeights.slice(columnsAreaRowCount));
var columnsAreaRowHeights = dataAreaHeights.slice(0, columnsAreaRowCount);
var columnsAreaHeight = getArraySum(columnsAreaRowHeights);
var rowsAreaColumnWidths = that._rowsArea.getColumnsWidth();
totalWidth = (0, _size.getWidth)(that._dataArea.tableElement());
totalHeight = getArraySum(resultHeights);
if (!totalWidth || !totalHeight) {
d.resolve();
return
}
rowsAreaWidth = getArraySum(rowsAreaColumnWidths);
var elementWidth = (0, _size.getWidth)(that.$element());
bordersWidth = getCommonBorderWidth([rowAreaCell, dataAreaCell, tableElement], "width");
groupWidth = elementWidth - rowsAreaWidth - bordersWidth;
groupWidth = groupWidth > 0 ? groupWidth : totalWidth;
var diff = totalWidth - groupWidth;
var needAdjustWidthOnZoom = diff >= 0 && diff <= 2;
if (needAdjustWidthOnZoom) {
adjustSizeArray(resultWidths, diff);
totalWidth = groupWidth
}
hasRowsScroll = that._hasHeight && calculateHasScroll(dataAreaHeight, totalHeight);
hasColumnsScroll = calculateHasScroll(groupWidth, totalWidth);
var groupHeight = calculateGroupHeight(dataAreaHeight, totalHeight, hasRowsScroll, hasColumnsScroll, scrollBarWidth);
(0, _common.deferRender)((function() {
that._columnsArea.tableElement().append(that._dataArea.headElement());
rowFieldsHeader.tableElement().append(that._rowsArea.headElement());
if (descriptionCellHeight > columnsAreaHeight) {
adjustSizeArray(columnsAreaRowHeights, columnsAreaHeight - descriptionCellHeight);
that._columnsArea.setRowsHeight(columnsAreaRowHeights)
}
tableElement.removeClass("dx-incompressible-fields");
columnHeaderCell.children().css("maxWidth", groupWidth);
that._columnsArea.setGroupWidth(groupWidth);
that._columnsArea.processScrollBarSpacing(hasRowsScroll ? scrollBarWidth : 0);
that._columnsArea.setColumnsWidth(resultWidths);
that._rowsArea.setGroupHeight(that._hasHeight ? groupHeight : "auto");
that._rowsArea.processScrollBarSpacing(hasColumnsScroll ? scrollBarWidth : 0);
that._rowsArea.setColumnsWidth(rowsAreaColumnWidths);
that._rowsArea.setRowsHeight(resultHeights);
that._dataArea.setColumnsWidth(resultWidths);
that._dataArea.setRowsHeight(resultHeights);
that._dataArea.setGroupWidth(groupWidth);
that._dataArea.setGroupHeight(that._hasHeight ? groupHeight : "auto");
needSynchronizeFieldPanel && rowFieldsHeader.setColumnsWidth(rowsAreaColumnWidths);
dataAreaCell.toggleClass("dx-bottom-border", !hasRowsScroll);
rowAreaCell.toggleClass("dx-bottom-border", !hasRowsScroll);
if (!that._hasHeight && elementWidth !== (0, _size.getWidth)(that.$element())) {
var _diff = elementWidth - (0, _size.getWidth)(that.$element());
if (!hasColumnsScroll) {
adjustSizeArray(resultWidths, _diff);
that._columnsArea.setColumnsWidth(resultWidths);
that._dataArea.setColumnsWidth(resultWidths)
}
that._dataArea.setGroupWidth(groupWidth - _diff);
that._columnsArea.setGroupWidth(groupWidth - _diff)
}
if (that._hasHeight && that._filterFields.isVisible() && (0, _size.getHeight)(filterHeaderCell) !== filterAreaHeight) {
var _diff2 = (0, _size.getHeight)(filterHeaderCell) - filterAreaHeight;
if (_diff2 > 0) {
hasRowsScroll = calculateHasScroll(dataAreaHeight - _diff2, totalHeight);
var _groupHeight = calculateGroupHeight(dataAreaHeight - _diff2, totalHeight, hasRowsScroll, hasColumnsScroll, scrollBarWidth);
that._dataArea.setGroupHeight(_groupHeight);
that._rowsArea.setGroupHeight(_groupHeight)
}
}
var scrollingOptions = that.option("scrolling");
if ("virtual" === scrollingOptions.mode) {
that._setVirtualContentParams(scrollingOptions, resultWidths, resultHeights, groupWidth, groupHeight, that._hasHeight, rowsAreaWidth)
}
var updateScrollableResults = [];
that._dataArea.updateScrollableOptions({
direction: that._dataArea.getScrollableDirection(hasColumnsScroll, hasRowsScroll),
rtlEnabled: that.option("rtlEnabled")
});
that._columnsArea.updateScrollableOptions({
rtlEnabled: that.option("rtlEnabled")
});
(0, _iterator.each)([that._columnsArea, that._rowsArea, that._dataArea], (function(_, area) {
updateScrollableResults.push(area && area.updateScrollable())
}));
that._updateLoading();
that._renderNoDataText(dataAreaCell);
_deferred.when.apply(_renderer.default, updateScrollableResults).done((function() {
that._updateScrollPosition(that._columnsArea, that._rowsArea, that._dataArea, true);
that._subscribeToEvents(that._columnsArea, that._rowsArea, that._dataArea);
d.resolve()
}))
}))
}));
return d
},
_setVirtualContentParams: function(scrollingOptions, resultWidths, resultHeights, groupWidth, groupHeight, hasHeight, rowsAreaWidth) {
var virtualContentParams = this._dataController.calculateVirtualContentParams({
virtualRowHeight: scrollingOptions.virtualRowHeight,
virtualColumnWidth: scrollingOptions.virtualColumnWidth,
itemWidths: resultWidths,
itemHeights: resultHeights,
rowCount: resultHeights.length,
columnCount: resultWidths.length,
viewportWidth: groupWidth,
viewportHeight: hasHeight ? groupHeight : (0, _size.getOuterHeight)(window)
});
this._dataArea.setVirtualContentParams({
top: virtualContentParams.contentTop,
left: virtualContentParams.contentLeft,
width: virtualContentParams.width,
height: virtualContentParams.height
});
this._rowsArea.setVirtualContentParams({
top: virtualContentParams.contentTop,
width: rowsAreaWidth,
height: virtualContentParams.height
});
this._columnsArea.setVirtualContentParams({
left: virtualContentParams.contentLeft,
width: virtualContentParams.width,
height: (0, _size.getHeight)(this._columnsArea.groupElement())
})
},
applyPartialDataSource: function(area, path, dataSource) {
this._dataController.applyPartialDataSource(area, path, dataSource)
}
}).inherit(_m_export.ExportController).include(_m_chart_integration.ChartIntegrationMixin);
exports.PivotGrid = PivotGrid;
(0, _component_registrator.default)("dxPivotGrid", PivotGrid);
var _default = {
PivotGrid: PivotGrid
};
exports.default = _default
},
28580:
/*!*******************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/pivot_grid/m_widget_utils.js ***!
\*******************************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.calculateScrollbarWidth = void 0;
exports.capitalizeFirstLetter = capitalizeFirstLetter;
exports.createPath = createPath;
exports.default = void 0;
exports.discoverObjectFields = discoverObjectFields;
exports.findField = findField;
exports.foreachDataLevel = foreachDataLevel;
exports.foreachTreeAsync = exports.foreachTree = void 0;
exports.formatValue = formatValue;
exports.getCompareFunction = getCompareFunction;
exports.getExpandedLevel = getExpandedLevel;
exports.getFieldsDataType = getFieldsDataType;
exports.getFiltersByPath = getFiltersByPath;
exports.getScrollbarWidth = void 0;
exports.mergeArraysByMaxValue = mergeArraysByMaxValue;
exports.sendRequest = sendRequest;
exports.setDefaultFieldValueFormatting = setDefaultFieldValueFormatting;
exports.storeDrillDownMixin = exports.setFieldProperty = void 0;
var _dom_adapter = _interopRequireDefault(__webpack_require__( /*! ../../../core/dom_adapter */ 73349));
var _ajax = _interopRequireDefault(__webpack_require__( /*! ../../../core/utils/ajax */ 37208));
var _call_once = _interopRequireDefault(__webpack_require__( /*! ../../../core/utils/call_once */ 39618));
var _data = __webpack_require__( /*! ../../../core/utils/data */ 47617);
var _deferred = __webpack_require__( /*! ../../../core/utils/deferred */ 62754);
var _extend = __webpack_require__( /*! ../../../core/utils/extend */ 13306);
var _iterator = __webpack_require__( /*! ../../../core/utils/iterator */ 95479);
var _type = __webpack_require__( /*! ../../../core/utils/type */ 35922);
var _array_store = _interopRequireDefault(__webpack_require__( /*! ../../../data/array_store */ 26562));
var _data_source = __webpack_require__( /*! ../../../data/data_source/data_source */ 85273);
var _format_helper = _interopRequireDefault(__webpack_require__( /*! ../../../format_helper */ 30343));
var _date = _interopRequireDefault(__webpack_require__( /*! ../../../localization/date */ 91500));
var _const = __webpack_require__( /*! ./const */ 18813);
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var setFieldProperty = function(field, property, value, isInitialization) {
var initProperties = field._initProperties = field._initProperties || {};
var initValue = isInitialization ? value : field[property];
var needInitProperty = !Object.prototype.hasOwnProperty.call(initProperties, property) || isInitialization;
if (needInitProperty && "_initProperties" !== property) {
initProperties[property] = initValue
}
field[property] = value
};
exports.setFieldProperty = setFieldProperty;
function sendRequest(options) {
return _ajax.default.sendRequest(options)
}
var foreachTreeAsyncDate = new Date;
function createForeachTreeFunc(isAsync) {
return function foreachTreeFunc(items, callback, parentAtFirst, members, index, isChildrenProcessing) {
members = members || [];
items = items || [];
var i;
var deferred;
index = index || 0;
function createForeachTreeAsyncHandler(deferred, i, isChildrenProcessing) {
(0, _deferred.when)(foreachTreeFunc(items, callback, parentAtFirst, members, i, isChildrenProcessing)).done(deferred.resolve)
}
for (i = index; i < items.length; i += 1) {
if (isAsync && i > index && i % 1e4 === 0 && new Date - foreachTreeAsyncDate >= 300) {
foreachTreeAsyncDate = new Date;
deferred = new _deferred.Deferred;
createForeachTreeAsyncHandler(deferred, i, false);
return deferred
}
var item = items[i];
if (!isChildrenProcessing) {
members.unshift(item);
if (parentAtFirst && false === callback(members, i)) {
return
}
if (item.children) {
var childrenDeferred = foreachTreeFunc(item.children, callback, parentAtFirst, members);
if (isAsync && childrenDeferred) {
deferred = new _deferred.Deferred;
childrenDeferred.done(createForeachTreeAsyncHandler(deferred, i, true));
return deferred
}
}
}
isChildrenProcessing = false;
if (!parentAtFirst && false === callback(members, i)) {
return
}
members.shift();
if (items[i] !== item) {
i -= 1
}
}
return
}
}
var foreachTree = createForeachTreeFunc(false);
exports.foreachTree = foreachTree;
var foreachTreeAsync = createForeachTreeFunc(true);
exports.foreachTreeAsync = foreachTreeAsync;
function findField(fields, id) {
if (fields && (0, _type.isDefined)(id)) {
for (var i = 0; i < fields.length; i += 1) {
var field = fields[i];
if (field.name === id || field.caption === id || field.dataField === id || field.index === id) {
return i
}
}
}
return -1
}
function formatValue(value, options) {
var valueText = value === value && _format_helper.default.format(value, options.format);
var formatObject = {
value: value,
valueText: valueText || ""
};
return options.customizeText ? options.customizeText.call(options, formatObject) : formatObject.valueText
}
function getCompareFunction(valueSelector) {
return function(a, b) {
var result = 0;
var valueA = valueSelector(a);
var valueB = valueSelector(b);
var aIsDefined = (0, _type.isDefined)(valueA);
var bIsDefined = (0, _type.isDefined)(valueB);
if (aIsDefined && bIsDefined) {
if (valueA > valueB) {
result = 1
} else if (valueA < valueB) {
result = -1
}
}
if (aIsDefined && !bIsDefined) {
result = 1
}
if (!aIsDefined && bIsDefined) {
result = -1
}
return result
}
}
function createPath(items) {
var result = [];
for (var i = items.length - 1; i >= 0; i -= 1) {
result.push(items[i].key || items[i].value)
}
return result
}
function foreachDataLevel(data, callback, index, childrenField) {
index = index || 0;
childrenField = childrenField || "children";
if (data.length) {
callback(data, index)
}
for (var i = 0; i < data.length; i += 1) {
var item = data[i];
if (item[childrenField] && item[childrenField].length) {
foreachDataLevel(item[childrenField], callback, index + 1, childrenField)
}
}
}
function mergeArraysByMaxValue(values1, values2) {
var result = [];
for (var i = 0; i < values1.length; i += 1) {
result.push(Math.max(values1[i] || 0, values2[i] || 0))
}
return result
}
function getExpandedLevel(options, axisName) {
var dimensions = options[axisName];
var expandLevel = 0;
var expandedPaths = ("columns" === axisName ? options.columnExpandedPaths : options.rowExpandedPaths) || [];
if (options.headerName === axisName) {
expandLevel = options.path.length
} else if (options.headerName && options.headerName !== axisName && options.oppositePath) {
expandLevel = options.oppositePath.length
} else {
(0, _iterator.each)(expandedPaths, (function(_, path) {
expandLevel = Math.max(expandLevel, path.length)
}))
}
while (dimensions[expandLevel + 1] && dimensions[expandLevel].expanded) {
expandLevel += 1
}
return expandLevel
}
function parseFields(dataSource, fieldsList, path, fieldsDataType) {
var result = [];
Object.keys(fieldsList || []).forEach((function(field) {
if (field && field.startsWith("__")) {
return
}
var dataIndex = 1;
var currentPath = path.length ? "".concat(path, ".").concat(field) : field;
var dataType = fieldsDataType[currentPath];
var getter = (0, _data.compileGetter)(currentPath);
var value = fieldsList[field];
var items;
while (!(0, _type.isDefined)(value) && dataSource[dataIndex]) {
value = getter(dataSource[dataIndex]);
dataIndex += 1
}
if (!dataType && (0, _type.isDefined)(value)) {
dataType = (0, _type.type)(value)
}
items = [{
dataField: currentPath,
dataType: dataType,
groupName: "date" === dataType ? field : void 0,
groupInterval: void 0,
displayFolder: path
}];
if ("date" === dataType) {
items = items.concat((item = items[0], (0, _iterator.map)(["year", "quarter", "month"], (function(value, index) {
return (0, _extend.extend)({}, item, {
groupInterval: value,
groupIndex: index
})
}))))
} else if ("object" === dataType) {
items = parseFields(dataSource, value, currentPath, fieldsDataType)
}
var item;
result.push.apply(result, items)
}));
return result
}
function discoverObjectFields(items, fields) {
var fieldsDataType = getFieldsDataType(fields);
return parseFields(items, items[0], "", fieldsDataType)
}
function getFieldsDataType(fields) {
var result = {};
(0, _iterator.each)(fields, (function(_, field) {
result[field.dataField] = result[field.dataField] || field.dataType
}));
return result
}
var DATE_INTERVAL_FORMATS = {
month: function(value) {
return _date.default.getMonthNames()[value - 1]
},
quarter: function(value) {
return _date.default.format(new Date(2e3, 3 * value - 1), "quarter")
},
dayOfWeek: function(value) {
return _date.default.getDayNames()[value]
}
};
function setDefaultFieldValueFormatting(field) {
if ("date" === field.dataType) {
if (!field.format) {
setFieldProperty(field, "format", DATE_INTERVAL_FORMATS[field.groupInterval])
}
} else if ("number" === field.dataType) {
var groupInterval = (0, _type.isNumeric)(field.groupInterval) && field.groupInterval > 0 && field.groupInterval;
if (groupInterval && !field.customizeText) {
setFieldProperty(field, "customizeText", (function(formatObject) {
var secondValue = formatObject.value + groupInterval;
var secondValueText = _format_helper.default.format(secondValue, field.format);
return formatObject.valueText && secondValueText ? "".concat(formatObject.valueText, " - ").concat(secondValueText) : ""
}))
}
}
}
function getFiltersByPath(fields, path) {
var result = [];
path = path || [];
for (var i = 0; i < path.length; i += 1) {
result.push((0, _extend.extend)({}, fields[i], {
groupIndex: null,
groupName: null,
filterType: "include",
filterValues: [path[i]]
}))
}
return result
}
var storeDrillDownMixin = {
createDrillDownDataSource: function(descriptions, params) {
var items = this.getDrillDownItems(descriptions, params);
function createCustomStoreMethod(methodName) {
return function(options) {
var d;
if (void 0) {
d = (void 0)[methodName](options)
} else {
d = new _deferred.Deferred;
(0, _deferred.when)(items).done((function(data) {
var arrayStore = new _array_store.default(data);
arrayStore[methodName](options).done(d.resolve).fail(d.reject)
})).fail(d.reject)
}
return d
}
}
var dataSource = new _data_source.DataSource({
load: createCustomStoreMethod("load"),
totalCount: createCustomStoreMethod("totalCount"),
key: this.key()
});
return dataSource
}
};
exports.storeDrillDownMixin = storeDrillDownMixin;
function capitalizeFirstLetter(string) {
return string.charAt(0).toUpperCase() + string.slice(1)
}
var getScrollbarWidth = function(containerElement) {
return containerElement.offsetWidth - containerElement.clientWidth
};
exports.getScrollbarWidth = getScrollbarWidth;
var calculateScrollbarWidth = (0, _call_once.default)((function() {
var document = _dom_adapter.default.getDocument();
document.body.insertAdjacentHTML("beforeend", ''));
var scrollbar = document.body.lastElementChild;
var scrollbarWidth = getScrollbarWidth(scrollbar);
if (scrollbar) {
document.body.removeChild(scrollbar)
}
return scrollbarWidth
}));
exports.calculateScrollbarWidth = calculateScrollbarWidth;
var _default = {
setFieldProperty: setFieldProperty,
sendRequest: sendRequest,
foreachTree: foreachTree,
foreachTreeAsync: foreachTreeAsync,
findField: findField,
formatValue: formatValue,
getCompareFunction: getCompareFunction,
createPath: createPath,
foreachDataLevel: foreachDataLevel,
mergeArraysByMaxValue: mergeArraysByMaxValue,
getExpandedLevel: getExpandedLevel,
discoverObjectFields: discoverObjectFields,
getFieldsDataType: getFieldsDataType,
setDefaultFieldValueFormatting: setDefaultFieldValueFormatting,
getFiltersByPath: getFiltersByPath,
storeDrillDownMixin: storeDrillDownMixin,
capitalizeFirstLetter: capitalizeFirstLetter,
getScrollbarWidth: getScrollbarWidth,
calculateScrollbarWidth: calculateScrollbarWidth
};
exports.default = _default
},
2166:
/*!********************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/pivot_grid/remote_store/m_remote_store.js ***!
\********************************************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
function _typeof(obj) {
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)
}
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = exports.RemoteStore = void 0;
var _class = _interopRequireDefault(__webpack_require__( /*! ../../../../core/class */ 38377));
var _date_serialization = _interopRequireDefault(__webpack_require__( /*! ../../../../core/utils/date_serialization */ 69434));
var _deferred = __webpack_require__( /*! ../../../../core/utils/deferred */ 62754);
var _extend = __webpack_require__( /*! ../../../../core/utils/extend */ 13306);
var _iterator = __webpack_require__( /*! ../../../../core/utils/iterator */ 95479);
var _type = __webpack_require__( /*! ../../../../core/utils/type */ 35922);
var _data_source = __webpack_require__( /*! ../../../../data/data_source/data_source */ 85273);
var _utils = __webpack_require__( /*! ../../../../data/data_source/utils */ 9234);
var _m_widget_utils = function(obj, nodeInterop) {
if (!nodeInterop && obj && obj.__esModule) {
return obj
}
if (null === obj || "object" !== _typeof(obj) && "function" !== typeof obj) {
return {
default: obj
}
}
var cache = _getRequireWildcardCache(nodeInterop);
if (cache && cache.has(obj)) {
return cache.get(obj)
}
var newObj = {};
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
for (var key in obj) {
if ("default" !== key && Object.prototype.hasOwnProperty.call(obj, key)) {
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
if (desc && (desc.get || desc.set)) {
Object.defineProperty(newObj, key, desc)
} else {
newObj[key] = obj[key]
}
}
}
newObj.default = obj;
if (cache) {
cache.set(obj, newObj)
}
return newObj
}(__webpack_require__( /*! ../m_widget_utils */ 28580));
var _m_remote_store_utils = __webpack_require__( /*! ./m_remote_store_utils */ 98413);
function _getRequireWildcardCache(nodeInterop) {
if ("function" !== typeof WeakMap) {
return null
}
var cacheBabelInterop = new WeakMap;
var cacheNodeInterop = new WeakMap;
return (_getRequireWildcardCache = function(nodeInterop) {
return nodeInterop ? cacheNodeInterop : cacheBabelInterop
})(nodeInterop)
}
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
function _toConsumableArray(arr) {
return function(arr) {
if (Array.isArray(arr)) {
return _arrayLikeToArray(arr)
}
}(arr) || function(iter) {
if ("undefined" !== typeof Symbol && null != iter[Symbol.iterator] || null != iter["@@iterator"]) {
return Array.from(iter)
}
}(arr) || function(o, minLen) {
if (!o) {
return
}
if ("string" === typeof o) {
return _arrayLikeToArray(o, minLen)
}
var n = Object.prototype.toString.call(o).slice(8, -1);
if ("Object" === n && o.constructor) {
n = o.constructor.name
}
if ("Map" === n || "Set" === n) {
return Array.from(o)
}
if ("Arguments" === n || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) {
return _arrayLikeToArray(o, minLen)
}
}(arr) || function() {
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 _arrayLikeToArray(arr, len) {
if (null == len || len > arr.length) {
len = arr.length
}
for (var i = 0, arr2 = new Array(len); i < len; i++) {
arr2[i] = arr[i]
}
return arr2
}
function createGroupingOptions(dimensionOptions, useSortOrder) {
var groupingOptions = [];
(0, _iterator.each)(dimensionOptions, (function(index, dimensionOption) {
groupingOptions.push({
selector: dimensionOption.dataField,
groupInterval: dimensionOption.groupInterval,
desc: useSortOrder && "desc" === dimensionOption.sortOrder,
isExpanded: index < dimensionOptions.length - 1
})
}));
return groupingOptions
}
function getIntervalFilterExpression(selector, numericInterval, numericValue, isExcludedFilterType) {
var startFilterValue = [selector, isExcludedFilterType ? "<" : ">=", numericValue];
var endFilterValue = [selector, isExcludedFilterType ? ">=" : "<", numericValue + numericInterval];
return [startFilterValue, isExcludedFilterType ? "or" : "and", endFilterValue]
}
function getFilterExpressionForFilterValue(field, filterValue) {
var selector = function(field) {
var selector = field.dataField;
var groupInterval = field.groupInterval;
if ("date" === field.dataType && "string" === typeof groupInterval) {
if ("quarter" === groupInterval.toLowerCase()) {
groupInterval = "Month"
}
selector = "".concat(selector, ".").concat((0, _m_widget_utils.capitalizeFirstLetter)(groupInterval))
}
return selector
}(field);
var isExcludedFilterType = "exclude" === field.filterType;
var expression = [selector, isExcludedFilterType ? "<>" : "=", filterValue];
if ((0, _type.isDefined)(field.groupInterval)) {
if ("string" === typeof field.groupInterval && "quarter" === field.groupInterval.toLowerCase()) {
expression = getIntervalFilterExpression(selector, 3, 3 * (filterValue - 1) + 1, isExcludedFilterType)
} else if ("number" === typeof field.groupInterval && "date" !== field.dataType) {
expression = getIntervalFilterExpression(selector, field.groupInterval, filterValue, isExcludedFilterType)
}
}
return expression
}
function createFilterExpressions(fields) {
var filterExpressions = [];
(0, _iterator.each)(fields, (function(_, field) {
var fieldExpressions = function createFieldFilterExpressions(field, operation) {
var fieldFilterExpressions = [];
if (field.searchValue) {
return [field.dataField, "contains", field.searchValue]
}
if ("exclude" === field.filterType) {
operation = operation || "and"
} else {
operation = operation || "or"
}(0, _iterator.each)(field.filterValues, (function(index, filterValue) {
var currentExpression = [];
if (Array.isArray(filterValue)) {
var parseLevelsRecursive = field.levels && field.levels.length;
if (parseLevelsRecursive) {
currentExpression = createFieldFilterExpressions({
filterValues: filterValue,
filterType: field.filterType,
levels: field.levels
}, "and")
}
} else {
var currentField = field.levels ? field.levels[index] : field;
currentExpression = getFilterExpressionForFilterValue(currentField, filterValue)
}
if (!currentExpression.length) {
return
}
if (fieldFilterExpressions.length) {
fieldFilterExpressions.push(operation)
}
fieldFilterExpressions.push(currentExpression)
}));
return fieldFilterExpressions
}(field);
if (!fieldExpressions.length) {
return []
}
if (filterExpressions.length) {
filterExpressions.push("and")
}
filterExpressions.push(fieldExpressions);
return
}));
if (1 === filterExpressions.length) {
filterExpressions = filterExpressions[0]
}
return filterExpressions
}
function mergeFilters(filter1, filter2) {
var mergedFilter;
var notEmpty = function(filter) {
return filter && filter.length
};
if (notEmpty(filter1) && notEmpty(filter2)) {
mergedFilter = [filter1, "and", filter2]
} else {
mergedFilter = notEmpty(filter1) ? filter1 : filter2
}
return mergedFilter
}
function setValue(valuesArray, value, rowIndex, columnIndex, dataIndex) {
valuesArray[rowIndex] = valuesArray[rowIndex] || [];
valuesArray[rowIndex][columnIndex] = valuesArray[rowIndex][columnIndex] || [];
if (!(0, _type.isDefined)(valuesArray[rowIndex][columnIndex][dataIndex])) {
valuesArray[rowIndex][columnIndex][dataIndex] = value
}
}
function parseValue(value, field) {
if (field && "number" === field.dataType && (0, _type.isString)(value)) {
return Number(value)
}
if (field && "date" === field.dataType && !field.groupInterval && !(value instanceof Date)) {
return _date_serialization.default.deserializeDate(value)
}
return value
}
function parseResult(data, total, descriptions, result) {
var rowPath = [];
var columnPath = [];
var rowHash = result.rowHash;
var columnHash = result.columnHash;
if (total && total.summary) {
(0, _iterator.each)(total.summary, (function(index, summary) {
setValue(result.values, summary, result.grandTotalRowIndex, result.grandTotalColumnIndex, index)
}))
}
if (total && total.groupCount >= 0) {
var skip = descriptions.rows.length ? descriptions.rowSkip : descriptions.columnSkip;
data = _toConsumableArray(Array(skip)).concat(data);
data.length = total.groupCount
}
function getItem(dataItem, dimensionName, path, level, field) {
var dimensionHash = result["".concat(dimensionName, "Hash")];
var parentItem;
var parentItemChildren;
var item;
var pathValue = path.slice(0, level + 1).join("/");
var parentPathValue;
if (void 0 !== dimensionHash[pathValue]) {
item = dimensionHash[pathValue]
} else {
item = {
value: parseValue(dataItem.key, field),
index: result["".concat(dimensionName, "Index")]++,
displayText: dataItem.displayText
};
parentPathValue = path.slice(0, level).join("/");
if (level > 0 && void 0 !== dimensionHash[parentPathValue]) {
parentItem = dimensionHash[parentPathValue];
parentItemChildren = parentItem.children = parentItem.children || []
} else {
parentItemChildren = result["".concat(dimensionName, "s")]
}
parentItemChildren.push(item);
dimensionHash[pathValue] = item
}
return item
}(0, _m_remote_store_utils.forEachGroup)(data, (function(item, level) {
var rowLevel = level >= descriptions.rows.length ? descriptions.rows.length : level;
var columnLevel = level >= descriptions.rows.length ? level - descriptions.rows.length : 0;
var columnItem;
var rowItem;
if (level >= descriptions.rows.length && columnLevel >= descriptions.columns.length) {
return
}
if (level < descriptions.rows.length) {
columnPath = []
}
if (level >= descriptions.rows.length) {
if (item) {
columnPath[columnLevel] = "".concat(item.key);
columnItem = getItem(item, "column", columnPath, columnLevel, descriptions.columns[columnLevel]);
rowItem = rowHash[rowPath.slice(0, rowLevel + 1).join("/")]
} else {
result.columns.push({})
}
} else if (item) {
rowPath[rowLevel] = "".concat(item.key);
rowItem = getItem(item, "row", rowPath, rowLevel, descriptions.rows[rowLevel]);
columnItem = columnHash[columnPath.slice(0, columnLevel + 1).join("/")]
} else {
result.rows.push({})
}
var currentRowIndex = rowItem && rowItem.index || result.grandTotalRowIndex;
var currentColumnIndex = columnItem && columnItem.index || result.grandTotalColumnIndex;
(0, _iterator.each)(item && item.summary || [], (function(i, summary) {
setValue(result.values, summary, currentRowIndex, currentColumnIndex, i)
}))
}));
return result
}
function getFiltersForDimension(fields) {
return (fields || []).filter((function(f) {
return f.filterValues && f.filterValues.length || f.searchValue
}))
}
function getExpandedIndex(options, axis) {
if (options.headerName) {
if (axis === options.headerName) {
return options.path.length
}
if (options.oppositePath) {
return options.oppositePath.length
}
}
return 0
}
function getExpandedPathSliceFilter(options, dimensionName, level, firstCollapsedFieldIndex) {
var result = [];
var startSliceIndex = level > firstCollapsedFieldIndex ? 0 : firstCollapsedFieldIndex;
var fields = options.headerName !== dimensionName ? options[dimensionName].slice(startSliceIndex, level) : [];
var paths = "rows" === dimensionName ? options.rowExpandedPaths : options.columnExpandedPaths;
(0, _iterator.each)(fields, (function(index, field) {
var filterValues = [];
(0, _iterator.each)(paths, (function(_, path) {
path = path.slice(startSliceIndex, level);
if (index < path.length) {
var filterValue = path[index];
if (!filterValues.includes(filterValue)) {
filterValues.push(filterValue)
}
}
}));
if (filterValues.length) {
result.push((0, _extend.extend)({}, field, {
filterType: "include",
filterValues: filterValues
}))
}
}));
return result
}
function getGrandTotalRequest(options, dimensionName, expandedIndex, expandedLevel, commonFilters, firstCollapsedFieldIndex) {
var expandedPaths = ("columns" === dimensionName ? options.columnExpandedPaths : options.rowExpandedPaths) || [];
var oppositeDimensionName = "columns" === dimensionName ? "rows" : "columns";
var fields = options[dimensionName];
var result = [];
var newOptions;
if (expandedPaths.length) {
for (var i = expandedIndex; i < expandedLevel + 1; i += 1) {
newOptions = {
filters: commonFilters.concat(getExpandedPathSliceFilter(options, dimensionName, i, firstCollapsedFieldIndex))
};
newOptions[dimensionName] = fields.slice(expandedIndex, i + 1);
newOptions[oppositeDimensionName] = [];
result.push((0, _extend.extend)({}, options, newOptions))
}
} else {
newOptions = {
filters: commonFilters
};
newOptions[dimensionName] = fields.slice(expandedIndex, expandedLevel + 1);
newOptions[oppositeDimensionName] = [];
result.push((0, _extend.extend)({}, options, newOptions))
}
result[0].includeTotalSummary = true;
return result
}
function getFirstCollapsedIndex(fields) {
var firstCollapsedIndex = 0;
(0, _iterator.each)(fields, (function(index, field) {
if (!field.expanded) {
firstCollapsedIndex = index;
return false
}
return
}));
return firstCollapsedIndex
}
function getRequestsData(options) {
var rowExpandedLevel = (0, _m_widget_utils.getExpandedLevel)(options, "rows");
var columnExpandedLevel = (0, _m_widget_utils.getExpandedLevel)(options, "columns");
var filters = options.filters || [];
var columnExpandedIndex = getExpandedIndex(options, "columns");
var firstCollapsedColumnIndex = getFirstCollapsedIndex(options.columns);
var firstCollapsedRowIndex = getFirstCollapsedIndex(options.rows);
var rowExpandedIndex = getExpandedIndex(options, "rows");
var data = [];
filters = filters.concat(getFiltersForDimension(options.rows)).concat(getFiltersForDimension(options.columns)).concat(function(options) {
return (0, _m_widget_utils.getFiltersByPath)(options[options.headerName], options.path).concat((0, _m_widget_utils.getFiltersByPath)(options["rows" === options.headerName ? "columns" : "rows"], options.oppositePath || []))
}(options));
var columnTotalsOptions = getGrandTotalRequest(options, "columns", columnExpandedIndex, columnExpandedLevel, filters, firstCollapsedColumnIndex);
if (options.rows.length && options.columns.length) {
if ("rows" !== options.headerName) {
data = data.concat(columnTotalsOptions)
}
for (var i = rowExpandedIndex; i < rowExpandedLevel + 1; i += 1) {
var rows = options.rows.slice(rowExpandedIndex, i + 1);
var rowFilterByExpandedPaths = getExpandedPathSliceFilter(options, "rows", i, firstCollapsedRowIndex);
for (var j = columnExpandedIndex; j < columnExpandedLevel + 1; j += 1) {
var preparedOptions = (0, _extend.extend)({}, options, {
columns: options.columns.slice(columnExpandedIndex, j + 1),
rows: rows,
filters: filters.concat(getExpandedPathSliceFilter(options, "columns", j, firstCollapsedColumnIndex)).concat(rowFilterByExpandedPaths)
});
data.push(preparedOptions)
}
}
} else {
data = options.columns.length ? columnTotalsOptions : getGrandTotalRequest(options, "rows", rowExpandedIndex, rowExpandedLevel, filters, firstCollapsedRowIndex)
}
return data
}
function prepareFields(fields) {
(0, _iterator.each)(fields || [], (function(_, field) {
var levels = field.levels;
if (levels) {
prepareFields(levels)
}(0, _m_widget_utils.setDefaultFieldValueFormatting)(field)
}))
}
var RemoteStore = _class.default.inherit({
ctor: function(options) {
this._dataSource = new _data_source.DataSource(options);
this._store = this._dataSource.store()
},
getFields: function(fields) {
var d = new _deferred.Deferred;
this._store.load({
skip: 0,
take: 20
}).done((function(data) {
var normalizedArguments = (0, _utils.normalizeLoadResult)(data);
d.resolve(_m_widget_utils.default.discoverObjectFields(normalizedArguments.data, fields))
})).fail(d.reject);
return d
},
key: function() {
return this._store.key()
},
load: function(options) {
var that = this;
var d = new _deferred.Deferred;
var result = {
rows: [],
columns: [],
values: [],
grandTotalRowIndex: 0,
grandTotalColumnIndex: 0,
rowHash: {},
columnHash: {},
rowIndex: 1,
columnIndex: 1
};
var requestsData = getRequestsData(options);
var deferreds = [];
prepareFields(options.rows);
prepareFields(options.columns);
prepareFields(options.filters);
(0, _iterator.each)(requestsData, (function(_, dataItem) {
deferreds.push(that._store.load(function(options, externalFilterExpr, hasRows) {
var filterExpressions = createFilterExpressions(options.filters);
var groupingOptions = createGroupingOptions(options.rows, options.rowTake).concat(createGroupingOptions(options.columns, options.columnTake));
var loadOptions = {
groupSummary: [],
totalSummary: [],
group: groupingOptions.length ? groupingOptions : void 0,
take: groupingOptions.length ? void 0 : 1
};
if (options.rows.length && options.rowTake) {
loadOptions.skip = options.rowSkip;
loadOptions.take = options.rowTake;
loadOptions.requireGroupCount = true
} else if (options.columns.length && options.columnTake && !hasRows) {
loadOptions.skip = options.columnSkip;
loadOptions.take = options.columnTake;
loadOptions.requireGroupCount = true
}
if (externalFilterExpr) {
filterExpressions = mergeFilters(filterExpressions, externalFilterExpr)
}
if (filterExpressions.length) {
loadOptions.filter = filterExpressions
}(0, _iterator.each)(options.values, (function(_, value) {
var summaryOption = {
selector: value.dataField,
summaryType: value.summaryType || "count"
};
loadOptions.groupSummary.push(summaryOption);
options.includeTotalSummary && loadOptions.totalSummary.push(summaryOption)
}));
return loadOptions
}(dataItem, that.filter(), options.rows.length)))
}));
_deferred.when.apply(null, deferreds).done((function() {
var args = deferreds.length > 1 ? arguments : [arguments];
(0, _iterator.each)(args, (function(index, argument) {
var normalizedArguments = (0, _utils.normalizeLoadResult)(argument[0], argument[1]);
parseResult(normalizedArguments.data, normalizedArguments.extra, requestsData[index], result)
}));
d.resolve({
rows: result.rows,
columns: result.columns,
values: result.values,
grandTotalRowIndex: result.grandTotalRowIndex,
grandTotalColumnIndex: result.grandTotalColumnIndex
})
})).fail(d.reject);
return d
},
filter: function() {
return this._dataSource.filter.apply(this._dataSource, arguments)
},
supportPaging: function() {
return false
},
createDrillDownDataSource: function(loadOptions, params) {
loadOptions = loadOptions || {};
params = params || {};
var store = this._store;
var filters = (0, _m_widget_utils.getFiltersByPath)(loadOptions.rows, params.rowPath).concat((0, _m_widget_utils.getFiltersByPath)(loadOptions.columns, params.columnPath)).concat(getFiltersForDimension(loadOptions.rows)).concat(loadOptions.filters || []).concat(getFiltersForDimension(loadOptions.columns));
var filterExp = createFilterExpressions(filters);
return new _data_source.DataSource({
load: function(loadOptions) {
return store.load((0, _extend.extend)({}, loadOptions, {
filter: mergeFilters(filterExp, loadOptions.filter),
select: params.customColumns
}))
}
})
}
});
exports.RemoteStore = RemoteStore;
var _default = {
RemoteStore: RemoteStore
};
exports.default = _default
},
98413:
/*!**************************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/pivot_grid/remote_store/m_remote_store_utils.js ***!
\**************************************************************************************************************/
function(__unused_webpack_module, exports) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.forEachGroup = exports.default = void 0;
var forEachGroup = function forEachGroup(data, callback, level) {
data = data || [];
level = level || 0;
for (var i = 0; i < data.length; i += 1) {
var group = data[i];
callback(group, level);
if (group && group.items && group.items.length) {
forEachGroup(group.items, callback, level + 1)
}
}
};
exports.forEachGroup = forEachGroup;
var _default = {
forEachGroup: forEachGroup
};
exports.default = _default
},
71442:
/*!************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/pivot_grid/sortable/m_sortable.js ***!
\************************************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = exports.Sortable = void 0;
var _component_registrator = _interopRequireDefault(__webpack_require__( /*! ../../../../core/component_registrator */ 99393));
var _dom_adapter = _interopRequireDefault(__webpack_require__( /*! ../../../../core/dom_adapter */ 73349));
var _dom_component = _interopRequireDefault(__webpack_require__( /*! ../../../../core/dom_component */ 13046));
var _renderer = _interopRequireDefault(__webpack_require__( /*! ../../../../core/renderer */ 68374));
var _extend = __webpack_require__( /*! ../../../../core/utils/extend */ 13306);
var _iterator = __webpack_require__( /*! ../../../../core/utils/iterator */ 95479);
var _size = __webpack_require__( /*! ../../../../core/utils/size */ 58664);
var _type = __webpack_require__( /*! ../../../../core/utils/type */ 35922);
var _events_engine = _interopRequireDefault(__webpack_require__( /*! ../../../../events/core/events_engine */ 55994));
var _drag = __webpack_require__( /*! ../../../../events/drag */ 23174);
var _index = __webpack_require__( /*! ../../../../events/utils/index */ 39611);
var _swatch_container = _interopRequireDefault(__webpack_require__( /*! ../../../../ui/widget/swatch_container */ 92591));
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var getSwatchContainer = _swatch_container.default.getSwatchContainer;
function checkHorizontalPosition(position, itemOffset, rtl) {
if ((0, _type.isDefined)(itemOffset.posHorizontal)) {
return rtl ? position > itemOffset.posHorizontal : position < itemOffset.posHorizontal
}
return true
}
function getTargetGroup(e, $groups) {
var result;
(0, _iterator.each)($groups, (function() {
if (function(element, x, y) {
var $item = (0, _renderer.default)(element);
var offset = $item.offset();
if (x >= offset.left && x <= offset.left + (0, _size.getOuterWidth)($item, true)) {
if (y >= offset.top && y <= offset.top + (0, _size.getOuterHeight)($item, true)) {
return true
}
}
return
}(this, e.pageX, e.pageY)) {
result = (0, _renderer.default)(this)
}
}));
return result
}
var Sortable = _dom_component.default.inherit({
_getDefaultOptions: function() {
return (0, _extend.extend)(this.callBase(), {
onChanged: null,
onDragging: null,
itemRender: null,
groupSelector: null,
itemSelector: ".dx-sort-item",
itemContainerSelector: ".dx-sortable-old",
sourceClass: "dx-drag-source",
dragClass: "dx-drag",
targetClass: "dx-drag-target",
direction: "vertical",
allowDragging: true,
groupFilter: null,
useIndicator: false
})
},
_renderItem: function($sourceItem, target) {
var itemRender = this.option("itemRender");
var $item;
if (itemRender) {
$item = itemRender($sourceItem, target)
} else {
$item = $sourceItem.clone();
$item.css({
width: (0, _size.getWidth)($sourceItem),
height: (0, _size.getHeight)($sourceItem)
})
}
return $item
},
_renderIndicator: function($item, isVertical, $targetGroup, isLast) {
var height = (0, _size.getOuterHeight)($item, true);
var width = (0, _size.getOuterWidth)($item, true);
var top = $item.offset().top - $targetGroup.offset().top;
var left = $item.offset().left - $targetGroup.offset().left;
this._indicator.css({
position: "absolute",
top: isLast && isVertical ? top + height : top,
left: isLast && !isVertical ? left + width : left
}).toggleClass("dx-position-indicator-horizontal", !isVertical).toggleClass("dx-position-indicator-vertical", !!isVertical).toggleClass("dx-position-indicator-last", !!isLast).appendTo($targetGroup);
(0, _size.setHeight)(this._indicator, "");
(0, _size.setWidth)(this._indicator, "");
if (isVertical) {
(0, _size.setWidth)(this._indicator, width)
} else {
(0, _size.setHeight)(this._indicator, height)
}
},
_renderDraggable: function($sourceItem) {
this._$draggable && this._$draggable.remove();
this._$draggable = this._renderItem($sourceItem, "drag").addClass(this.option("dragClass")).appendTo(getSwatchContainer($sourceItem)).css({
zIndex: 1e6,
position: "absolute"
})
},
_detachEventHandlers: function() {
var dragEventsString = [_drag.move, _drag.start, _drag.end, _drag.enter, _drag.leave, _drag.drop].join(" ");
_events_engine.default.off(this._getEventListener(), (0, _index.addNamespace)(dragEventsString, "dxSortable"), void 0)
},
_getItemOffset: function(isVertical, itemsOffset, e) {
for (var i = 0; i < itemsOffset.length; i += 1) {
var shouldInsert = void 0;
var sameLine = e.pageY < itemsOffset[i].posVertical;
if (isVertical) {
shouldInsert = sameLine
} else if (sameLine) {
shouldInsert = checkHorizontalPosition(e.pageX, itemsOffset[i], this.option("rtlEnabled"));
if (!shouldInsert && itemsOffset[i + 1] && itemsOffset[i + 1].posVertical > itemsOffset[i].posVertical) {
shouldInsert = true
}
}
if (shouldInsert) {
return itemsOffset[i]
}
}
return
},
_getEventListener: function() {
var groupSelector = this.option("groupSelector");
var element = this.$element();
return groupSelector ? element.find(groupSelector) : element
},
_attachEventHandlers: function() {
var that = this;
var itemSelector = that.option("itemSelector");
var itemContainerSelector = that.option("itemContainerSelector");
var groupSelector = that.option("groupSelector");
var sourceClass = that.option("sourceClass");
var targetClass = that.option("targetClass");
var onDragging = that.option("onDragging");
var groupFilter = that.option("groupFilter");
var $sourceItem;
var sourceIndex;
var $targetItem;
var $targetGroup;
var startPositions;
var sourceGroup;
var element = that.$element();
var $groups;
var scrollWrapper = null;
var targetIndex = -1;
var disposeScrollWrapper = function() {
null === scrollWrapper || void 0 === scrollWrapper ? void 0 : scrollWrapper.dispose();
scrollWrapper = null
};
that._detachEventHandlers();
if (that.option("allowDragging")) {
var $eventListener = that._getEventListener();
_events_engine.default.on($eventListener, (0, _index.addNamespace)(_drag.start, "dxSortable"), itemSelector, (function(e) {
$sourceItem = (0, _renderer.default)(e.currentTarget);
var $sourceGroup = $sourceItem.closest(groupSelector);
sourceGroup = $sourceGroup.attr("group");
sourceIndex = function($items, $item) {
var index = -1;
var itemElement = $item.get(0);
(0, _iterator.each)($items, (function(elementIndex, element) {
var $element = (0, _renderer.default)(element);
if (!($element.attr("item-group") && $element.attr("item-group") === $items.eq(elementIndex - 1).attr("item-group"))) {
index += 1
}
if (element === itemElement) {
return false
}
return
}));
return index === $items.length ? -1 : index
}((groupSelector ? $sourceGroup : element).find(itemSelector), $sourceItem);
if ($sourceItem.attr("item-group")) {
$sourceItem = $sourceGroup.find("[item-group='".concat($sourceItem.attr("item-group"), "']"))
}
that._renderDraggable($sourceItem);
$targetItem = that._renderItem($sourceItem, "target").addClass(targetClass);
$sourceItem.addClass(sourceClass);
! function() {
startPositions = [];
(0, _iterator.each)($sourceItem, (function(_, item) {
startPositions.push((0, _renderer.default)(item).offset())
}))
}();
$groups = function() {
var root = _dom_adapter.default.getRootNode(that.$element().get(0));
if (!groupSelector) {
return element
}
return groupFilter ? (0, _renderer.default)(root).find(groupSelector).filter(groupFilter) : element.find(groupSelector)
}();
that._indicator = (0, _renderer.default)("").addClass("dx-position-indicator")
}));
_events_engine.default.on($eventListener, (0, _index.addNamespace)(_drag.move, "dxSortable"), (function(e) {
var $item;
var $lastItem;
var $prevItem;
if (!$sourceItem) {
return
}
targetIndex = -1;
that._indicator.detach();
(0, _iterator.each)(that._$draggable, (function(index, draggableElement) {
(0, _renderer.default)(draggableElement).css({
top: startPositions[index].top + e.offset.y,
left: startPositions[index].left + e.offset.x
})
}));
$targetGroup && $targetGroup.removeClass(targetClass);
$targetGroup = getTargetGroup(e, $groups);
$targetGroup && function() {
var draggingArgs = {
sourceGroup: sourceGroup,
sourceIndex: sourceIndex,
sourceElement: $sourceItem,
targetGroup: $targetGroup.attr("group"),
targetIndex: $targetGroup.find(itemSelector).index($targetItem)
};
onDragging && onDragging(draggingArgs);
if (draggingArgs.cancel) {
$targetGroup = void 0
}
}();
if ($targetGroup && scrollWrapper && $targetGroup.get(0) !== scrollWrapper.element().get(0)) {
disposeScrollWrapper()
}
scrollWrapper && scrollWrapper.moveIfNeed(e);
if (!$targetGroup) {
$targetItem.detach();
return
}
if (!scrollWrapper && $targetGroup.attr("allow-scrolling")) {
scrollWrapper = function(scrollable) {
var timeout;
var scrollTop = scrollable.scrollTop();
var $element = scrollable.$element();
var _$element$offset = $element.offset(),
top = _$element$offset.top;
var height = (0, _size.getHeight)($element);
var delta = 0;
function onScroll(e) {
scrollTop = e.scrollOffset.top
}
scrollable.on("scroll", onScroll);
function move() {
stop();
scrollable.scrollTo(scrollTop += delta);
timeout = setTimeout(move, 10)
}
function stop() {
clearTimeout(timeout)
}
return {
moveIfNeed: function(event) {
if (event.pageY <= top + 20) {
delta = -2
} else if (event.pageY >= top + height - 20) {
delta = 2
} else {
delta = 0;
stop();
return
}
move()
},
element: function() {
return $element
},
dispose: function() {
stop();
scrollable.off("scroll", onScroll)
}
}
}($targetGroup.dxScrollable("instance"))
}
$targetGroup.addClass(targetClass);
var $itemContainer = $targetGroup.find(itemContainerSelector);
var $items = $itemContainer.find(itemSelector);
var targetSortable = $targetGroup.closest(".".concat("dx-sortable-old")).data("dxSortableOld");
var useIndicator = targetSortable.option("useIndicator");
var isVertical = "vertical" === (targetSortable || that).option("direction");
var itemsOffset = function($elements, isVertical, $itemsContainer) {
var result = [];
var $item = [];
for (var i = 0; i < $elements.length; i += $item.length) {
$item = $elements.eq(i);
if ($item.attr("item-group")) {
$item = $itemsContainer.find("[item-group='".concat($item.attr("item-group"), "']"))
}
if ($item.is(":visible")) {
var offset = {
item: $item,
index: result.length,
posVertical: isVertical ? ($item.last().offset().top + $item.offset().top + (0, _size.getOuterHeight)($item.last(), true)) / 2 : (0, _size.getOuterHeight)($item.last(), true) + $item.last().offset().top,
posHorizontal: isVertical ? void 0 : ((0, _size.getOuterWidth)($item.last(), true) + $item.last().offset().left + $item.offset().left) / 2
};
result.push(offset)
}
}
return result
}($items, isVertical, $itemContainer);
var itemOffset = that._getItemOffset(isVertical, itemsOffset, e);
if (itemOffset) {
$item = itemOffset.item;
$prevItem = itemsOffset[itemOffset.index - 1] && itemsOffset[itemOffset.index - 1].item;
if ($item.hasClass(sourceClass) || $prevItem && $prevItem.hasClass(sourceClass) && $prevItem.is(":visible")) {
$targetItem.detach();
return
}
targetIndex = itemOffset.index;
if (!useIndicator) {
$targetItem.insertBefore($item);
return
}
var isAnotherGroup = $targetGroup.attr("group") !== sourceGroup;
var isSameIndex = targetIndex === sourceIndex;
var isNextIndex = targetIndex === sourceIndex + 1;
if (isAnotherGroup) {
that._renderIndicator($item, isVertical, $targetGroup, that.option("rtlEnabled") && !isVertical);
return
}
if (!isSameIndex && !isNextIndex) {
that._renderIndicator($item, isVertical, $targetGroup, that.option("rtlEnabled") && !isVertical)
}
} else {
$lastItem = $items.last();
if ($lastItem.is(":visible") && $lastItem.hasClass(sourceClass)) {
return
}
if ($itemContainer.length) {
targetIndex = itemsOffset.length ? itemsOffset[itemsOffset.length - 1].index + 1 : 0
}
if (useIndicator) {
$items.length && that._renderIndicator($lastItem, isVertical, $targetGroup, !that.option("rtlEnabled") || isVertical)
} else {
$targetItem.appendTo($itemContainer)
}
}
}));
_events_engine.default.on($eventListener, (0, _index.addNamespace)(_drag.end, "dxSortable"), (function() {
disposeScrollWrapper();
if (!$sourceItem) {
return
}
var onChanged = that.option("onChanged");
var changedArgs = {
sourceIndex: sourceIndex,
sourceElement: $sourceItem,
sourceGroup: sourceGroup,
targetIndex: targetIndex,
removeSourceElement: true,
removeTargetElement: false,
removeSourceClass: true
};
if ($targetGroup) {
$targetGroup.removeClass(targetClass);
changedArgs.targetGroup = $targetGroup.attr("group");
if (sourceGroup !== changedArgs.targetGroup || targetIndex > -1) {
onChanged && onChanged(changedArgs);
changedArgs.removeSourceElement && $sourceItem.remove()
}
}
that._indicator.detach();
changedArgs.removeSourceClass && $sourceItem.removeClass(sourceClass);
$sourceItem = null;
that._$draggable.remove();
that._$draggable = null;
changedArgs.removeTargetElement && $targetItem.remove();
$targetItem.removeClass(targetClass);
$targetItem = null
}))
}
},
_init: function() {
this.callBase();
this._attachEventHandlers()
},
_render: function() {
this.callBase();
this.$element().addClass("dx-sortable-old")
},
_dispose: function() {
var that = this;
that.callBase.apply(that, arguments);
that._$draggable && that._$draggable.detach();
that._indicator && that._indicator.detach()
},
_optionChanged: function(args) {
switch (args.name) {
case "onDragging":
case "onChanged":
case "itemRender":
case "groupSelector":
case "itemSelector":
case "itemContainerSelector":
case "sourceClass":
case "targetClass":
case "dragClass":
case "allowDragging":
case "groupFilter":
case "useIndicator":
this._attachEventHandlers();
break;
case "direction":
break;
default:
this.callBase(args)
}
},
_useTemplates: function() {
return false
}
});
exports.Sortable = Sortable;
(0, _component_registrator.default)("dxSortableOld", Sortable);
var _default = {
Sortable: Sortable
};
exports.default = _default
},
42717:
/*!**************************************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/pivot_grid/summary_display_modes/m_summary_display_modes.js ***!
\**************************************************************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
function _typeof(obj) {
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)
}
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.Cell = void 0;
exports.applyDisplaySummaryMode = applyDisplaySummaryMode;
exports.applyRunningTotal = applyRunningTotal;
exports.createMockSummaryCell = createMockSummaryCell;
exports.default = void 0;
exports.getExpression = getExpression;
exports.summaryDictionary = void 0;
var _extend = __webpack_require__( /*! ../../../../core/utils/extend */ 13306);
var _type = __webpack_require__( /*! ../../../../core/utils/type */ 35922);
var _m_widget_utils = function(obj, nodeInterop) {
if (!nodeInterop && obj && obj.__esModule) {
return obj
}
if (null === obj || "object" !== _typeof(obj) && "function" !== typeof obj) {
return {
default: obj
}
}
var cache = _getRequireWildcardCache(nodeInterop);
if (cache && cache.has(obj)) {
return cache.get(obj)
}
var newObj = {};
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
for (var key in obj) {
if ("default" !== key && Object.prototype.hasOwnProperty.call(obj, key)) {
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
if (desc && (desc.get || desc.set)) {
Object.defineProperty(newObj, key, desc)
} else {
newObj[key] = obj[key]
}
}
}
newObj.default = obj;
if (cache) {
cache.set(obj, newObj)
}
return newObj
}(__webpack_require__( /*! ../m_widget_utils */ 28580));
function _getRequireWildcardCache(nodeInterop) {
if ("function" !== typeof WeakMap) {
return null
}
var cacheBabelInterop = new WeakMap;
var cacheNodeInterop = new WeakMap;
return (_getRequireWildcardCache = function(nodeInterop) {
return nodeInterop ? cacheNodeInterop : cacheBabelInterop
})(nodeInterop)
}
var ROW = "row";
var calculatePercentValue = function(value, totalValue) {
var result = value / totalValue;
if (!(0, _type.isDefined)(value) || isNaN(result)) {
result = null
}
return result
};
var _percentOfGrandTotal = function(e, dimension) {
return calculatePercentValue(e.value(), e.grandTotal(dimension).value())
};
var percentOfParent = function(e, dimension) {
var parent = e.parent(dimension);
var parentValue = parent ? parent.value() : e.value();
return calculatePercentValue(e.value(), parentValue)
};
var createAbsoluteVariationExp = function(allowCrossGroup) {
return function(e) {
var prevCell = e.prev("column", allowCrossGroup);
var prevValue = prevCell && prevCell.value();
if ((0, _type.isDefined)(prevValue) && (0, _type.isDefined)(e.value())) {
return e.value() - prevValue
}
return null
}
};
var summaryDictionary = {
percentOfColumnTotal: function(e) {
return percentOfParent(e, ROW)
},
percentOfRowTotal: function(e) {
return percentOfParent(e, "column")
},
percentOfColumnGrandTotal: function(e) {
return _percentOfGrandTotal(e, ROW)
},
percentOfRowGrandTotal: function(e) {
return _percentOfGrandTotal(e, "column")
},
percentOfGrandTotal: function(e) {
return _percentOfGrandTotal(e)
}
};
exports.summaryDictionary = summaryDictionary;
var createRunningTotalExpr = function(field) {
if (!field.runningTotal) {
return
}
var direction = "column" === field.runningTotal ? ROW : "column";
return function(e) {
var prevCell = field.allowCrossGroupCalculation ? function getPrevCellCrossGroup(cell, direction) {
if (!cell || !cell.parent(direction)) {
return
}
var prevCell = cell.prev(direction);
if (!prevCell) {
prevCell = getPrevCellCrossGroup(cell.parent(direction), direction)
}
return prevCell
}(e, direction) : e.prev(direction, false);
var value = e.value(true);
var prevValue = prevCell && prevCell.value(true);
if ((0, _type.isDefined)(prevValue) && (0, _type.isDefined)(value)) {
value = prevValue + value
} else if ((0, _type.isDefined)(prevValue)) {
value = prevValue
}
return value
}
};
function getFieldPos(descriptions, field, cache) {
var fieldParams = {
index: -1
};
if (!(0, _type.isObject)(field)) {
if (cache.fields[field]) {
field = cache[field]
} else {
var allFields = descriptions.columns.concat(descriptions.rows).concat(descriptions.values);
var fieldIndex = (0, _m_widget_utils.findField)(allFields, field);
field = cache[field] = allFields[fieldIndex]
}
}
if (field) {
var area = field.area || "data";
fieldParams = cache.positions[field.index] = cache.positions[field.index] || {
area: area,
index: descriptions["data" === area ? "values" : "".concat(area, "s")].indexOf(field)
}
}
return fieldParams
}
function getPathFieldName(dimension) {
return dimension === ROW ? "_rowPath" : "_columnPath"
}
var SummaryCell = function(columnPath, rowPath, data, descriptions, fieldIndex, fieldsCache) {
this._columnPath = columnPath;
this._rowPath = rowPath;
this._fieldIndex = fieldIndex;
this._fieldsCache = fieldsCache || {
fields: {},
positions: {}
};
this._data = data;
this._descriptions = descriptions;
var cell = data.values && data.values[rowPath[0].index] && data.values[rowPath[0].index][columnPath[0].index];
if (cell) {
cell.originalCell = cell.originalCell || cell.slice();
cell.postProcessedFlags = cell.postProcessedFlags || [];
this._cell = cell
}
};
exports.Cell = SummaryCell;
SummaryCell.prototype = (0, _extend.extend)(SummaryCell.prototype, {
_getPath: function(dimension) {
return this[getPathFieldName(dimension)]
},
_getDimension: function(dimension) {
dimension = dimension === ROW ? "rows" : "columns";
return this._descriptions[dimension]
},
_createCell: function(config) {
return new SummaryCell(config._columnPath || this._columnPath, config._rowPath || this._rowPath, this._data, this._descriptions, this._fieldIndex)
},
parent: function(direction) {
var path = this._getPath(direction).slice();
var config = {};
path.shift();
if (path.length) {
config[getPathFieldName(direction)] = path;
return this._createCell(config)
}
return null
},
children: function(direction) {
var path = this._getPath(direction).slice();
var item = path[0];
var result = [];
var cellConfig = {};
if (item.children) {
for (var i = 0; i < item.children.length; i += 1) {
cellConfig[getPathFieldName(direction)] = [item.children[i]].concat(path.slice());
result.push(this._createCell(cellConfig))
}
}
return result
},
grandTotal: function(direction) {
var config = {};
var rowPath = this._rowPath;
var columnPath = this._columnPath;
var dimensionPath = this._getPath(direction);
var pathFieldName = getPathFieldName(direction);
if (!direction) {
config._rowPath = [rowPath[rowPath.length - 1]];
config._columnPath = [columnPath[columnPath.length - 1]]
} else {
config[pathFieldName] = [dimensionPath[dimensionPath.length - 1]]
}
return this._createCell(config)
},
next: function(direction, allowCrossGroup) {
var currentPath = this._getPath(direction);
var item = currentPath[0];
var parent = this.parent(direction);
var siblings;
if (parent) {
var index = currentPath[1].children.indexOf(item);
siblings = parent.children(direction);
if (siblings[index + 1]) {
return siblings[index + 1]
}
}
if (allowCrossGroup && parent) {
do {
parent = parent.next(direction, allowCrossGroup);
siblings = parent ? parent.children(direction) : []
} while (parent && !siblings.length);
return siblings[0] || null
}
return null
},
prev: function(direction, allowCrossGroup) {
var currentPath = this._getPath(direction);
var item = currentPath[0];
var parent = this.parent(direction);
var siblings;
if (parent) {
var index = currentPath[1].children.indexOf(item);
siblings = parent.children(direction);
if (siblings[index - 1]) {
return siblings[index - 1]
}
}
if (allowCrossGroup && parent) {
do {
parent = parent.prev(direction, allowCrossGroup);
siblings = parent ? parent.children(direction) : []
} while (parent && !siblings.length);
return siblings[siblings.length - 1] || null
}
return null
},
cell: function() {
return this._cell
},
field: function(area) {
if ("data" === area) {
return this._descriptions.values[this._fieldIndex]
}
var path = this._getPath(area);
var descriptions = this._getDimension(area);
var field = descriptions[path.length - 2];
return field || null
},
child: function(direction, fieldValue) {
var childLevelField;
var children = this.children(direction);
for (var i = 0; i < children.length; i += 1) {
childLevelField = childLevelField || children[i].field(direction);
if (children[i].value(childLevelField) === fieldValue) {
return children[i]
}
}
return null
},
slice: function(field, value) {
var config = {};
var fieldPos = getFieldPos(this._descriptions, field, this._fieldsCache);
var area = fieldPos.area;
var fieldIndex = fieldPos.index;
var sliceCell = null;
if (area === ROW || "column" === area) {
var path = this._getPath(area).slice();
var level = -1 !== fieldIndex && path.length - 2 - fieldIndex;
if (path[level]) {
[][path.length - 1] = path[path.length - 1];
for (var i = level; i >= 0; i -= 1) {
if (path[i + 1]) {
var childItems = path[i + 1].children || [];
var currentValue = i === level ? value : path[i].value;
path[i] = void 0;
for (var childIndex = 0; childIndex < childItems.length; childIndex += 1) {
if (childItems[childIndex].value === currentValue) {
path[i] = childItems[childIndex];
break
}
}
}
if (void 0 === path[i]) {
return sliceCell
}
}
config[getPathFieldName(area)] = path;
sliceCell = this._createCell(config)
}
}
return sliceCell
},
value: function(arg1, arg2) {
var cell = this._cell;
var fieldIndex = this._fieldIndex;
var fistArgIsBoolean = true === arg1 || false === arg1;
var field = !fistArgIsBoolean ? arg1 : null;
var needCalculatedValue = fistArgIsBoolean && arg1 || arg2;
if ((0, _type.isDefined)(field)) {
var fieldPos = getFieldPos(this._descriptions, field, this._fieldsCache);
fieldIndex = fieldPos.index;
if ("data" !== fieldPos.area) {
var path = this._getPath(fieldPos.area);
var level = -1 !== fieldIndex && path.length - 2 - fieldIndex;
return path[level] && path[level].value
}
}
if (cell && cell.originalCell) {
return needCalculatedValue ? cell[fieldIndex] : cell.originalCell[fieldIndex]
}
return null
},
isPostProcessed: function(field) {
var fieldIndex = this._fieldIndex;
if ((0, _type.isDefined)(field)) {
var fieldPos = getFieldPos(this._descriptions, field, this._fieldsCache);
fieldIndex = fieldPos.index;
if ("data" !== fieldPos.area) {
return false
}
}
return !!(this._cell && this._cell.postProcessedFlags[fieldIndex])
}
});
function getExpression(field) {
var summaryDisplayMode = field.summaryDisplayMode;
var crossGroupCalculation = field.allowCrossGroupCalculation;
var expression = null;
if ((0, _type.isFunction)(field.calculateSummaryValue)) {
expression = field.calculateSummaryValue
} else if (summaryDisplayMode) {
if ("absoluteVariation" === summaryDisplayMode) {
expression = createAbsoluteVariationExp(crossGroupCalculation)
} else if ("percentVariation" === summaryDisplayMode) {
expression = (allowCrossGroup = crossGroupCalculation, absoluteExp = createAbsoluteVariationExp(allowCrossGroup), function(e) {
var absVar = absoluteExp(e);
var prevCell = e.prev("column", allowCrossGroup);
var prevValue = prevCell && prevCell.value();
return null !== absVar && prevValue ? absVar / prevValue : null
})
} else {
expression = summaryDictionary[summaryDisplayMode]
}
if (expression && !field.format && -1 !== summaryDisplayMode.indexOf("percent")) {
_m_widget_utils.default.setFieldProperty(field, "format", "percent")
}
}
var allowCrossGroup, absoluteExp;
return expression
}
function processDataCell(data, rowIndex, columnIndex, isRunningTotalCalculation) {
var values = data.values[rowIndex][columnIndex] = data.values[rowIndex][columnIndex] || [];
var originalCell = values.originalCell;
if (!originalCell) {
return
}
if (values.allowResetting || !isRunningTotalCalculation) {
data.values[rowIndex][columnIndex] = originalCell.slice()
}
data.values[rowIndex][columnIndex].allowResetting = isRunningTotalCalculation
}
function applyDisplaySummaryMode(descriptions, data) {
var expressions = [];
var columnElements = [{
index: data.grandTotalColumnIndex,
children: data.columns
}];
var rowElements = [{
index: data.grandTotalRowIndex,
children: data.rows
}];
var valueFields = descriptions.values;
var fieldsCache = {
fields: {},
positions: {}
};
data.values = data.values || [];
(0, _m_widget_utils.foreachTree)(columnElements, (function(columnPath) {
columnPath[0].isEmpty = []
}), false);
(0, _m_widget_utils.foreachTree)(rowElements, (function(rowPath) {
var rowItem = rowPath[0];
rowItem.isEmpty = [];
data.values[rowItem.index] = data.values[rowItem.index] || [];
(0, _m_widget_utils.foreachTree)(columnElements, (function(columnPath) {
var columnItem = columnPath[0];
var isEmptyCell;
processDataCell(data, rowItem.index, columnItem.index, false);
for (var i = 0; i < valueFields.length; i += 1) {
var field = valueFields[i];
var expression = expressions[i] = void 0 === expressions[i] ? getExpression(field) : expressions[i];
isEmptyCell = false;
if (expression) {
var expressionArg = new SummaryCell(columnPath, rowPath, data, descriptions, i, fieldsCache);
var cell = expressionArg.cell();
var value = cell[i] = expression(expressionArg);
cell.postProcessedFlags[i] = true;
isEmptyCell = null === value || void 0 === value
}
if (void 0 === columnItem.isEmpty[i]) {
columnItem.isEmpty[i] = true
}
if (void 0 === rowItem.isEmpty[i]) {
rowItem.isEmpty[i] = true
}
if (!isEmptyCell) {
rowItem.isEmpty[i] = columnItem.isEmpty[i] = false
}
}
}), false)
}), false);
data.isEmptyGrandTotalRow = rowElements[0].isEmpty;
data.isEmptyGrandTotalColumn = columnElements[0].isEmpty
}
function applyRunningTotal(descriptions, data) {
var expressions = [];
var columnElements = [{
index: data.grandTotalColumnIndex,
children: data.columns
}];
var rowElements = [{
index: data.grandTotalRowIndex,
children: data.rows
}];
var valueFields = descriptions.values;
var fieldsCache = {
fields: {},
positions: {}
};
data.values = data.values || [];
(0, _m_widget_utils.foreachTree)(rowElements, (function(rowPath) {
var rowItem = rowPath[0];
data.values[rowItem.index] = data.values[rowItem.index] || [];
(0, _m_widget_utils.foreachTree)(columnElements, (function(columnPath) {
var columnItem = columnPath[0];
processDataCell(data, rowItem.index, columnItem.index, true);
for (var i = 0; i < valueFields.length; i += 1) {
var field = valueFields[i];
var expression = expressions[i] = void 0 === expressions[i] ? createRunningTotalExpr(field) : expressions[i];
if (expression) {
var expressionArg = new SummaryCell(columnPath, rowPath, data, descriptions, i, fieldsCache);
var cell = expressionArg.cell();
cell[i] = expression(expressionArg);
cell.postProcessedFlags[i] = true
}
}
}), false)
}), false)
}
function createMockSummaryCell(descriptions, fields, indices) {
var summaryCell = new SummaryCell([], [], {}, descriptions, 0);
summaryCell.value = function(fieldId) {
if ((0, _type.isDefined)(fieldId)) {
var index = (0, _m_widget_utils.findField)(fields, fieldId);
var field = fields[index];
if (!indices[index] && field && !(0, _type.isDefined)(field.area)) {
descriptions.values.push(field);
indices[index] = true
}
}
};
summaryCell.grandTotal = function() {
return this
};
summaryCell.children = function() {
return []
};
return summaryCell
}
var _default = {
Cell: SummaryCell,
summaryDictionary: summaryDictionary,
getExpression: getExpression,
applyRunningTotal: applyRunningTotal,
createMockSummaryCell: createMockSummaryCell,
applyDisplaySummaryMode: applyDisplaySummaryMode
};
exports.default = _default
},
79755:
/*!****************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/pivot_grid/xmla_store/m_xmla_store.js ***!
\****************************************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
function _typeof(obj) {
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)
}
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = exports.XmlaStore = void 0;
var _class = _interopRequireDefault(__webpack_require__( /*! ../../../../core/class */ 38377));
var _renderer = _interopRequireDefault(__webpack_require__( /*! ../../../../core/renderer */ 68374));
var _common = __webpack_require__( /*! ../../../../core/utils/common */ 20576);
var _deferred = __webpack_require__( /*! ../../../../core/utils/deferred */ 62754);
var _extend = __webpack_require__( /*! ../../../../core/utils/extend */ 13306);
var _iterator = __webpack_require__( /*! ../../../../core/utils/iterator */ 95479);
var _string = __webpack_require__( /*! ../../../../core/utils/string */ 68752);
var _type = __webpack_require__( /*! ../../../../core/utils/type */ 35922);
var _window = __webpack_require__( /*! ../../../../core/utils/window */ 58201);
var _errors = __webpack_require__( /*! ../../../../data/errors */ 18438);
var _language_codes = __webpack_require__( /*! ../../../../localization/language_codes */ 9821);
var _m_widget_utils = function(obj, nodeInterop) {
if (!nodeInterop && obj && obj.__esModule) {
return obj
}
if (null === obj || "object" !== _typeof(obj) && "function" !== typeof obj) {
return {
default: obj
}
}
var cache = _getRequireWildcardCache(nodeInterop);
if (cache && cache.has(obj)) {
return cache.get(obj)
}
var newObj = {};
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
for (var key in obj) {
if ("default" !== key && Object.prototype.hasOwnProperty.call(obj, key)) {
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
if (desc && (desc.get || desc.set)) {
Object.defineProperty(newObj, key, desc)
} else {
newObj[key] = obj[key]
}
}
}
newObj.default = obj;
if (cache) {
cache.set(obj, newObj)
}
return newObj
}(__webpack_require__( /*! ../m_widget_utils */ 28580));
function _getRequireWildcardCache(nodeInterop) {
if ("function" !== typeof WeakMap) {
return null
}
var cacheBabelInterop = new WeakMap;
var cacheNodeInterop = new WeakMap;
return (_getRequireWildcardCache = function(nodeInterop) {
return nodeInterop ? cacheNodeInterop : cacheBabelInterop
})(nodeInterop)
}
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
function _toConsumableArray(arr) {
return function(arr) {
if (Array.isArray(arr)) {
return _arrayLikeToArray(arr)
}
}(arr) || function(iter) {
if ("undefined" !== typeof Symbol && null != iter[Symbol.iterator] || null != iter["@@iterator"]) {
return Array.from(iter)
}
}(arr) || function(o, minLen) {
if (!o) {
return
}
if ("string" === typeof o) {
return _arrayLikeToArray(o, minLen)
}
var n = Object.prototype.toString.call(o).slice(8, -1);
if ("Object" === n && o.constructor) {
n = o.constructor.name
}
if ("Map" === n || "Set" === n) {
return Array.from(o)
}
if ("Arguments" === n || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) {
return _arrayLikeToArray(o, minLen)
}
}(arr) || function() {
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 _arrayLikeToArray(arr, len) {
if (null == len || len > arr.length) {
len = arr.length
}
for (var i = 0, arr2 = new Array(len); i < len; i++) {
arr2[i] = arr[i]
}
return arr2
}
var window = (0, _window.getWindow)();
var XmlaStore = _class.default.inherit(function() {
var discover = ' {2}{0}{1}{0}{3}';
var mdx = "SELECT {2} FROM {0} {1} CELL PROPERTIES VALUE, FORMAT_STRING, LANGUAGE, BACK_COLOR, FORE_COLOR, FONT_FLAGS";
function execXMLA(requestOptions, data) {
var deferred = new _deferred.Deferred;
var beforeSend = requestOptions.beforeSend;
var ajaxSettings = {
url: requestOptions.url,
dataType: "text",
data: data,
headers: {
"Content-Type": "text/xml"
},
xhrFields: {},
method: "POST"
};
if ((0, _type.isFunction)(beforeSend)) {
beforeSend(ajaxSettings)
}
_m_widget_utils.default.sendRequest(ajaxSettings).fail((function() {
deferred.reject(arguments)
})).done((function(text) {
var parser = new window.DOMParser;
var xml;
try {
try {
xml = parser.parseFromString(text, "text/xml")
} catch (e) {
xml = void 0
}
if (!xml || xml.getElementsByTagName("parsererror").length || 0 === xml.childNodes.length) {
throw new _errors.errors.Error("E4023", text)
}
} catch (e) {
deferred.reject({
statusText: e.message,
stack: e.stack,
responseText: text
})
}
deferred.resolve(xml)
}));
return deferred
}
function getLocaleIdProperty() {
var languageId = (0, _language_codes.getLanguageId)();
if (void 0 !== languageId) {
return (0, _string.format)(" {0}", languageId)
}
return ""
}
function getAllMember(dimension) {
return "".concat(dimension.hierarchyName || dimension.dataField, ".[All]")
}
function getAllMembers(field) {
var result = "".concat(field.dataField, ".allMembers");
var searchValue = field.searchValue;
if (searchValue) {
searchValue = searchValue.replace(/'/g, "''");
result = "Filter(".concat(result, ", instr(").concat(field.dataField, ".currentmember.member_caption,'").concat(searchValue, "') > 0)")
}
return result
}
function crossJoinElements(elements) {
var elementsString = elements.join(",");
return elements.length > 1 ? (0, _string.format)("CrossJoin({0})", elementsString) : elementsString
}
function generateCrossJoin(path, expandLevel, expandAllCount, expandIndex, slicePath, options, axisName, take) {
var crossJoinArgs = [];
var dimensions = options[axisName];
var fields = [];
var arg;
var prevDimension;
var member;
for (var i = expandIndex; i <= expandLevel; i += 1) {
var field = dimensions[i];
var dataField = field.dataField;
var prevHierarchyName = dimensions[i - 1] && dimensions[i - 1].hierarchyName;
var hierarchyName = field.hierarchyName;
var isLastDimensionInGroup = !hierarchyName || !dimensions[i + 1] || dimensions[i + 1].hierarchyName !== hierarchyName;
var expandAllIndex = path.length + expandAllCount + expandIndex;
arg = null;
fields.push(field);
if (i < path.length) {
if (isLastDimensionInGroup) {
arg = "(".concat(dataField, ".").concat(preparePathValue(path[i], dataField), ")")
}
} else if (i <= expandAllIndex) {
if (0 === i && 0 === expandAllCount) {
var allMember = getAllMember(dimensions[expandIndex]);
if (!hierarchyName) {
arg = getAllMembers(dimensions[expandIndex])
} else {
arg = "".concat(allMember, ",").concat(dimensions[expandIndex].dataField)
}
} else if (hierarchyName) {
member = preparePathValue(slicePath[slicePath.length - 1]);
if (isLastDimensionInGroup || i === expandAllIndex) {
if (prevHierarchyName === hierarchyName) {
if (slicePath.length) {
prevDimension = dimensions[slicePath.length - 1]
}
if (!prevDimension || prevDimension.hierarchyName !== hierarchyName) {
prevDimension = dimensions[i - 1];
member = ""
}
arg = (level = prevDimension.dataField, levelMember = member, nextLevel = dataField, memberExpression = void 0, memberExpression = levelMember || level, "Descendants({".concat(memberExpression, "}, ").concat(nextLevel, ", SELF_AND_BEFORE)"))
} else {
arg = getAllMembers(field)
}
}
} else {
arg = getAllMembers(field)
}
} else {
var isFirstDimensionInGroup = !hierarchyName || prevHierarchyName !== hierarchyName;
if (isFirstDimensionInGroup) {
arg = "(".concat(getAllMember(field), ")")
}
}
if (arg) {
arg = (0, _string.format)("{{0}}", arg);
if (take) {
var sortBy = (field.hierarchyName || field.dataField) + ("displayText" === field.sortBy ? ".MEMBER_CAPTION" : ".MEMBER_VALUE");
arg = (0, _string.format)("Order({0}, {1}, {2})", arg, sortBy, "desc" === field.sortOrder ? "DESC" : "ASC")
}
crossJoinArgs.push(arg)
}
}
var level, levelMember, nextLevel, memberExpression;
return crossJoinElements(crossJoinArgs)
}
function fillCrossJoins(crossJoins, path, expandLevel, expandIndex, slicePath, options, axisName, cellsString, take, totalsOnly) {
var expandAllCount = -1;
var dimensions = options[axisName];
var dimensionIndex;
do {
expandAllCount += 1;
dimensionIndex = path.length + expandAllCount + expandIndex;
var crossJoin = generateCrossJoin(path, expandLevel, expandAllCount, expandIndex, slicePath, options, axisName, take);
if (!take && !totalsOnly) {
crossJoin = (0, _string.format)("NonEmpty({0}, {1})", crossJoin, cellsString)
}
crossJoins.push(crossJoin)
} while (dimensions[dimensionIndex] && dimensions[dimensionIndex + 1] && dimensions[dimensionIndex].expanded)
}
function declare(expression, withArray, name, type) {
name = name || "[DX_Set_".concat(withArray.length, "]");
type = type || "set";
withArray.push((0, _string.format)("{0} {1} as {2}", type, name, expression));
return name
}
function generateAxisMdx(options, axisName, cells, withArray, parseOptions) {
var dimensions = options[axisName];
var crossJoins = [];
var path = [];
var expandedPaths = [];
var expandIndex = 0;
var expandLevel = 0;
var result = [];
var cellsString = (0, _string.format)("{{0}}", cells.join(","));
if (dimensions && dimensions.length) {
if (options.headerName === axisName) {
path = options.path;
expandIndex = path.length
} else if (options.headerName && options.oppositePath) {
path = options.oppositePath;
expandIndex = path.length
} else {
expandedPaths = ("columns" === axisName ? options.columnExpandedPaths : options.rowExpandedPaths) || expandedPaths
}
expandLevel = (0, _m_widget_utils.getExpandedLevel)(options, axisName);
fillCrossJoins(crossJoins, [], expandLevel, expandIndex, path, options, axisName, cellsString, "rows" === axisName ? options.rowTake : options.columnTake, options.totalsOnly);
(0, _iterator.each)(expandedPaths, (function(_, expandedPath) {
fillCrossJoins(crossJoins, expandedPath, expandLevel, expandIndex, expandedPath, options, axisName, cellsString)
}));
for (var i = expandLevel; i >= path.length; i -= 1) {
if (dimensions[i].hierarchyName) {
parseOptions.visibleLevels[dimensions[i].hierarchyName] = parseOptions.visibleLevels[dimensions[i].hierarchyName] || [];
parseOptions.visibleLevels[dimensions[i].hierarchyName].push(dimensions[i].dataField)
}
}
}
if (crossJoins.length) {
var expression = (elements = crossJoins, elementsString = elements.join(","), elements.length > 1 ? "Union(".concat(elementsString, ")") : elementsString);
if ("rows" === axisName && options.rowTake) {
expression = (0, _string.format)("Subset({0}, {1}, {2})", expression, options.rowSkip > 0 ? options.rowSkip + 1 : 0, options.rowSkip > 0 ? options.rowTake : options.rowTake + 1)
}
if ("columns" === axisName && options.columnTake) {
expression = (0, _string.format)("Subset({0}, {1}, {2})", expression, options.columnSkip > 0 ? options.columnSkip + 1 : 0, options.columnSkip > 0 ? options.columnTake : options.columnTake + 1)
}
var axisSet = "[DX_".concat(axisName, "]");
result.push(declare(expression, withArray, axisSet));
if (options.totalsOnly) {
result.push(declare("COUNT(".concat(axisSet, ")"), withArray, "[DX_".concat(axisName, "_count]"), "member"))
}
}
var elements, elementsString;
if ("columns" === axisName && cells.length && !options.skipValues) {
result.push(cellsString)
}
return (0, _string.format)("{0} DIMENSION PROPERTIES PARENT_UNIQUE_NAME,HIERARCHY_UNIQUE_NAME, MEMBER_VALUE ON {1}", crossJoinElements(result), axisName)
}
function generateAxisFieldsFilter(fields) {
var filterMembers = [];
(0, _iterator.each)(fields, (function(_, field) {
var dataField = field.dataField;
var filterExpression = [];
var filterValues = field.filterValues || [];
var filterStringExpression;
if (field.hierarchyName && (0, _type.isNumeric)(field.groupIndex)) {
return
}(0, _iterator.each)(filterValues, (function(_, filterValue) {
var filterMdx = "".concat(dataField, ".").concat(preparePathValue(Array.isArray(filterValue) ? filterValue[filterValue.length - 1] : filterValue, dataField));
if ("exclude" === field.filterType) {
filterExpression.push("".concat(filterMdx, ".parent"));
filterMdx = "Descendants(".concat(filterMdx, ")")
}
filterExpression.push(filterMdx)
}));
if (filterValues.length) {
filterStringExpression = (0, _string.format)("{{0}}", filterExpression.join(","));
if ("exclude" === field.filterType) {
filterStringExpression = "Except(".concat(getAllMembers(field), ",").concat(filterStringExpression, ")")
}
filterMembers.push(filterStringExpression)
}
}));
return filterMembers.length ? crossJoinElements(filterMembers) : ""
}
function generateFrom(columnsFilter, rowsFilter, filter, cubeName) {
var from = "[".concat(cubeName, "]");
(0, _iterator.each)([columnsFilter, rowsFilter, filter], (function(_, filter) {
if (filter) {
from = (0, _string.format)("(SELECT {0} FROM {1})", "".concat(filter, "on 0"), from)
}
}));
return from
}
function generateMdxCore(axisStrings, withArray, columns, rows, filters, slice, cubeName) {
var options = arguments.length > 7 && void 0 !== arguments[7] ? arguments[7] : {};
var mdxString = "";
var withString = "".concat(withArray.length ? "with ".concat(withArray.join(" ")) : "", " ");
if (axisStrings.length) {
var select;
if (options.totalsOnly) {
var countMembers = [];
if (rows.length) {
countMembers.push("[DX_rows_count]")
}
if (columns.length) {
countMembers.push("[DX_columns_count]")
}
select = "{".concat(countMembers.join(","), "} on columns")
} else {
select = axisStrings.join(",")
}
mdxString = withString + (0, _string.format)(mdx, generateFrom(generateAxisFieldsFilter(columns), generateAxisFieldsFilter(rows), generateAxisFieldsFilter(filters || []), cubeName), slice.length ? (0, _string.format)("WHERE ({0})", slice.join(",")) : "", select)
}
return mdxString
}
function prepareDataFields(withArray, valueFields) {
return (0, _iterator.map)(valueFields, (function(cell) {
if ((0, _type.isString)(cell.expression)) {
declare(cell.expression, withArray, cell.dataField, "member")
}
return cell.dataField
}))
}
function addSlices(slices, options, headerName, path) {
(0, _iterator.each)(path, (function(index, value) {
var dimension = options[headerName][index];
if (!dimension.hierarchyName || dimension.hierarchyName !== options[headerName][index + 1].hierarchyName) {
slices.push("".concat(dimension.dataField, ".").concat(preparePathValue(value, dimension.dataField)))
}
}))
}
function generateMDX(options, cubeName, parseOptions) {
var columns = options.columns || [];
var rows = options.rows || [];
var values = options.values && options.values.length ? options.values : [{
dataField: "[Measures]"
}];
var slice = [];
var withArray = [];
var axisStrings = [];
var dataFields = prepareDataFields(withArray, values);
parseOptions.measureCount = options.skipValues ? 1 : values.length;
parseOptions.visibleLevels = {};
if (options.headerName && options.path) {
addSlices(slice, options, options.headerName, options.path)
}
if (options.headerName && options.oppositePath) {
addSlices(slice, options, "rows" === options.headerName ? "columns" : "rows", options.oppositePath)
}
if (columns.length || dataFields.length) {
axisStrings.push(generateAxisMdx(options, "columns", dataFields, withArray, parseOptions))
}
if (rows.length) {
axisStrings.push(generateAxisMdx(options, "rows", dataFields, withArray, parseOptions))
}
return generateMdxCore(axisStrings, withArray, columns, rows, options.filters, slice, cubeName, options)
}
function createDrillDownAxisSlice(slice, fields, path) {
(0, _iterator.each)(path, (function(index, value) {
var field = fields[index];
if (field.hierarchyName && (fields[index + 1] || {}).hierarchyName === field.hierarchyName) {
return
}
slice.push("".concat(field.dataField, ".").concat(preparePathValue(value, field.dataField)))
}))
}
function getNumber(str) {
return parseInt(str, 10)
}
function getFirstChildText(node, childTagName) {
return getNodeText(function(node, tagName) {
return (node.getElementsByTagName(tagName) || [])[0]
}(node, childTagName))
}
function getNodeText(node) {
return node && (node.textContent || node.text || node.innerHTML) || ""
}
function parseCells(xml, axes, measureCount) {
var cells = [];
var cell = [];
var index = 0;
var cellsOriginal = [];
var cellElements = xml.getElementsByTagName("Cell");
var errorDictionary = {};
for (var i = 0; i < cellElements.length; i += 1) {
var xmlCell = cellElements[i];
var valueElement = xmlCell.getElementsByTagName("Value")[0];
var errorElements = valueElement && valueElement.getElementsByTagName("Error") || [];
var text = 0 === errorElements.length ? getNodeText(valueElement) : "#N/A";
var value = parseFloat(text);
var _isNumeric = text - value + 1 > 0;
var cellOrdinal = getNumber(xmlCell.getAttribute("CellOrdinal"));
if (errorElements.length) {
errorDictionary[getNodeText(errorElements[0].getElementsByTagName("ErrorCode")[0])] = getNodeText(errorElements[0].getElementsByTagName("Description")[0])
}
cellsOriginal[cellOrdinal] = {
value: _isNumeric ? value : text || null
}
}(0, _iterator.each)(axes[1], (function() {
var row = [];
cells.push(row);
(0, _iterator.each)(axes[0], (function() {
var measureIndex = index % measureCount;
if (0 === measureIndex) {
cell = [];
row.push(cell)
}
cell.push(cellsOriginal[index] ? cellsOriginal[index].value : null);
index += 1
}))
}));
Object.keys(errorDictionary).forEach((function(key) {
_errors.errors.log("W4002", errorDictionary[key])
}));
return cells
}
function preparePathValue(pathValue, dataField) {
if (pathValue) {
pathValue = (0, _type.isString)(pathValue) && pathValue.includes("&") ? pathValue : "[".concat(pathValue, "]");
if (dataField && 0 === pathValue.indexOf("".concat(dataField, "."))) {
pathValue = pathValue.slice(dataField.length + 1, pathValue.length)
}
}
return pathValue
}
function getItem(hash, name, member, index) {
var item = hash[name];
if (!item) {
item = {};
hash[name] = item
}
if (!(0, _type.isDefined)(item.value) && member) {
item.text = member.caption;
item.value = member.value;
item.key = name || "";
item.levelName = member.levelName;
item.hierarchyName = member.hierarchyName;
item.parentName = member.parentName;
item.index = index;
item.level = member.level
}
return item
}
function getVisibleChildren(item, visibleLevels) {
var result = [];
var children = item.children && (item.children.length ? item.children : Object.keys(item.children.grandTotalHash || {}).reduce((function(result, name) {
return result.concat(item.children.grandTotalHash[name].children)
}), []));
var firstChild = children && children[0];
if (firstChild && (visibleLevels[firstChild.hierarchyName] && visibleLevels[firstChild.hierarchyName].includes(firstChild.levelName) || !visibleLevels[firstChild.hierarchyName] || 0 === firstChild.level)) {
var newChildren = children.filter((function(child) {
return child.hierarchyName === firstChild.hierarchyName
}));
newChildren.grandTotalHash = children.grandTotalHash;
return newChildren
}
if (firstChild) {
for (var i = 0; i < children.length; i += 1) {
if (children[i].hierarchyName === firstChild.hierarchyName) {
result.push.apply(result, getVisibleChildren(children[i], visibleLevels))
}
}
}
return result
}
function fillDataSourceAxes(dataSourceAxis, axisTuples, measureCount, visibleLevels) {
var result = [];
(0, _iterator.each)(axisTuples, (function(tupleIndex, members) {
var parentItem = {
children: result
};
var dataIndex = (0, _type.isDefined)(measureCount) ? Math.floor(tupleIndex / measureCount) : tupleIndex;
(0, _iterator.each)(members, (function(_, member) {
parentItem = function(dataIndex, member, parentItem) {
var children = parentItem.children = parentItem.children || [];
var hash = children.hash = children.hash || {};
var grandTotalHash = children.grandTotalHash = children.grandTotalHash || {};
if (member.parentName) {
parentItem = getItem(hash, member.parentName);
children = parentItem.children = parentItem.children || []
}
var currentItem = getItem(hash, member.name, member, dataIndex);
if (member.hasValue && !currentItem.added) {
currentItem.index = dataIndex;
currentItem.added = true;
children.push(currentItem)
}
if ((!parentItem.value || !parentItem.parentName) && member.parentName) {
grandTotalHash[member.parentName] = parentItem
} else if (grandTotalHash[parentItem.name]) {
delete grandTotalHash[member.parentName]
}
return currentItem
}(dataIndex, member, parentItem)
}))
}));
var parentItem = {
children: result
};
parentItem.children = getVisibleChildren(parentItem, visibleLevels);
var grandTotalIndex = function(parentItem, visibleLevels) {
var grandTotalIndex;
if (1 === parentItem.children.length && "" === parentItem.children[0].parentName) {
grandTotalIndex = parentItem.children[0].index;
var grandTotalHash = parentItem.children.grandTotalHash;
parentItem.children = parentItem.children[0].children || [];
parentItem.children.grandTotalHash = grandTotalHash;
parentItem.children = getVisibleChildren(parentItem, visibleLevels)
} else if (0 === parentItem.children.length) {
grandTotalIndex = 0
}
return grandTotalIndex
}(parentItem, visibleLevels);
(0, _m_widget_utils.foreachTree)(parentItem.children, (function(items) {
var item = items[0];
var children = getVisibleChildren(item, visibleLevels);
if (children.length) {
item.children = children
} else {
delete item.children
}
delete item.levelName;
delete item.hierarchyName;
delete item.added;
delete item.parentName;
delete item.level
}), true);
(0, _iterator.each)(parentItem.children || [], (function(_, e) {
dataSourceAxis.push(e)
}));
return grandTotalIndex
}
function checkError(xml) {
var faultElementNS = xml.getElementsByTagName("soap:Fault");
var faultElement = xml.getElementsByTagName("Fault");
var errorElement = (0, _renderer.default)([].slice.call(faultElement.length ? faultElement : faultElementNS)).find("Error");
if (errorElement.length) {
var description = errorElement.attr("Description");
var error = new _errors.errors.Error("E4000", description);
_errors.errors.log("E4000", description);
return error
}
return null
}
function parseResult(xml, parseOptions) {
var dataSource = {
columns: [],
rows: []
};
var measureCount = parseOptions.measureCount;
var axes = function(xml, skipValues) {
var axes = [];
(0, _iterator.each)(xml.getElementsByTagName("Axis"), (function(_, axisElement) {
var name = axisElement.getAttribute("name");
var axis = [];
var index = 0;
if (0 === name.indexOf("Axis") && (0, _type.isNumeric)(getNumber(name.substr(4)))) {
axes.push(axis);
(0, _iterator.each)(axisElement.getElementsByTagName("Tuple"), (function(_, tupleElement) {
var tupleMembers = tupleElement.childNodes;
var levelSum = 0;
var members = [];
var membersCount = skipValues ? tupleMembers.length : tupleMembers.length - 1;
var isAxisWithMeasure = 1 === axes.length;
if (isAxisWithMeasure) {
membersCount -= 1
}
axis.push(members);
for (var i = membersCount; i >= 0; i -= 1) {
var tuple = tupleMembers[i];
var level = getNumber(getFirstChildText(tuple, "LNum"));
members[i] = {
caption: getFirstChildText(tuple, "Caption"),
value: (valueText = getFirstChildText(tuple, "MEMBER_VALUE"), (0, _type.isNumeric)(valueText) ? parseFloat(valueText) : valueText),
level: level,
index: index++,
hasValue: !levelSum && (!!level || 0 === i),
name: getFirstChildText(tuple, "UName"),
hierarchyName: tupleMembers[i].getAttribute("Hierarchy"),
parentName: getFirstChildText(tuple, "PARENT_UNIQUE_NAME"),
levelName: getFirstChildText(tuple, "LName")
};
levelSum += level
}
var valueText
}))
}
}));
while (axes.length < 2) {
axes.push([
[{
level: 0
}]
])
}
return axes
}(xml, parseOptions.skipValues);
dataSource.grandTotalColumnIndex = fillDataSourceAxes(dataSource.columns, axes[0], measureCount, parseOptions.visibleLevels);
dataSource.grandTotalRowIndex = fillDataSourceAxes(dataSource.rows, axes[1], void 0, parseOptions.visibleLevels);
dataSource.values = parseCells(xml, axes, measureCount);
return dataSource
}
function parseDiscoverRowSet(xml, schema, dimensions, translatedDisplayFolders) {
var result = [];
var isMeasure = "MEASURE" === schema;
var displayFolderField = isMeasure ? "MEASUREGROUP_NAME" : "".concat(schema, "_DISPLAY_FOLDER");
(0, _iterator.each)(xml.getElementsByTagName("row"), (function(_, row) {
var hierarchyName = "LEVEL" === schema ? getFirstChildText(row, "HIERARCHY_UNIQUE_NAME") : void 0;
var levelNumber = getFirstChildText(row, "LEVEL_NUMBER");
var displayFolder = getFirstChildText(row, displayFolderField);
if (isMeasure) {
displayFolder = translatedDisplayFolders[displayFolder] || displayFolder
}
if (("0" !== levelNumber || "true" !== getFirstChildText(row, "".concat(schema, "_IS_VISIBLE"))) && "2" !== getFirstChildText(row, "DIMENSION_TYPE")) {
var dimension = isMeasure ? "DX_MEASURES" : getFirstChildText(row, "DIMENSION_UNIQUE_NAME");
var dataField = getFirstChildText(row, "".concat(schema, "_UNIQUE_NAME"));
result.push({
dimension: dimensions.names[dimension] || dimension,
groupIndex: levelNumber ? getNumber(levelNumber) - 1 : void 0,
dataField: dataField,
caption: getFirstChildText(row, "".concat(schema, "_CAPTION")),
hierarchyName: hierarchyName,
groupName: hierarchyName,
displayFolder: displayFolder,
isMeasure: isMeasure,
isDefault: !!dimensions.defaultHierarchies[dataField]
})
}
}));
return result
}
function parseStringWithUnicodeSymbols(str) {
str = str.replace(/_x(....)_/g, (function(_, group1) {
return String.fromCharCode(parseInt(group1, 16))
}));
var stringArray = str.match(/\[.+?\]/gi);
if (stringArray && stringArray.length) {
str = stringArray[stringArray.length - 1]
}
return str.replace(/\[/gi, "").replace(/\]/gi, "").replace(/\$/gi, "").replace(/\./gi, " ")
}
function sendQuery(storeOptions, mdxString) {
mdxString = (0, _renderer.default)(" ").text(mdxString).html();
return execXMLA(storeOptions, (0, _string.format)(' {0}{1}TrueMicrosoft SQL Server Management Studio3600{2}', mdxString, storeOptions.catalog, getLocaleIdProperty()))
}
return {
ctor: function(options) {
this._options = options
},
getFields: function() {
var options = this._options;
var catalog = options.catalog;
var cube = options.cube;
var localeIdProperty = getLocaleIdProperty();
var dimensionsRequest = execXMLA(options, (0, _string.format)(discover, catalog, cube, "MDSCHEMA_DIMENSIONS", localeIdProperty));
var measuresRequest = execXMLA(options, (0, _string.format)(discover, catalog, cube, "MDSCHEMA_MEASURES", localeIdProperty));
var hierarchiesRequest = execXMLA(options, (0, _string.format)(discover, catalog, cube, "MDSCHEMA_HIERARCHIES", localeIdProperty));
var levelsRequest = execXMLA(options, (0, _string.format)(discover, catalog, cube, "MDSCHEMA_LEVELS", localeIdProperty));
var result = new _deferred.Deferred;
(0, _deferred.when)(dimensionsRequest, measuresRequest, hierarchiesRequest, levelsRequest).then((function(dimensionsResponse, measuresResponse, hierarchiesResponse, levelsResponse) {
execXMLA(options, (0, _string.format)(discover, catalog, cube, "MDSCHEMA_MEASUREGROUPS", localeIdProperty)).done((function(measureGroupsResponse) {
var dimensions = function(xml) {
var result = {
names: {},
defaultHierarchies: {}
};
(0, _iterator.each)((0, _renderer.default)(xml).find("row"), (function() {
var $row = (0, _renderer.default)(this);
var type = $row.children("DIMENSION_TYPE").text();
var dimensionName = "2" === type ? "DX_MEASURES" : $row.children("DIMENSION_UNIQUE_NAME").text();
result.names[dimensionName] = $row.children("DIMENSION_CAPTION").text();
result.defaultHierarchies[$row.children("DEFAULT_HIERARCHY").text()] = true
}));
return result
}(dimensionsResponse);
var hierarchies = parseDiscoverRowSet(hierarchiesResponse, "HIERARCHY", dimensions);
var levels = parseDiscoverRowSet(levelsResponse, "LEVEL", dimensions);
var measureGroups = function(xml) {
var measureGroups = {};
(0, _iterator.each)(xml.getElementsByTagName("row"), (function(_, row) {
measureGroups[getFirstChildText(row, "MEASUREGROUP_NAME")] = getFirstChildText(row, "MEASUREGROUP_CAPTION")
}));
return measureGroups
}(measureGroupsResponse);
var fields = parseDiscoverRowSet(measuresResponse, "MEASURE", dimensions, measureGroups).concat(hierarchies);
var levelsByHierarchy = {};
(0, _iterator.each)(levels, (function(_, level) {
levelsByHierarchy[level.hierarchyName] = levelsByHierarchy[level.hierarchyName] || [];
levelsByHierarchy[level.hierarchyName].push(level)
}));
(0, _iterator.each)(hierarchies, (function(_, hierarchy) {
if (levelsByHierarchy[hierarchy.dataField] && levelsByHierarchy[hierarchy.dataField].length > 1) {
hierarchy.groupName = hierarchy.hierarchyName = hierarchy.dataField;
fields.push.apply(fields, levelsByHierarchy[hierarchy.hierarchyName])
}
}));
result.resolve(fields)
})).fail(result.reject)
})).fail(result.reject);
return result
},
load: function(options) {
var result = new _deferred.Deferred;
var storeOptions = this._options;
var parseOptions = {
skipValues: options.skipValues
};
var mdxString = generateMDX(options, storeOptions.cube, parseOptions);
var rowCountMdx;
if (options.rowSkip || options.rowTake || options.columnTake || options.columnSkip) {
rowCountMdx = generateMDX((0, _extend.extend)({}, options, {
totalsOnly: true,
rowSkip: null,
rowTake: null,
columnSkip: null,
columnTake: null
}), storeOptions.cube, {})
}
var load = function() {
if (mdxString) {
(0, _deferred.when)(sendQuery(storeOptions, mdxString), rowCountMdx && sendQuery(storeOptions, rowCountMdx)).done((function(executeXml, rowCountXml) {
var error = checkError(executeXml) || rowCountXml && checkError(rowCountXml);
if (!error) {
var response = parseResult(executeXml, parseOptions);
if (rowCountXml) {
! function(data, options, totalCountXml) {
var axes = [];
var columnOptions = options.columns || [];
var rowOptions = options.rows || [];
if (columnOptions.length) {
axes.push({})
}
if (rowOptions.length) {
axes.push({})
}
var cells = parseCells(totalCountXml, [
[{}],
[{}, {}]
], 1);
if (!columnOptions.length && rowOptions.length) {
data.rowCount = Math.max(cells[0][0][0] - 1, 0)
}
if (!rowOptions.length && columnOptions.length) {
data.columnCount = Math.max(cells[0][0][0] - 1, 0)
}
if (rowOptions.length && columnOptions.length) {
data.rowCount = Math.max(cells[0][0][0] - 1, 0);
data.columnCount = Math.max(cells[1][0][0] - 1, 0)
}
if (void 0 !== data.rowCount && options.rowTake) {
data.rows = _toConsumableArray(Array(options.rowSkip)).concat(data.rows);
data.rows.length = data.rowCount;
for (var i = 0; i < data.rows.length; i += 1) {
data.rows[i] = data.rows[i] || {}
}
}
if (void 0 !== data.columnCount && options.columnTake) {
data.columns = _toConsumableArray(Array(options.columnSkip)).concat(data.columns);
data.columns.length = data.columnCount;
for (var _i = 0; _i < data.columns.length; _i += 1) {
data.columns[_i] = data.columns[_i] || {}
}
}
}(response, options, rowCountXml)
}
result.resolve(response)
} else {
result.reject(error)
}
})).fail(result.reject)
} else {
result.resolve({
columns: [],
rows: [],
values: [],
grandTotalColumnIndex: 0,
grandTotalRowIndex: 0
})
}
};
if (options.delay) {
setTimeout(load, options.delay)
} else {
load()
}
return result
},
supportPaging: function() {
return true
},
getDrillDownItems: function(options, params) {
var result = new _deferred.Deferred;
var storeOptions = this._options;
var mdxString = function(options, cubeName, params) {
var columns = options.columns || [];
var rows = options.rows || [];
var values = options.values && options.values.length ? options.values : [{
dataField: "[Measures]"
}];
var slice = [];
var withArray = [];
var axisStrings = [];
var dataFields = prepareDataFields(withArray, values);
var maxRowCount = params.maxRowCount;
var customColumns = params.customColumns || [];
var customColumnsString = customColumns.length > 0 ? " return ".concat(customColumns.join(",")) : "";
createDrillDownAxisSlice(slice, columns, params.columnPath || []);
createDrillDownAxisSlice(slice, rows, params.rowPath || []);
if (columns.length || dataFields.length) {
axisStrings.push(["".concat(dataFields[params.dataIndex] || dataFields[0], " on 0")])
}
var coreMDX = generateMdxCore(axisStrings, withArray, columns, rows, options.filters, slice, cubeName);
return coreMDX ? "drillthrough".concat(maxRowCount > 0 ? " maxrows ".concat(maxRowCount) : "").concat(coreMDX).concat(customColumnsString) : coreMDX
}(options, storeOptions.cube, params);
if (mdxString) {
(0, _deferred.when)(sendQuery(storeOptions, mdxString)).done((function(executeXml) {
var error = checkError(executeXml);
if (!error) {
result.resolve(function(xml) {
var rows = xml.getElementsByTagName("row");
var result = [];
var columnNames = {};
for (var i = 0; i < rows.length; i += 1) {
var children = rows[i].childNodes;
var item = {};
for (var j = 0; j < children.length; j += 1) {
var tagName = children[j].tagName;
var name = columnNames[tagName] = columnNames[tagName] || parseStringWithUnicodeSymbols(tagName);
item[name] = getNodeText(children[j])
}
result.push(item)
}
return result
}(executeXml))
} else {
result.reject(error)
}
})).fail(result.reject)
} else {
result.resolve([])
}
return result
},
key: _common.noop,
filter: _common.noop
}
}()).include(_m_widget_utils.storeDrillDownMixin);
exports.XmlaStore = XmlaStore;
var _default = {
XmlaStore: XmlaStore
};
exports.default = _default
},
26686:
/*!*************************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/data_controller/m_data_controller.js ***!
\*************************************************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.DataController = void 0;
var _common = __webpack_require__( /*! ../../../../core/utils/common */ 20576);
var _deferred = __webpack_require__( /*! ../../../../core/utils/deferred */ 62754);
var _extend = __webpack_require__( /*! ../../../../core/utils/extend */ 13306);
var _m_data_controller = __webpack_require__( /*! ../../../grids/grid_core/data_controller/m_data_controller */ 72119);
var _m_data_source_adapter = _interopRequireDefault(__webpack_require__( /*! ../data_source_adapter/m_data_source_adapter */ 22821));
var _m_core = _interopRequireDefault(__webpack_require__( /*! ../m_core */ 12500));
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var DataController = _m_data_controller.dataControllerModule.controllers.data.inherit({
_getDataSourceAdapter: function() {
return _m_data_source_adapter.default
},
_getNodeLevel: function(node) {
var level = -1;
while (node.parent) {
if (node.visible) {
level++
}
node = node.parent
}
return level
},
_generateDataItem: function(node, options) {
return {
rowType: "data",
node: node,
key: node.key,
data: node.data,
isExpanded: this.isRowExpanded(node.key, options),
level: this._getNodeLevel(node)
}
},
_loadOnOptionChange: function() {
this._dataSource.load()
},
_isItemEquals: function(item1, item2) {
if (!this.callBase.apply(this, arguments)) {
return false
}
if (item1.node && item2.node && item1.node.hasChildren !== item2.node.hasChildren) {
return false
}
if (item1.level !== item2.level || item1.isExpanded !== item2.isExpanded) {
return false
}
return true
},
init: function() {
this.createAction("onRowExpanding");
this.createAction("onRowExpanded");
this.createAction("onRowCollapsing");
this.createAction("onRowCollapsed");
this.callBase.apply(this, arguments)
},
keyOf: function(data) {
var dataSource = this._dataSource;
if (dataSource) {
return dataSource.keyOf(data)
}
},
key: function() {
var dataSource = this._dataSource;
if (dataSource) {
return dataSource.getKeyExpr()
}
},
publicMethods: function() {
return this.callBase().concat(["expandRow", "collapseRow", "isRowExpanded", "getRootNode", "getNodeByKey", "loadDescendants", "forEachNode"])
},
changeRowExpand: function(key) {
var _this = this;
if (this._dataSource) {
var args = {
key: key
};
var isExpanded = this.isRowExpanded(key);
this.executeAction(isExpanded ? "onRowCollapsing" : "onRowExpanding", args);
if (!args.cancel) {
return this._dataSource.changeRowExpand(key).done((function() {
_this.executeAction(isExpanded ? "onRowCollapsed" : "onRowExpanded", args)
}))
}
}
return (new _deferred.Deferred).resolve()
},
isRowExpanded: function(key, cache) {
return this._dataSource && this._dataSource.isRowExpanded(key, cache)
},
expandRow: function(key) {
if (!this.isRowExpanded(key)) {
return this.changeRowExpand(key)
}
return (new _deferred.Deferred).resolve()
},
collapseRow: function(key) {
if (this.isRowExpanded(key)) {
return this.changeRowExpand(key)
}
return (new _deferred.Deferred).resolve()
},
getRootNode: function() {
return this._dataSource && this._dataSource.getRootNode()
},
optionChanged: function(args) {
switch (args.name) {
case "rootValue":
case "parentIdExpr":
case "itemsExpr":
case "filterMode":
case "expandNodesOnFiltering":
case "autoExpandAll":
case "hasItemsExpr":
case "dataStructure":
this._columnsController.reset();
this._items = [];
this._refreshDataSource();
args.handled = true;
break;
case "expandedRowKeys":
case "onNodesInitialized":
if (this._dataSource && !this._dataSource._isNodesInitializing && !(0, _common.equalByValue)(args.value, args.previousValue)) {
this._loadOnOptionChange()
}
args.handled = true;
break;
case "maxFilterLengthInRequest":
args.handled = true;
break;
default:
this.callBase(args)
}
},
getNodeByKey: function(key) {
if (!this._dataSource) {
return
}
return this._dataSource.getNodeByKey(key)
},
getChildNodeKeys: function(parentKey) {
if (!this._dataSource) {
return
}
return this._dataSource.getChildNodeKeys(parentKey)
},
loadDescendants: function(keys, childrenOnly) {
if (!this._dataSource) {
return
}
return this._dataSource.loadDescendants(keys, childrenOnly)
},
forEachNode: function() {
this._dataSource.forEachNode.apply(this, arguments)
}
});
exports.DataController = DataController;
_m_core.default.registerModule("data", {
defaultOptions: function() {
return (0, _extend.extend)({}, _m_data_controller.dataControllerModule.defaultOptions(), {
itemsExpr: "items",
parentIdExpr: "parentId",
rootValue: 0,
dataStructure: "plain",
expandedRowKeys: [],
filterMode: "withAncestors",
expandNodesOnFiltering: true,
autoExpandAll: false,
onNodesInitialized: null,
maxFilterLengthInRequest: 1500,
paging: {
enabled: false
}
})
},
controllers: {
data: DataController
}
})
},
22821:
/*!*********************************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/data_source_adapter/m_data_source_adapter.js ***!
\*********************************************************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _common = __webpack_require__( /*! ../../../../core/utils/common */ 20576);
var _data = __webpack_require__( /*! ../../../../core/utils/data */ 47617);
var _deferred = __webpack_require__( /*! ../../../../core/utils/deferred */ 62754);
var _extend = __webpack_require__( /*! ../../../../core/utils/extend */ 13306);
var _iterator = __webpack_require__( /*! ../../../../core/utils/iterator */ 95479);
var _type = __webpack_require__( /*! ../../../../core/utils/type */ 35922);
var _array_store = _interopRequireDefault(__webpack_require__( /*! ../../../../data/array_store */ 26562));
var _array_utils = __webpack_require__( /*! ../../../../data/array_utils */ 60637);
var _query = _interopRequireDefault(__webpack_require__( /*! ../../../../data/query */ 96687));
var _store_helper = _interopRequireDefault(__webpack_require__( /*! ../../../../data/store_helper */ 99236));
var _ui = _interopRequireDefault(__webpack_require__( /*! ../../../../ui/widget/ui.errors */ 96688));
var _m_data_source_adapter = _interopRequireDefault(__webpack_require__( /*! ../../../grids/grid_core/data_source_adapter/m_data_source_adapter */ 30945));
var _m_utils = _interopRequireDefault(__webpack_require__( /*! ../../../grids/grid_core/m_utils */ 60082));
var _m_core = _interopRequireDefault(__webpack_require__( /*! ../m_core */ 12500));
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var queryByOptions = _store_helper.default.queryByOptions;
var isFullBranchFilterMode = function(that) {
return "fullBranch" === that.option("filterMode")
};
var DataSourceAdapterTreeList = _m_data_source_adapter.default.inherit({
_createKeyGetter: function() {
var keyExpr = this.getKeyExpr();
return (0, _data.compileGetter)(keyExpr)
},
_createKeySetter: function() {
var keyExpr = this.getKeyExpr();
if ((0, _type.isFunction)(keyExpr)) {
return keyExpr
}
return (0, _data.compileSetter)(keyExpr)
},
createParentIdGetter: function() {
return (0, _data.compileGetter)(this.option("parentIdExpr"))
},
createParentIdSetter: function() {
var parentIdExpr = this.option("parentIdExpr");
if ((0, _type.isFunction)(parentIdExpr)) {
return parentIdExpr
}
return (0, _data.compileSetter)(parentIdExpr)
},
_createItemsGetter: function() {
return (0, _data.compileGetter)(this.option("itemsExpr"))
},
_createHasItemsGetter: function() {
var hasItemsExpr = this.option("hasItemsExpr");
return hasItemsExpr && (0, _data.compileGetter)(hasItemsExpr)
},
_createHasItemsSetter: function() {
var hasItemsExpr = this.option("hasItemsExpr");
if ((0, _type.isFunction)(hasItemsExpr)) {
return hasItemsExpr
}
return hasItemsExpr && (0, _data.compileSetter)(hasItemsExpr)
},
_updateIndexByKeyObject: function(items) {
var that = this;
that._indexByKey = {};
(0, _iterator.each)(items, (function(index, item) {
that._indexByKey[item.key] = index
}))
},
_calculateHasItems: function(node, options) {
var parentIds = options.storeLoadOptions.parentIds;
var hasItems;
var isFullBranch = isFullBranchFilterMode(this);
if (this._hasItemsGetter && (parentIds || !options.storeLoadOptions.filter || isFullBranch)) {
hasItems = this._hasItemsGetter(node.data)
}
if (void 0 === hasItems) {
if (!this._isChildrenLoaded[node.key] && options.remoteOperations.filtering && (parentIds || isFullBranch)) {
hasItems = true
} else if (options.loadOptions.filter && !options.remoteOperations.filtering && isFullBranch) {
hasItems = node.children.length
} else {
hasItems = node.hasChildren
}
}
return !!hasItems
},
_fillVisibleItemsByNodes: function(nodes, options, result) {
for (var i = 0; i < nodes.length; i++) {
if (nodes[i].visible) {
result.push(nodes[i])
}
if ((this.isRowExpanded(nodes[i].key, options) || !nodes[i].visible) && nodes[i].hasChildren && nodes[i].children.length) {
this._fillVisibleItemsByNodes(nodes[i].children, options, result)
}
}
},
_convertItemToNode: function(item, rootValue, nodeByKey) {
var key = this._keyGetter(item);
var parentId = this._parentIdGetter(item);
parentId = (0, _type.isDefined)(parentId) ? parentId : rootValue;
var parentNode = nodeByKey[parentId] = nodeByKey[parentId] || {
key: parentId,
children: []
};
var node = nodeByKey[key] = nodeByKey[key] || {
key: key,
children: []
};
node.data = item;
node.parent = parentNode;
return node
},
_createNodesByItems: function(items, visibleItems) {
var rootValue = this.option("rootValue");
var visibleByKey = {};
var nodeByKey = this._nodeByKey = {};
var i;
if (visibleItems) {
for (i = 0; i < visibleItems.length; i++) {
visibleByKey[this._keyGetter(visibleItems[i])] = true
}
}
for (i = 0; i < items.length; i++) {
var node = this._convertItemToNode(items[i], rootValue, nodeByKey);
if (void 0 === node.key) {
return
}
node.visible = !visibleItems || !!visibleByKey[node.key];
if (node.parent) {
node.parent.children.push(node)
}
}
var rootNode = nodeByKey[rootValue] || {
key: rootValue,
children: []
};
rootNode.level = -1;
return rootNode
},
_convertDataToPlainStructure: function(data, parentId, result) {
var key;
if (this._itemsGetter && !data.isConverted) {
result = result || [];
for (var i = 0; i < data.length; i++) {
var item = (0, _array_utils.createObjectWithChanges)(data[i]);
key = this._keyGetter(item);
if (void 0 === key) {
key = result.length + 1;
this._keySetter(item, key)
}
this._parentIdSetter(item, void 0 === parentId ? this.option("rootValue") : parentId);
result.push(item);
var childItems = this._itemsGetter(item);
if (childItems && childItems.length) {
this._convertDataToPlainStructure(childItems, key, result);
var itemsExpr = this.option("itemsExpr");
if (!(0, _type.isFunction)(itemsExpr)) {
delete item[itemsExpr]
}
}
}
result.isConverted = true;
return result
}
return data
},
_createIdFilter: function(field, keys) {
var parentIdFilters = [];
for (var i = 0; i < keys.length; i++) {
parentIdFilters.push([field, "=", keys[i]])
}
return _m_utils.default.combineFilters(parentIdFilters, "or")
},
_customizeRemoteOperations: function(options, operationTypes) {
this.callBase.apply(this, arguments);
options.remoteOperations.paging = false;
var expandVisibleNodes = false;
if (this.option("autoExpandAll")) {
options.remoteOperations.sorting = false;
options.remoteOperations.filtering = false;
if ((!this._lastLoadOptions || operationTypes.filtering && !options.storeLoadOptions.filter) && !options.isCustomLoading) {
expandVisibleNodes = true
}
}
if (!options.isCustomLoading) {
this._isReload = this._isReload || operationTypes.reload;
if (!options.cachedStoreData) {
this._isChildrenLoaded = {};
if (this._isReload) {
this._nodeByKey = {}
}
}
if (this.option("expandNodesOnFiltering") && (operationTypes.filtering || this._isReload && options.storeLoadOptions.filter)) {
if (options.storeLoadOptions.filter) {
expandVisibleNodes = true
} else {
options.collapseVisibleNodes = true
}
}
}
options.expandVisibleNodes = expandVisibleNodes
},
_getParentIdsToLoad: function(parentIds) {
var parentIdsToLoad = [];
for (var i = 0; i < parentIds.length; i++) {
var node = this.getNodeByKey(parentIds[i]);
if (!node || node.hasChildren && !node.children.length) {
parentIdsToLoad.push(parentIds[i])
}
}
return parentIdsToLoad
},
_handleCustomizeStoreLoadOptions: function(options) {
var rootValue = this.option("rootValue");
var parentIdExpr = this.option("parentIdExpr");
var parentIds = options.storeLoadOptions.parentIds;
if (parentIds) {
options.isCustomLoading = false
}
this.callBase.apply(this, arguments);
if (options.remoteOperations.filtering && !options.isCustomLoading) {
if (isFullBranchFilterMode(this) && options.cachedStoreData || !options.storeLoadOptions.filter) {
var expandedRowKeys = options.collapseVisibleNodes ? [] : this.option("expandedRowKeys");
parentIds = [rootValue].concat(expandedRowKeys).concat(parentIds || []);
var parentIdsToLoad = options.data ? this._getParentIdsToLoad(parentIds) : parentIds;
if (parentIdsToLoad.length) {
options.cachedPagingData = void 0;
options.data = void 0;
options.mergeStoreLoadData = true;
options.delay = this.option("loadingTimeout")
}
options.storeLoadOptions.parentIds = parentIdsToLoad;
options.storeLoadOptions.filter = this._createIdFilter(parentIdExpr, parentIdsToLoad)
}
}
},
_generateInfoToLoad: function(data, needChildren) {
var key;
var keyMap = {};
var resultKeyMap = {};
var resultKeys = [];
var rootValue = this.option("rootValue");
var i;
for (i = 0; i < data.length; i++) {
key = needChildren ? this._parentIdGetter(data[i]) : this._keyGetter(data[i]);
keyMap[key] = true
}
for (i = 0; i < data.length; i++) {
key = needChildren ? this._keyGetter(data[i]) : this._parentIdGetter(data[i]);
var needToLoad = needChildren ? this.isRowExpanded(key) : key !== rootValue;
if (!keyMap[key] && !resultKeyMap[key] && needToLoad) {
resultKeyMap[key] = true;
resultKeys.push(key)
}
}
return {
keyMap: resultKeyMap,
keys: resultKeys
}
},
_loadParentsOrChildren: function(data, options, needChildren) {
var _this = this;
var that = this;
var filter;
var needLocalFiltering;
var _that$_generateInfoTo = that._generateInfoToLoad(data, needChildren),
keys = _that$_generateInfoTo.keys,
keyMap = _that$_generateInfoTo.keyMap;
var d = new _deferred.Deferred;
var isRemoteFiltering = options.remoteOperations.filtering;
var maxFilterLengthInRequest = that.option("maxFilterLengthInRequest");
var loadOptions = isRemoteFiltering ? options.storeLoadOptions : options.loadOptions;
function concatLoadedData(loadedData) {
if (isRemoteFiltering) {
that._cachedStoreData = that._cachedStoreData.concat(loadedData)
}
return data.concat(loadedData)
}
if (!keys.length) {
return d.resolve(data)
}
var cachedNodes = keys.map((function(id) {
return _this.getNodeByKey(id)
})).filter((function(node) {
return node && node.data
}));
if (cachedNodes.length === keys.length) {
if (needChildren) {
cachedNodes = cachedNodes.reduce((function(result, node) {
return result.concat(node.children)
}), [])
}
if (cachedNodes.length) {
return that._loadParentsOrChildren(concatLoadedData(cachedNodes.map((function(node) {
return node.data
}))), options, needChildren)
}
}
var keyExpr = needChildren ? that.option("parentIdExpr") : that.getKeyExpr();
filter = that._createIdFilter(keyExpr, keys);
var filterLength = encodeURI(JSON.stringify(filter)).length;
if (filterLength > maxFilterLengthInRequest) {
filter = function(itemData) {
return keyMap[needChildren ? that._parentIdGetter(itemData) : that._keyGetter(itemData)]
};
needLocalFiltering = isRemoteFiltering
}
loadOptions = (0, _extend.extend)({}, loadOptions, {
filter: !needLocalFiltering ? filter : null
});
var store = options.fullData ? new _array_store.default(options.fullData) : that._dataSource.store();
that.loadFromStore(loadOptions, store).done((function(loadedData) {
if (loadedData.length) {
if (needLocalFiltering) {
loadedData = (0, _query.default)(loadedData).filter(filter).toArray()
}
that._loadParentsOrChildren(concatLoadedData(loadedData), options, needChildren).done(d.resolve).fail(d.reject)
} else {
d.resolve(data)
}
})).fail(d.reject);
return d
},
_loadParents: function(data, options) {
return this._loadParentsOrChildren(data, options)
},
_loadChildrenIfNeed: function(data, options) {
if (isFullBranchFilterMode(this)) {
return this._loadParentsOrChildren(data, options, true)
}
return (0, _deferred.when)(data)
},
_updateHasItemsMap: function(options) {
var parentIds = options.storeLoadOptions.parentIds;
if (parentIds) {
for (var i = 0; i < parentIds.length; i++) {
this._isChildrenLoaded[parentIds[i]] = true
}
}
},
_getKeyInfo: function() {
return {
key: function() {
return "key"
},
keyOf: function(data) {
return data.key
}
}
},
_processChanges: function(changes) {
var _this2 = this;
var processedChanges = [];
changes.forEach((function(change) {
if ("insert" === change.type) {
processedChanges = processedChanges.concat(_this2._applyInsert(change))
} else if ("remove" === change.type) {
processedChanges = processedChanges.concat(_this2._applyRemove(change))
} else if ("update" === change.type) {
processedChanges.push({
type: change.type,
key: change.key,
data: {
data: change.data
}
})
}
}));
return processedChanges
},
_handleChanging: function(e) {
var _this3 = this;
this.callBase.apply(this, arguments);
var processChanges = function(changes) {
var changesToProcess = changes.filter((function(item) {
return "update" === item.type
}));
return _this3._processChanges(changesToProcess)
};
e.postProcessChanges = processChanges
},
_applyBatch: function(changes) {
var processedChanges = this._processChanges(changes);
this.callBase(processedChanges)
},
_setHasItems: function(node, value) {
var hasItemsSetter = this._hasItemsSetter;
node.hasChildren = value;
if (hasItemsSetter && node.data) {
hasItemsSetter(node.data, value)
}
},
_applyInsert: function(change) {
var baseChanges = [];
var parentId = this.parentKeyOf(change.data);
var parentNode = this.getNodeByKey(parentId);
if (parentNode) {
var rootValue = this.option("rootValue");
var node = this._convertItemToNode(change.data, rootValue, this._nodeByKey);
node.hasChildren = false;
node.level = parentNode.level + 1;
node.visible = true;
parentNode.children.push(node);
this._isChildrenLoaded[node.key] = true;
this._setHasItems(parentNode, true);
if ((!parentNode.parent || this.isRowExpanded(parentNode.key)) && void 0 !== change.index) {
var index = this.items().indexOf(parentNode) + 1;
index += change.index >= 0 ? Math.min(change.index, parentNode.children.length) : parentNode.children.length;
baseChanges.push({
type: change.type,
data: node,
index: index
})
}
}
return baseChanges
},
_needToCopyDataObject: function() {
return false
},
_applyRemove: function(change) {
var baseChanges = [];
var node = this.getNodeByKey(change.key);
var parentNode = node && node.parent;
if (parentNode) {
var index = parentNode.children.indexOf(node);
if (index >= 0) {
parentNode.children.splice(index, 1);
if (!parentNode.children.length) {
this._setHasItems(parentNode, false)
}
baseChanges.push(change);
baseChanges = baseChanges.concat(this.getChildNodeKeys(change.key).map((function(key) {
return {
type: change.type,
key: key
}
})))
}
}
return baseChanges
},
_handleDataLoaded: function(options) {
var data = options.data = this._convertDataToPlainStructure(options.data);
if (!options.remoteOperations.filtering && options.loadOptions.filter) {
options.fullData = queryByOptions((0, _query.default)(options.data), {
sort: options.loadOptions && options.loadOptions.sort
}).toArray()
}
this._updateHasItemsMap(options);
this.callBase(options);
if (data.isConverted && this._cachedStoreData) {
this._cachedStoreData.isConverted = true
}
},
_fillNodes: function(nodes, options, expandedRowKeys, level) {
var isFullBranch = isFullBranchFilterMode(this);
level = level || 0;
for (var i = 0; i < nodes.length; i++) {
var node = nodes[i];
var needToExpand = false;
this._fillNodes(nodes[i].children, options, expandedRowKeys, level + 1);
node.level = level;
node.hasChildren = this._calculateHasItems(node, options);
if (node.visible && node.hasChildren) {
if (isFullBranch) {
if (node.children.filter((function(node) {
return node.visible
})).length) {
needToExpand = true
} else if (node.children.length) {
_m_core.default.foreachNodes(node.children, (function(node) {
node.visible = true
}))
}
} else {
needToExpand = true
}
if (options.expandVisibleNodes && needToExpand) {
expandedRowKeys.push(node.key)
}
}
if (node.visible || node.hasChildren) {
node.parent.hasChildren = true
}
}
},
_processTreeStructure: function(options, visibleItems) {
var data = options.data;
var parentIds = options.storeLoadOptions.parentIds;
var expandedRowKeys = [];
if (parentIds && parentIds.length || this._isReload) {
if (options.fullData && options.fullData.length > options.data.length) {
data = options.fullData;
visibleItems = visibleItems || options.data
}
this._rootNode = this._createNodesByItems(data, visibleItems);
if (!this._rootNode) {
options.data = (new _deferred.Deferred).reject(_ui.default.Error("E1046", this.getKeyExpr()));
return
}
this._fillNodes(this._rootNode.children, options, expandedRowKeys);
this._isNodesInitializing = true;
if (options.collapseVisibleNodes || expandedRowKeys.length) {
this.option("expandedRowKeys", expandedRowKeys)
}
this._isReload = false;
this.executeAction("onNodesInitialized", {
root: this._rootNode
});
this._isNodesInitializing = false
}
var resultData = [];
this._fillVisibleItemsByNodes(this._rootNode.children, options, resultData);
options.data = resultData;
this._totalItemsCount = resultData.length
},
_handleDataLoadedCore: function(options) {
var that = this;
var data = options.data;
var callBase = that.callBase;
var filter = options.storeLoadOptions.filter || options.loadOptions.filter;
var filterMode = that.option("filterMode");
var visibleItems;
var parentIds = options.storeLoadOptions.parentIds;
var needLoadParents = filter && (!parentIds || !parentIds.length) && "standard" !== filterMode;
if (!options.isCustomLoading) {
if (needLoadParents) {
var d = options.data = new _deferred.Deferred;
if ("matchOnly" === filterMode) {
visibleItems = data
}
return that._loadParents(data, options).done((function(data) {
that._loadChildrenIfNeed(data, options).done((function(data) {
options.data = data;
that._processTreeStructure(options, visibleItems);
callBase.call(that, options);
d.resolve(options.data)
}))
})).fail(d.reject)
}
that._processTreeStructure(options)
}
that.callBase(options)
},
_handlePush: function(_ref) {
var changes = _ref.changes;
var reshapeOnPush = this._dataSource._reshapeOnPush;
var isNeedReshape = reshapeOnPush && !!changes.length;
if (isNeedReshape) {
this._isReload = true
}
changes.forEach((function(change) {
var _a;
null !== (_a = change.index) && void 0 !== _a ? _a : change.index = -1
}));
this.callBase.apply(this, arguments)
},
init: function(dataSource, remoteOperations) {
this.callBase.apply(this, arguments);
var dataStructure = this.option("dataStructure");
this._keyGetter = this._createKeyGetter();
this._parentIdGetter = this.createParentIdGetter();
this._hasItemsGetter = this._createHasItemsGetter();
this._hasItemsSetter = this._createHasItemsSetter();
if ("tree" === dataStructure) {
this._itemsGetter = this._createItemsGetter();
this._keySetter = this._createKeySetter();
this._parentIdSetter = this.createParentIdSetter()
}
this._nodeByKey = {};
this._isChildrenLoaded = {};
this._totalItemsCount = 0;
this.createAction("onNodesInitialized")
},
getKeyExpr: function() {
var store = this.store();
var key = store && store.key();
var keyExpr = this.option("keyExpr");
if ((0, _type.isDefined)(key) && (0, _type.isDefined)(keyExpr)) {
if (!(0, _common.equalByValue)(key, keyExpr)) {
throw _ui.default.Error("E1044")
}
}
return key || keyExpr || "id"
},
keyOf: function(data) {
return this._keyGetter && this._keyGetter(data)
},
parentKeyOf: function(data) {
return this._parentIdGetter && this._parentIdGetter(data)
},
getRootNode: function() {
return this._rootNode
},
totalItemsCount: function() {
return this._totalItemsCount + this._totalCountCorrection
},
isRowExpanded: function(key, cache) {
if (cache) {
var isExpandedByKey = cache.isExpandedByKey;
if (!isExpandedByKey) {
isExpandedByKey = cache.isExpandedByKey = {};
this.option("expandedRowKeys").forEach((function(key) {
isExpandedByKey[key] = true
}))
}
return !!isExpandedByKey[key]
}
var indexExpandedNodeKey = _m_utils.default.getIndexByKey(key, this.option("expandedRowKeys"), null);
return indexExpandedNodeKey >= 0
},
_changeRowExpandCore: function(key) {
var expandedRowKeys = this.option("expandedRowKeys").slice();
var indexExpandedNodeKey = _m_utils.default.getIndexByKey(key, expandedRowKeys, null);
if (indexExpandedNodeKey < 0) {
expandedRowKeys.push(key)
} else {
expandedRowKeys.splice(indexExpandedNodeKey, 1)
}
this.option("expandedRowKeys", expandedRowKeys)
},
changeRowExpand: function(key) {
this._changeRowExpandCore(key);
return this._isNodesInitializing ? (new _deferred.Deferred).resolve() : this.load()
},
getNodeByKey: function(key) {
if (this._nodeByKey) {
return this._nodeByKey[key]
}
},
getNodeLeafKeys: function() {
var that = this;
var result = [];
var keys = that._rootNode ? [that._rootNode.key] : [];
keys.forEach((function(key) {
var node = that.getNodeByKey(key);
node && _m_core.default.foreachNodes([node], (function(childNode) {
!childNode.children.length && result.push(childNode.key)
}))
}));
return result
},
getChildNodeKeys: function(parentKey) {
var node = this.getNodeByKey(parentKey);
var childrenKeys = [];
node && _m_core.default.foreachNodes(node.children, (function(childNode) {
childrenKeys.push(childNode.key)
}));
return childrenKeys
},
loadDescendants: function(keys, childrenOnly) {
var that = this;
var d = new _deferred.Deferred;
var remoteOperations = that.remoteOperations();
if ((0, _type.isDefined)(keys)) {
keys = Array.isArray(keys) ? keys : [keys]
} else {
keys = that.getNodeLeafKeys()
}
if (!remoteOperations.filtering || !keys.length) {
return d.resolve()
}
var loadOptions = that._dataSource._createStoreLoadOptions();
loadOptions.parentIds = keys;
that.load(loadOptions).done((function() {
if (!childrenOnly) {
var childKeys = function(that, keys) {
var childKeys = [];
keys.forEach((function(key) {
var node = that.getNodeByKey(key);
node && node.children.forEach((function(child) {
childKeys.push(child.key)
}))
}));
return childKeys
}(that, keys);
if (childKeys.length) {
that.loadDescendants(childKeys, childrenOnly).done(d.resolve).fail(d.reject);
return
}
}
d.resolve()
})).fail(d.reject);
return d.promise()
},
forEachNode: function() {
var nodes = [];
var callback;
if (1 === arguments.length) {
callback = arguments[0];
var rootNode = this.getRootNode();
nodes = rootNode && rootNode.children || []
} else if (2 === arguments.length) {
callback = arguments[1];
nodes = arguments[0];
nodes = Array.isArray(nodes) ? nodes : [nodes]
}
_m_core.default.foreachNodes(nodes, callback)
}
});
var _default = {
extend: function(extender) {
DataSourceAdapterTreeList = DataSourceAdapterTreeList.inherit(extender)
},
create: function(component) {
return new DataSourceAdapterTreeList(component)
}
};
exports.default = _default
},
17629:
/*!*********************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/editing/m_editing.js ***!
\*********************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
__webpack_require__( /*! ../module_not_extended/editor_factory */ 29900);
var _renderer = _interopRequireDefault(__webpack_require__( /*! ../../../../core/renderer */ 68374));
var _deferred = __webpack_require__( /*! ../../../../core/utils/deferred */ 62754);
var _extend = __webpack_require__( /*! ../../../../core/utils/extend */ 13306);
var _type = __webpack_require__( /*! ../../../../core/utils/type */ 35922);
var _message = _interopRequireDefault(__webpack_require__( /*! ../../../../localization/message */ 28109));
var _ui = _interopRequireDefault(__webpack_require__( /*! ../../../../ui/widget/ui.errors */ 96688));
var _m_editing = __webpack_require__( /*! ../../../grids/grid_core/editing/m_editing */ 22324);
var _m_utils = _interopRequireDefault(__webpack_require__( /*! ../../../grids/grid_core/m_utils */ 60082));
var _m_core = _interopRequireDefault(__webpack_require__( /*! ../m_core */ 12500));
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var EditingController = _m_editing.editingModule.controllers.editing.inherit({
_generateNewItem: function(key) {
var item = this.callBase(key);
item.data = {
key: key
};
item.children = [];
item.level = 0;
item.parentKey = this.option("rootValue");
return item
},
_isProcessedItem: function() {
return true
},
_setInsertAfterOrBeforeKey: function(change, parentKey) {
if (void 0 !== parentKey && parentKey !== this.option("rootValue")) {
change.insertAfterKey = parentKey
} else {
this.callBase.apply(this, arguments)
}
},
_getLoadedRowIndex: function(items, change) {
var dataController = this.getController("data");
var dataSourceAdapter = dataController.dataSource();
var parentKey = null === dataSourceAdapter || void 0 === dataSourceAdapter ? void 0 : dataSourceAdapter.parentKeyOf(change.data);
if (void 0 !== parentKey && parentKey !== this.option("rootValue")) {
var rowIndex = _m_utils.default.getIndexByKey(parentKey, items);
if (rowIndex >= 0 && this._dataController.isRowExpanded(parentKey)) {
return rowIndex + 1
}
return -1
}
return this.callBase.apply(this, arguments)
},
_isEditColumnVisible: function() {
var result = this.callBase.apply(this, arguments);
var editingOptions = this.option("editing");
return result || editingOptions.allowAdding
},
_isDefaultButtonVisible: function(button, options) {
var result = this.callBase.apply(this, arguments);
var row = options.row;
if ("add" === button.name) {
return this.allowAdding(options) && row.rowIndex !== this._getVisibleEditRowIndex() && !(row.removed || row.isNewRow)
}
return result
},
_getEditingButtons: function(options) {
var buttons = this.callBase.apply(this, arguments);
if (!options.column.buttons) {
buttons.unshift(this._getButtonConfig("add", options))
}
return buttons
},
_beforeSaveEditData: function(change) {
var dataController = this._dataController;
var result = this.callBase.apply(this, arguments);
if (change && "insert" !== change.type) {
var store = null === dataController || void 0 === dataController ? void 0 : dataController.store();
var key = null === store || void 0 === store ? void 0 : store.key();
if (!(0, _type.isDefined)(key)) {
throw _ui.default.Error("E1045")
}
}
return result
},
addRowByRowIndex: function(rowIndex) {
var dataController = this.getController("data");
var row = dataController.getVisibleRows()[rowIndex];
return this.addRow(row ? row.key : void 0)
},
addRow: function(key) {
if (void 0 === key) {
key = this.option("rootValue")
}
return this.callBase.call(this, key)
},
_addRowCore: function(data, parentKey, oldEditRowIndex) {
var _this = this;
var callBase = this.callBase;
var rootValue = this.option("rootValue");
var dataController = this.getController("data");
var dataSourceAdapter = dataController.dataSource();
var parentKeyGetter = dataSourceAdapter.createParentIdGetter();
parentKey = parentKeyGetter(data);
if (void 0 !== parentKey && parentKey !== rootValue && !dataController.isRowExpanded(parentKey)) {
var deferred = new _deferred.Deferred;
dataController.expandRow(parentKey).done((function() {
setTimeout((function() {
callBase.call(_this, data, parentKey, oldEditRowIndex).done(deferred.resolve).fail(deferred.reject)
}))
})).fail(deferred.reject);
return deferred.promise()
}
return callBase.call(this, data, parentKey, oldEditRowIndex)
},
_initNewRow: function(options, parentKey) {
var dataController = this.getController("data");
var dataSourceAdapter = dataController.dataSource();
var parentIdSetter = dataSourceAdapter.createParentIdSetter();
parentIdSetter(options.data, parentKey);
return this.callBase.apply(this, arguments)
},
allowAdding: function(options) {
return this._allowEditAction("allowAdding", options)
},
_needToCloseEditableCell: function($targetElement) {
return this.callBase.apply(this, arguments) || $targetElement.closest(".".concat("dx-treelist-icon-container")).length && this.isEditing()
},
getButtonLocalizationNames: function() {
var names = this.callBase.apply(this);
names.add = "dxTreeList-editingAddRowToNode";
return names
}
});
var originalRowClick = _m_editing.editingModule.extenders.views.rowsView._rowClick;
var originalRowDblClick = _m_editing.editingModule.extenders.views.rowsView._rowDblClick;
var validateClick = function(e) {
var $targetElement = (0, _renderer.default)(e.event.target);
var originalClickHandler = "dxdblclick" === e.event.type ? originalRowDblClick : originalRowClick;
if ($targetElement.closest(".".concat("dx-select-checkbox")).length) {
return false
}
return !needToCallOriginalClickHandler.call(this, e, originalClickHandler)
};
function needToCallOriginalClickHandler(e, originalClickHandler) {
var $targetElement = (0, _renderer.default)(e.event.target);
if (!$targetElement.closest(".".concat("dx-treelist-icon-container")).length) {
originalClickHandler.call(this, e);
return true
}
return false
}
var RowsViewExtender = (0, _extend.extend)({}, _m_editing.editingModule.extenders.views.rowsView, {
_renderCellCommandContent: function($container, options) {
var editingController = this._editingController;
var isEditRow = options.row && editingController.isEditRow(options.row.rowIndex);
var isEditing = options.isEditing || isEditRow;
if (!isEditing) {
return this.callBase.apply(this, arguments)
}
return false
},
_rowClick: function(e) {
if (validateClick.call(this, e)) {
this.callBase.apply(this, arguments)
}
},
_rowDblClick: function(e) {
if (validateClick.call(this, e)) {
this.callBase.apply(this, arguments)
}
}
});
_m_core.default.registerModule("editing", {
defaultOptions: function() {
return (0, _extend.extend)(true, _m_editing.editingModule.defaultOptions(), {
editing: {
texts: {
addRowToNode: _message.default.format("dxTreeList-editingAddRowToNode")
}
}
})
},
controllers: {
editing: EditingController
},
extenders: {
controllers: (0, _extend.extend)(true, {}, _m_editing.editingModule.extenders.controllers, {
data: {
changeRowExpand: function() {
this._editingController.refresh();
return this.callBase.apply(this, arguments)
}
}
}),
views: {
rowsView: RowsViewExtender,
headerPanel: _m_editing.editingModule.extenders.views.headerPanel
}
}
})
},
79873:
/*!************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/m_columns_controller.js ***!
\************************************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.ColumnsController = void 0;
var _type = __webpack_require__( /*! ../../../core/utils/type */ 35922);
var _m_columns_controller = __webpack_require__( /*! ../../grids/grid_core/columns_controller/m_columns_controller */ 10279);
var _m_core = (obj = __webpack_require__( /*! ./m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var ColumnsController = _m_columns_controller.columnsControllerModule.controllers.columns.inherit({
_getFirstItems: function(dataSourceAdapter) {
return this.callBase(dataSourceAdapter).map((function(node) {
return node.data
}))
},
getFirstDataColumnIndex: function() {
var visibleColumns = this.getVisibleColumns();
var visibleColumnsLength = visibleColumns.length;
var firstDataColumnIndex = 0;
for (var i = 0; i <= visibleColumnsLength - 1; i++) {
if (!(0, _type.isDefined)(visibleColumns[i].command)) {
firstDataColumnIndex = visibleColumns[i].index;
break
}
}
return firstDataColumnIndex
}
});
exports.ColumnsController = ColumnsController;
_m_core.default.registerModule("columns", {
defaultOptions: _m_columns_controller.columnsControllerModule.defaultOptions,
controllers: {
columns: ColumnsController
}
})
},
12500:
/*!**********************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/m_core.js ***!
\**********************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _extend = __webpack_require__( /*! ../../../core/utils/extend */ 13306);
var _m_modules = (obj = __webpack_require__( /*! ../../grids/grid_core/m_modules */ 15943), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var _default = (0, _extend.extend)({}, _m_modules.default, {
modules: [],
foreachNodes: function(nodes, callBack, ignoreHasChildren) {
for (var i = 0; i < nodes.length; i++) {
if (false !== callBack(nodes[i]) && (ignoreHasChildren || nodes[i].hasChildren) && nodes[i].children.length) {
this.foreachNodes(nodes[i].children, callBack, ignoreHasChildren)
}
}
}
});
exports.default = _default
},
50226:
/*!***********************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/m_focus.js ***!
\***********************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _deferred = __webpack_require__( /*! ../../../core/utils/deferred */ 62754);
var _extend = __webpack_require__( /*! ../../../core/utils/extend */ 13306);
var _m_focus = __webpack_require__( /*! ../../grids/grid_core/focus/m_focus */ 5325);
var _m_core = (obj = __webpack_require__( /*! ./m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("focus", (0, _extend.extend)(true, {}, _m_focus.focusModule, {
extenders: {
controllers: {
data: {
changeRowExpand: function(key) {
if (this.option("focusedRowEnabled") && this.isRowExpanded(key)) {
if (this._isFocusedRowInside(key)) {
this.option("focusedRowKey", key)
}
}
return this.callBase.apply(this, arguments)
},
_isFocusedRowInside: function(parentKey) {
var focusedRowKey = this.option("focusedRowKey");
var rowIndex = this.getRowIndexByKey(focusedRowKey);
var focusedRow = rowIndex >= 0 && this.getVisibleRows()[rowIndex];
var parent = focusedRow && focusedRow.node.parent;
while (parent) {
if (parent.key === parentKey) {
return true
}
parent = parent.parent
}
return false
},
getParentKey: function(key) {
var dataSource = this._dataSource;
var node = this.getNodeByKey(key);
var d = new _deferred.Deferred;
if (node) {
d.resolve(node.parent ? node.parent.key : void 0)
} else {
dataSource.load({
filter: [dataSource.getKeyExpr(), "=", key]
}).done((function(items) {
var parentData = items[0];
if (parentData) {
d.resolve(dataSource.parentKeyOf(parentData))
} else {
d.reject()
}
})).fail(d.reject)
}
return d.promise()
},
expandAscendants: function(key) {
var that = this;
var dataSource = that._dataSource;
var d = new _deferred.Deferred;
that.getParentKey(key).done((function(parentKey) {
if (dataSource && void 0 !== parentKey && parentKey !== that.option("rootValue")) {
dataSource._isNodesInitializing = true;
that.expandRow(parentKey);
dataSource._isNodesInitializing = false;
that.expandAscendants(parentKey).done(d.resolve).fail(d.reject)
} else {
d.resolve()
}
})).fail(d.reject);
return d.promise()
},
getPageIndexByKey: function(key) {
var that = this;
var dataSource = that._dataSource;
var d = new _deferred.Deferred;
that.expandAscendants(key).done((function() {
dataSource.load({
parentIds: []
}).done((function(nodes) {
var offset = function(items, callback) {
var result = -1;
items.forEach((function(node, index) {
if (callback(node)) {
result = index
}
}));
return result
}(nodes, (function(node) {
return that.keyOf(node.data) === key
}));
var pageIndex = -1;
if (offset >= 0) {
pageIndex = Math.floor(offset / that.pageSize())
}
d.resolve(pageIndex)
})).fail(d.reject)
})).fail(d.reject);
return d.promise()
}
}
}
}
}))
},
94907:
/*!***************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/m_grid_view.js ***!
\***************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_grid_view = __webpack_require__( /*! ../../grids/grid_core/views/m_grid_view */ 28016);
var _m_core = (obj = __webpack_require__( /*! ./m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var GridView = _m_grid_view.gridViewModule.views.gridView.inherit({
_getWidgetAriaLabel: function() {
return "dxTreeList-ariaTreeList"
},
_getTableRoleName: function() {
return "treegrid"
}
});
_m_core.default.registerModule("gridView", {
defaultOptions: _m_grid_view.gridViewModule.defaultOptions,
controllers: _m_grid_view.gridViewModule.controllers,
views: {
gridView: GridView
},
extenders: {
controllers: {
resizing: {
_toggleBestFitMode: function(isBestFit) {
this.callBase(isBestFit);
var $rowsTable = this._rowsView.getTableElement();
$rowsTable.find(".dx-treelist-cell-expandable").toggleClass(this.addWidgetPrefix("best-fit"), isBestFit)
}
}
}
}
})
},
38886:
/*!*************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/m_keyboard_navigation.js ***!
\*************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _extend = __webpack_require__( /*! ../../../core/utils/extend */ 13306);
var _m_keyboard_navigation = __webpack_require__( /*! ../../grids/grid_core/keyboard_navigation/m_keyboard_navigation */ 31822);
var _m_core = (obj = __webpack_require__( /*! ./m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("keyboardNavigation", (0, _extend.extend)(true, {}, _m_keyboard_navigation.keyboardNavigationModule, {
extenders: {
controllers: {
keyboardNavigation: {
_leftRightKeysHandler: function(eventArgs, isEditing) {
var rowIndex = this.getVisibleRowIndex();
var dataController = this._dataController;
if (eventArgs.ctrl) {
var directionCode = this._getDirectionCodeByKey(eventArgs.keyName);
var key = dataController.getKeyByRowIndex(rowIndex);
if ("nextInRow" === directionCode) {
dataController.expandRow(key)
} else {
dataController.collapseRow(key)
}
} else {
return this.callBase.apply(this, arguments)
}
}
}
}
}
}))
},
31580:
/*!*******************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/m_master_detail.js ***!
\*******************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _extend = __webpack_require__( /*! ../../../core/utils/extend */ 13306);
var _m_master_detail = __webpack_require__( /*! ../../grids/grid_core/master_detail/m_master_detail */ 82802);
var _m_core = (obj = __webpack_require__( /*! ./m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("masterDetail", (0, _extend.extend)(true, {}, _m_master_detail.masterDetailModule, {
extenders: {
controllers: {
data: {
isRowExpanded: function() {
return this.callBase.apply(this, arguments)
},
_processItems: function() {
return this.callBase.apply(this, arguments)
},
_processDataItem: function() {
return this.callBase.apply(this, arguments)
}
}
}
}
}))
},
13477:
/*!*******************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/m_state_storing.js ***!
\*******************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _extend = __webpack_require__( /*! ../../../core/utils/extend */ 13306);
var _m_state_storing = __webpack_require__( /*! ../../grids/grid_core/state_storing/m_state_storing */ 12440);
var _m_core = (obj = __webpack_require__( /*! ./m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var origApplyState = _m_state_storing.stateStoringModule.extenders.controllers.stateStoring.applyState;
_m_core.default.registerModule("stateStoring", (0, _extend.extend)(true, {}, _m_state_storing.stateStoringModule, {
extenders: {
controllers: {
stateStoring: {
applyState: function(state) {
origApplyState.apply(this, arguments);
this.option("expandedRowKeys", state.expandedRowKeys ? state.expandedRowKeys.slice() : [])
}
},
data: {
getUserState: function() {
var state = this.callBase.apply(this, arguments);
if (!this.option("autoExpandAll")) {
state.expandedRowKeys = this.option("expandedRowKeys")
}
return state
}
}
}
}
}))
},
99751:
/*!****************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/m_validating.js ***!
\****************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _extend = __webpack_require__( /*! ../../../core/utils/extend */ 13306);
var _m_validating = __webpack_require__( /*! ../../grids/grid_core/validating/m_validating */ 39830);
var _m_core = (obj = __webpack_require__( /*! ./m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var EditingControllerExtender = (0, _extend.extend)({}, _m_validating.validatingModule.extenders.controllers.editing);
delete EditingControllerExtender.processItems;
delete EditingControllerExtender.processDataItem;
_m_core.default.registerModule("validating", {
defaultOptions: _m_validating.validatingModule.defaultOptions,
controllers: _m_validating.validatingModule.controllers,
extenders: {
controllers: {
editing: EditingControllerExtender,
editorFactory: _m_validating.validatingModule.extenders.controllers.editorFactory
},
views: _m_validating.validatingModule.extenders.views
}
})
},
26058:
/*!***********************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/m_virtual_scrolling.js ***!
\***********************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _extend = __webpack_require__( /*! ../../../core/utils/extend */ 13306);
var _m_virtual_scrolling = __webpack_require__( /*! ../../grids/grid_core/virtual_scrolling/m_virtual_scrolling */ 92018);
var _m_data_source_adapter = _interopRequireDefault(__webpack_require__( /*! ./data_source_adapter/m_data_source_adapter */ 22821));
var _m_core = _interopRequireDefault(__webpack_require__( /*! ./m_core */ 12500));
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var oldDefaultOptions = _m_virtual_scrolling.virtualScrollingModule.defaultOptions;
var originalDataControllerExtender = _m_virtual_scrolling.virtualScrollingModule.extenders.controllers.data;
var originalDataSourceAdapterExtender = _m_virtual_scrolling.virtualScrollingModule.extenders.dataSourceAdapter;
_m_virtual_scrolling.virtualScrollingModule.extenders.controllers.data = (0, _extend.extend)({}, originalDataControllerExtender, {
_loadOnOptionChange: function() {
var virtualScrollController = this._dataSource && this._dataSource._virtualScrollController;
virtualScrollController && virtualScrollController.reset();
this.callBase()
}
});
_m_virtual_scrolling.virtualScrollingModule.extenders.dataSourceAdapter = (0, _extend.extend)({}, originalDataSourceAdapterExtender, {
changeRowExpand: function() {
var _this = this;
return this.callBase.apply(this, arguments).done((function() {
var viewportItemIndex = _this.getViewportItemIndex();
viewportItemIndex >= 0 && _this.setViewportItemIndex(viewportItemIndex)
}))
}
});
_m_core.default.registerModule("virtualScrolling", (0, _extend.extend)({}, _m_virtual_scrolling.virtualScrollingModule, {
defaultOptions: function() {
return (0, _extend.extend)(true, oldDefaultOptions(), {
scrolling: {
mode: "virtual"
}
})
}
}));
_m_data_source_adapter.default.extend(_m_virtual_scrolling.virtualScrollingModule.extenders.dataSourceAdapter)
},
1977:
/*!************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/m_widget.js ***!
\************************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _m_widget_base = (obj = __webpack_require__( /*! ./m_widget_base */ 14126), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
__webpack_require__( /*! ./m_state_storing */ 13477);
__webpack_require__( /*! ./module_not_extended/column_chooser */ 92026);
__webpack_require__( /*! ./m_master_detail */ 31580);
__webpack_require__( /*! ./editing/m_editing */ 17629);
__webpack_require__( /*! ./module_not_extended/editing_row_based */ 64757);
__webpack_require__( /*! ./module_not_extended/editing_form_based */ 45998);
__webpack_require__( /*! ./module_not_extended/editing_cell_based */ 7446);
__webpack_require__( /*! ./m_validating */ 99751);
__webpack_require__( /*! ./m_virtual_scrolling */ 26058);
__webpack_require__( /*! ./module_not_extended/filter_row */ 98439);
__webpack_require__( /*! ./module_not_extended/header_filter */ 26763);
__webpack_require__( /*! ./module_not_extended/filter_sync */ 1440);
__webpack_require__( /*! ./module_not_extended/filter_builder */ 49248);
__webpack_require__( /*! ./module_not_extended/filter_panel */ 86737);
__webpack_require__( /*! ./module_not_extended/pager */ 84214);
__webpack_require__( /*! ./module_not_extended/columns_resizing_reordering */ 43468);
__webpack_require__( /*! ./module_not_extended/column_fixing */ 50776);
__webpack_require__( /*! ./module_not_extended/adaptivity */ 43301);
__webpack_require__( /*! ./selection/m_selection */ 91445);
__webpack_require__( /*! ./module_not_extended/search */ 1272);
__webpack_require__( /*! ./m_keyboard_navigation */ 38886);
__webpack_require__( /*! ./module_not_extended/virtual_columns */ 75188);
__webpack_require__( /*! ./m_focus */ 50226);
__webpack_require__( /*! ./module_not_extended/row_dragging */ 31937);
var _default = _m_widget_base.default;
exports.default = _default
},
14126:
/*!*****************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/m_widget_base.js ***!
\*****************************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
__webpack_require__( /*! ./module_not_extended/column_headers */ 25052);
__webpack_require__( /*! ./m_columns_controller */ 79873);
__webpack_require__( /*! ./data_controller/m_data_controller */ 26686);
__webpack_require__( /*! ./module_not_extended/sorting */ 7138);
__webpack_require__( /*! ./rows/m_rows */ 31397);
__webpack_require__( /*! ./module_not_extended/context_menu */ 87454);
__webpack_require__( /*! ./module_not_extended/error_handling */ 84973);
__webpack_require__( /*! ./m_grid_view */ 94907);
__webpack_require__( /*! ./module_not_extended/header_panel */ 37980);
var _component_registrator = _interopRequireDefault(__webpack_require__( /*! ../../../core/component_registrator */ 99393));
var _common = __webpack_require__( /*! ../../../core/utils/common */ 20576);
var _extend = __webpack_require__( /*! ../../../core/utils/extend */ 13306);
var _iterator = __webpack_require__( /*! ../../../core/utils/iterator */ 95479);
var _type = __webpack_require__( /*! ../../../core/utils/type */ 35922);
var _themes = __webpack_require__( /*! ../../../ui/themes */ 75811);
var _ui = _interopRequireDefault(__webpack_require__( /*! ../../../ui/widget/ui.widget */ 14390));
var _m_utils = _interopRequireDefault(__webpack_require__( /*! ../../grids/grid_core/m_utils */ 60082));
var _m_core = _interopRequireDefault(__webpack_require__( /*! ./m_core */ 12500));
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var callModuleItemsMethod = _m_core.default.callModuleItemsMethod;
_m_core.default.registerModulesOrder(["stateStoring", "columns", "selection", "editorFactory", "columnChooser", "editingRowBased", "editingFormBased", "editingCellBased", "editing", "grouping", "masterDetail", "validating", "adaptivity", "data", "virtualScrolling", "columnHeaders", "filterRow", "headerPanel", "headerFilter", "sorting", "search", "rows", "pager", "columnsResizingReordering", "contextMenu", "keyboardNavigation", "errorHandling", "summary", "columnFixing", "export", "gridView"]);
var TreeList = _ui.default.inherit({
_activeStateUnit: ".dx-row",
_getDefaultOptions: function() {
var result = this.callBase();
(0, _iterator.each)(_m_core.default.modules, (function() {
if ((0, _type.isFunction)(this.defaultOptions)) {
(0, _extend.extend)(true, result, this.defaultOptions())
}
}));
return result
},
_setDeprecatedOptions: function() {
this.callBase();
(0, _extend.extend)(this._deprecatedOptions, {
"columnChooser.allowSearch": {
since: "23.1",
message: 'Use the "columnChooser.search.enabled" option instead'
},
"columnChooser.searchTimeout": {
since: "23.1",
message: 'Use the "columnChooser.search.timeout" option instead'
}
})
},
_defaultOptionsRules: function() {
return this.callBase().concat([{
device: function() {
return (0, _themes.isMaterial)()
},
options: {
showRowLines: true,
showColumnLines: false,
headerFilter: {
height: 315
},
editing: {
useIcons: true
}
}
}])
},
_init: function() {
this.callBase();
if (!this.option("_disableDeprecationWarnings")) {
_m_utils.default.logHeaderFilterDeprecatedWarningIfNeed(this)
}
_m_core.default.processModules(this, _m_core.default);
callModuleItemsMethod(this, "init")
},
_clean: _common.noop,
_optionChanged: function(args) {
callModuleItemsMethod(this, "optionChanged", [args]);
if (!args.handled) {
this.callBase(args)
}
},
_dimensionChanged: function() {
this.updateDimensions(true)
},
_visibilityChanged: function(visible) {
if (visible) {
this.updateDimensions()
}
},
_initMarkup: function() {
this.callBase.apply(this, arguments);
this.$element().addClass("dx-treelist");
this.getView("gridView").render(this.$element())
},
_renderContentImpl: function() {
this.getView("gridView").update()
},
_renderContent: function() {
var that = this;
(0, _common.deferRender)((function() {
that._renderContentImpl()
}))
},
_dispose: function() {
this.callBase();
callModuleItemsMethod(this, "dispose")
},
isReady: function() {
return this.getController("data").isReady()
},
beginUpdate: function() {
this.callBase();
callModuleItemsMethod(this, "beginUpdate")
},
endUpdate: function() {
callModuleItemsMethod(this, "endUpdate");
this.callBase()
},
getController: function(name) {
return this._controllers[name]
},
getView: function(name) {
return this._views[name]
},
focus: function(element) {
this.callBase();
if ((0, _type.isDefined)(element)) {
this.getController("keyboardNavigation").focus(element)
}
}
});
TreeList.registerModule = _m_core.default.registerModule.bind(_m_core.default);
(0, _component_registrator.default)("dxTreeList", TreeList);
var _default = TreeList;
exports.default = _default
},
43301:
/*!**********************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/adaptivity.js ***!
\**********************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_adaptivity = __webpack_require__( /*! ../../../grids/grid_core/adaptivity/m_adaptivity */ 18107);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("adaptivity", _m_adaptivity.adaptivityModule)
},
92026:
/*!**************************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/column_chooser.js ***!
\**************************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_column_chooser = __webpack_require__( /*! ../../../grids/grid_core/column_chooser/m_column_chooser */ 71184);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("columnChooser", _m_column_chooser.columnChooserModule)
},
50776:
/*!*************************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/column_fixing.js ***!
\*************************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_column_fixing = __webpack_require__( /*! ../../../grids/grid_core/column_fixing/m_column_fixing */ 53424);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("columnFixing", _m_column_fixing.columnFixingModule)
},
25052:
/*!**************************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/column_headers.js ***!
\**************************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_column_headers = __webpack_require__( /*! ../../../grids/grid_core/column_headers/m_column_headers */ 14509);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("columnHeaders", _m_column_headers.columnHeadersModule)
},
43468:
/*!***************************************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/columns_resizing_reordering.js ***!
\***************************************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_columns_resizing_reordering = __webpack_require__( /*! ../../../grids/grid_core/columns_resizing_reordering/m_columns_resizing_reordering */ 49505);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("columnsResizingReordering", _m_columns_resizing_reordering.columnsResizingReorderingModule)
},
87454:
/*!************************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/context_menu.js ***!
\************************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_context_menu = __webpack_require__( /*! ../../../grids/grid_core/context_menu/m_context_menu */ 69823);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("contextMenu", _m_context_menu.contextMenuModule)
},
7446:
/*!******************************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/editing_cell_based.js ***!
\******************************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_editing_cell_based = __webpack_require__( /*! ../../../grids/grid_core/editing/m_editing_cell_based */ 68802);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("editingCellBased", _m_editing_cell_based.editingCellBasedModule)
},
45998:
/*!******************************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/editing_form_based.js ***!
\******************************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_editing_form_based = __webpack_require__( /*! ../../../grids/grid_core/editing/m_editing_form_based */ 99211);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("editingFormBased", _m_editing_form_based.editingFormBasedModule)
},
64757:
/*!*****************************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/editing_row_based.js ***!
\*****************************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_editing_row_based = __webpack_require__( /*! ../../../grids/grid_core/editing/m_editing_row_based */ 55597);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("editingRowBased", _m_editing_row_based.editingRowBasedModule)
},
29900:
/*!**************************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/editor_factory.js ***!
\**************************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_editor_factory = __webpack_require__( /*! ../../../grids/grid_core/editor_factory/m_editor_factory */ 80070);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("editorFactory", _m_editor_factory.editorFactoryModule)
},
84973:
/*!**************************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/error_handling.js ***!
\**************************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_error_handling = __webpack_require__( /*! ../../../grids/grid_core/error_handling/m_error_handling */ 31152);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("errorHandling", _m_error_handling.errorHandlingModule)
},
49248:
/*!**************************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/filter_builder.js ***!
\**************************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_filter_builder = __webpack_require__( /*! ../../../grids/grid_core/filter/m_filter_builder */ 62690);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("filterBuilder", _m_filter_builder.filterBuilderModule)
},
86737:
/*!************************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/filter_panel.js ***!
\************************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_filter_panel = __webpack_require__( /*! ../../../grids/grid_core/filter/m_filter_panel */ 4062);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("filterPanel", _m_filter_panel.filterPanelModule)
},
98439:
/*!**********************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/filter_row.js ***!
\**********************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_filter_row = __webpack_require__( /*! ../../../grids/grid_core/filter/m_filter_row */ 12302);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("filterRow", _m_filter_row.filterRowModule)
},
1440:
/*!***********************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/filter_sync.js ***!
\***********************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_filter_sync = __webpack_require__( /*! ../../../grids/grid_core/filter/m_filter_sync */ 14407);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("filterSync", _m_filter_sync.filterSyncModule)
},
26763:
/*!*************************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/header_filter.js ***!
\*************************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_header_filter = __webpack_require__( /*! ../../../grids/grid_core/header_filter/m_header_filter */ 68796);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("headerFilter", _m_header_filter.headerFilterModule)
},
37980:
/*!************************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/header_panel.js ***!
\************************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_header_panel = __webpack_require__( /*! ../../../grids/grid_core/header_panel/m_header_panel */ 92468);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("headerPanel", _m_header_panel.headerPanelModule)
},
84214:
/*!*****************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/pager.js ***!
\*****************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_pager = __webpack_require__( /*! ../../../grids/grid_core/pager/m_pager */ 3990);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("pager", _m_pager.pagerModule)
},
31937:
/*!************************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/row_dragging.js ***!
\************************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_row_dragging = __webpack_require__( /*! ../../../grids/grid_core/row_dragging/m_row_dragging */ 88351);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("rowDragging", _m_row_dragging.rowDraggingModule)
},
1272:
/*!******************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/search.js ***!
\******************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_search = __webpack_require__( /*! ../../../grids/grid_core/search/m_search */ 92021);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("search", _m_search.searchModule)
},
7138:
/*!*******************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/sorting.js ***!
\*******************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_sorting = __webpack_require__( /*! ../../../grids/grid_core/sorting/m_sorting */ 11590);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("sorting", _m_sorting.sortingModule)
},
75188:
/*!***************************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/module_not_extended/virtual_columns.js ***!
\***************************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _m_virtual_columns = __webpack_require__( /*! ../../../grids/grid_core/virtual_columns/m_virtual_columns */ 87482);
var _m_core = (obj = __webpack_require__( /*! ../m_core */ 12500), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
_m_core.default.registerModule("virtualColumns", _m_virtual_columns.virtualColumnsModule)
},
31397:
/*!***************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/rows/m_rows.js ***!
\***************************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.RowsView = void 0;
var _renderer = _interopRequireDefault(__webpack_require__( /*! ../../../../core/renderer */ 68374));
var _m_rows_view = __webpack_require__( /*! ../../../grids/grid_core/views/m_rows_view */ 35095);
var _m_core = _interopRequireDefault(__webpack_require__( /*! ../m_core */ 12500));
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var RowsView = _m_rows_view.rowsModule.views.rowsView.inherit((createIcon = function(hasIcon, isExpanded) {
var $iconElement = (0, _renderer.default)(" ").addClass("dx-treelist-empty-space");
if (hasIcon) {
$iconElement.toggleClass("dx-treelist-expanded", isExpanded).toggleClass("dx-treelist-collapsed", !isExpanded).append((0, _renderer.default)(" "))
}
return $iconElement
}, {
_renderIconContainer: function($container, options) {
var _this = this;
var $iconContainer = (0, _renderer.default)("").addClass("dx-treelist-icon-container").appendTo($container);
options.watch && options.watch((function() {
return [options.row.level, options.row.isExpanded, options.row.node.hasChildren]
}), (function() {
$iconContainer.empty();
_this._renderIcons($iconContainer, options)
}));
$container.addClass("dx-treelist-cell-expandable");
return this._renderIcons($iconContainer, options)
},
_renderIcons: function($iconContainer, options) {
var row = options.row;
var level = row.level;
for (var i = 0; i <= level; i++) {
$iconContainer.append(createIcon(i === level && row.node.hasChildren, row.isExpanded))
}
return $iconContainer
},
_renderCellCommandContent: function(container, model) {
this._renderIconContainer(container, model);
return true
},
_processTemplate: function(template, options) {
var _a;
var that = this;
var resultTemplate;
var renderingTemplate = this.callBase(template);
var firstDataColumnIndex = that._columnsController.getFirstDataColumnIndex();
if (renderingTemplate && (null === (_a = options.column) || void 0 === _a ? void 0 : _a.index) === firstDataColumnIndex) {
resultTemplate = {
render: function(options) {
var $container = options.container;
if (that._renderCellCommandContent($container, options.model)) {
options.container = function($container) {
return (0, _renderer.default)(" ").addClass("dx-treelist-text-content").appendTo($container)
}($container)
}
renderingTemplate.render(options)
}
}
} else {
resultTemplate = renderingTemplate
}
return resultTemplate
},
_updateCell: function($cell, options) {
$cell = $cell.hasClass("dx-treelist-text-content") ? $cell.parent() : $cell;
this.callBase($cell, options)
},
_rowClick: function(e) {
var dataController = this._dataController;
var $targetElement = (0, _renderer.default)(e.event.target);
var isExpandIcon = this.isExpandIcon($targetElement);
var item = dataController && dataController.items()[e.rowIndex];
if (isExpandIcon && item) {
dataController.changeRowExpand(item.key)
}
this.callBase(e)
},
_createRow: function(row) {
var node = row && row.node;
var $rowElement = this.callBase.apply(this, arguments);
if (node) {
this.setAria("level", row.level + 1, $rowElement);
if (node.hasChildren) {
this.setAria("expanded", row.isExpanded, $rowElement)
}
}
return $rowElement
},
isExpandIcon: function($targetElement) {
return !!$targetElement.closest(".".concat("dx-treelist-expanded", ", .").concat("dx-treelist-collapsed")).length
}
}));
var createIcon;
exports.RowsView = RowsView;
_m_core.default.registerModule("rows", {
defaultOptions: _m_rows_view.rowsModule.defaultOptions,
views: {
rowsView: RowsView
}
})
},
91445:
/*!*************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/grids/tree_list/selection/m_selection.js ***!
\*************************************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var _renderer = _interopRequireDefault(__webpack_require__( /*! ../../../../core/renderer */ 68374));
var _common = __webpack_require__( /*! ../../../../core/utils/common */ 20576);
var _extend = __webpack_require__( /*! ../../../../core/utils/extend */ 13306);
var _type = __webpack_require__( /*! ../../../../core/utils/type */ 35922);
var _m_selection = __webpack_require__( /*! ../../../grids/grid_core/selection/m_selection */ 17969);
var _m_core = _interopRequireDefault(__webpack_require__( /*! ../m_core */ 12500));
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var originalRowClick = _m_selection.selectionModule.extenders.views.rowsView._rowClick;
var originalHandleDataChanged = _m_selection.selectionModule.extenders.controllers.data._handleDataChanged;
var nodeExists = function(array, currentKey) {
return !!array.filter((function(key) {
return key === currentKey
})).length
};
_m_core.default.registerModule("selection", (0, _extend.extend)(true, {}, _m_selection.selectionModule, {
defaultOptions: function() {
return (0, _extend.extend)(true, _m_selection.selectionModule.defaultOptions(), {
selection: {
showCheckBoxesMode: "always",
recursive: false
}
})
},
extenders: {
controllers: {
data: {
_handleDataChanged: function(e) {
var selectionController = this.getController("selection");
var isRecursiveSelection = selectionController.isRecursiveSelection();
if (isRecursiveSelection && (!e || "updateSelectionState" !== e.changeType)) {
selectionController.updateSelectionState({
selectedItemKeys: this.option("selectedRowKeys")
})
}
originalHandleDataChanged.apply(this, arguments)
},
loadDescendants: function() {
var that = this;
var d = that.callBase.apply(that, arguments);
var selectionController = that.getController("selection");
var isRecursiveSelection = selectionController.isRecursiveSelection();
if (isRecursiveSelection) {
d.done((function() {
selectionController.updateSelectionState({
selectedItemKeys: that.option("selectedRowKeys")
})
}))
}
return d
}
},
selection: {
init: function() {
this.callBase.apply(this, arguments);
this._selectionStateByKey = {}
},
_getSelectionConfig: function() {
var _arguments = arguments,
_this = this;
var config = this.callBase.apply(this, arguments);
var plainItems = config.plainItems;
config.plainItems = function(cached) {
var result;
if (cached) {
result = _this._dataController.getCachedStoreData()
}
result || (result = plainItems.apply(_this, _arguments).map((function(item) {
return item.data
})));
return result || []
};
config.isItemSelected = function(item) {
var key = _this._dataController.keyOf(item);
return _this.isRowSelected(key)
};
config.isSelectableItem = function(item) {
return !!item
};
config.getItemData = function(item) {
return item
};
config.allowLoadByRange = function() {
return false
};
return config
},
renderSelectCheckBoxContainer: function($container, model) {
var rowsView = this.component.getView("rowsView");
$container.addClass("dx-cell-focus-disabled");
var $checkbox = rowsView._renderSelectCheckBox($container, {
value: model.row.isSelected,
row: model.row,
column: model.column
});
rowsView._attachCheckBoxClickEvent($checkbox)
},
_updateSelectColumn: _common.noop,
_getSelectAllNodeKeys: function() {
var component = this.component;
var root = component.getRootNode();
var cache = {};
var keys = [];
var isRecursiveSelection = this.isRecursiveSelection();
root && _m_core.default.foreachNodes(root.children, (function(node) {
if (void 0 !== node.key && (node.visible || isRecursiveSelection)) {
keys.push(node.key)
}
if (!node.visible) {
return true
}
return isRecursiveSelection ? false : component.isRowExpanded(node.key, cache)
}));
return keys
},
isSelectAll: function() {
var selectedRowKeys = this.option("selectedRowKeys") || [];
if (0 === selectedRowKeys.length) {
return false
}
var component = this.component;
var visibleKeys = this._getSelectAllNodeKeys();
var isRecursiveSelection = this.isRecursiveSelection();
var hasIndeterminateState = false;
var selectedVisibleKeys = visibleKeys.filter((function(key) {
var isRowSelected = component.isRowSelected(key, isRecursiveSelection);
if (void 0 === isRowSelected) {
hasIndeterminateState = true
}
return isRowSelected
}));
if (!selectedVisibleKeys.length) {
return hasIndeterminateState ? void 0 : false
}
if (selectedVisibleKeys.length === visibleKeys.length) {
return true
}
return
},
selectAll: function() {
var _this2 = this;
var visibleKeys = this._getSelectAllNodeKeys().filter((function(key) {
return !_this2.isRowSelected(key)
}));
this.focusedItemIndex(-1);
return this.selectRows(visibleKeys, true)
},
deselectAll: function() {
var visibleKeys = this._getSelectAllNodeKeys();
this.focusedItemIndex(-1);
return this.deselectRows(visibleKeys)
},
selectedItemKeys: function(value, preserve, isDeselect, isSelectAll) {
var that = this;
var selectedRowKeys = that.option("selectedRowKeys");
var isRecursiveSelection = this.isRecursiveSelection();
var normalizedArgs = isRecursiveSelection && that._normalizeSelectionArgs({
keys: (0, _type.isDefined)(value) ? value : []
}, preserve, !isDeselect);
if (normalizedArgs && !(0, _common.equalByValue)(normalizedArgs.selectedRowKeys, selectedRowKeys)) {
that._isSelectionNormalizing = true;
return this.callBase(normalizedArgs.selectedRowKeys, false, false, false).always((function() {
that._isSelectionNormalizing = false
})).done((function(items) {
normalizedArgs.selectedRowsData = items;
that._fireSelectionChanged(normalizedArgs)
}))
}
return this.callBase(value, preserve, isDeselect, isSelectAll)
},
changeItemSelection: function(itemIndex, keyboardKeys) {
var _this3 = this;
var isRecursiveSelection = this.isRecursiveSelection();
if (isRecursiveSelection && !keyboardKeys.shift) {
var key = this._dataController.getKeyByRowIndex(itemIndex);
return this.selectedItemKeys(key, true, this.isRowSelected(key)).done((function() {
_this3.isRowSelected(key) && _this3.callBase(itemIndex, keyboardKeys, true)
}))
}
return this.callBase.apply(this, arguments)
},
_updateParentSelectionState: function(node, isSelected) {
var that = this;
var state = isSelected;
var parentNode = node.parent;
if (parentNode) {
if (parentNode.children.length > 1) {
if (false === isSelected) {
var hasSelectedState = parentNode.children.some((function(childNode) {
return that._selectionStateByKey[childNode.key]
}));
state = hasSelectedState ? void 0 : false
} else if (true === isSelected) {
var hasNonSelectedState = parentNode.children.some((function(childNode) {
return !that._selectionStateByKey[childNode.key]
}));
state = hasNonSelectedState ? void 0 : true
}
}
this._selectionStateByKey[parentNode.key] = state;
if (parentNode.parent && parentNode.parent.level >= 0) {
this._updateParentSelectionState(parentNode, state)
}
}
},
_updateChildrenSelectionState: function(node, isSelected) {
var that = this;
var children = node.children;
children && children.forEach((function(childNode) {
that._selectionStateByKey[childNode.key] = isSelected;
if (childNode.children.length > 0) {
that._updateChildrenSelectionState(childNode, isSelected)
}
}))
},
_updateSelectionStateCore: function(keys, isSelected) {
var dataController = this._dataController;
for (var i = 0; i < keys.length; i++) {
this._selectionStateByKey[keys[i]] = isSelected;
var node = dataController.getNodeByKey(keys[i]);
if (node) {
this._updateParentSelectionState(node, isSelected);
this._updateChildrenSelectionState(node, isSelected)
}
}
},
_getSelectedParentKeys: function(key, selectedItemKeys, useCash) {
var selectedParentNode;
var node = this._dataController.getNodeByKey(key);
var parentNode = node && node.parent;
var result = [];
while (parentNode && parentNode.level >= 0) {
result.unshift(parentNode.key);
var isSelected = useCash ? !nodeExists(selectedItemKeys, parentNode.key) && this.isRowSelected(parentNode.key) : selectedItemKeys.indexOf(parentNode.key) >= 0;
if (isSelected) {
selectedParentNode = parentNode;
result = this._getSelectedParentKeys(selectedParentNode.key, selectedItemKeys, useCash).concat(result);
break
} else if (useCash) {
break
}
parentNode = parentNode.parent
}
return selectedParentNode && result || []
},
_getSelectedChildKeys: function(key, keysToIgnore) {
var _this4 = this;
var childKeys = [];
var node = this._dataController.getNodeByKey(key);
node && _m_core.default.foreachNodes(node.children, (function(childNode) {
var ignoreKeyIndex = keysToIgnore.indexOf(childNode.key);
if (ignoreKeyIndex < 0) {
childKeys.push(childNode.key)
}
return ignoreKeyIndex > 0 || ignoreKeyIndex < 0 && void 0 === _this4._selectionStateByKey[childNode.key]
}));
return childKeys
},
_normalizeParentKeys: function(key, args) {
var keysToIgnore = [key];
var parentNodeKeys = this._getSelectedParentKeys(key, args.selectedRowKeys);
if (parentNodeKeys.length) {
keysToIgnore = keysToIgnore.concat(parentNodeKeys);
keysToIgnore.forEach((function(key) {
var index = args.selectedRowKeys.indexOf(key);
if (index >= 0) {
args.selectedRowKeys.splice(index, 1)
}
}));
var childKeys = this._getSelectedChildKeys(parentNodeKeys[0], keysToIgnore);
args.selectedRowKeys = args.selectedRowKeys.concat(childKeys)
}
},
_normalizeChildrenKeys: function(key, args) {
var _this5 = this;
var node = this._dataController.getNodeByKey(key);
node && node.children.forEach((function(childNode) {
var index = args.selectedRowKeys.indexOf(childNode.key);
if (index >= 0) {
args.selectedRowKeys.splice(index, 1)
}
_this5._normalizeChildrenKeys(childNode.key, args)
}))
},
_normalizeSelectedRowKeysCore: function(keys, args, preserve, isSelect) {
var that = this;
keys.forEach((function(key) {
if (preserve && that.isRowSelected(key) === isSelect) {
return
}
that._normalizeChildrenKeys(key, args);
var index = args.selectedRowKeys.indexOf(key);
if (isSelect) {
if (index < 0) {
args.selectedRowKeys.push(key)
}
args.currentSelectedRowKeys.push(key)
} else {
if (index >= 0) {
args.selectedRowKeys.splice(index, 1)
}
args.currentDeselectedRowKeys.push(key);
that._normalizeParentKeys(key, args)
}
}))
},
_normalizeSelectionArgs: function(args, preserve, isSelect) {
var result;
var keys = Array.isArray(args.keys) ? args.keys : [args.keys];
var selectedRowKeys = this.option("selectedRowKeys") || [];
if (keys.length) {
result = {
currentSelectedRowKeys: [],
currentDeselectedRowKeys: [],
selectedRowKeys: preserve ? selectedRowKeys.slice(0) : []
};
this._normalizeSelectedRowKeysCore(keys, result, preserve, isSelect)
}
return result
},
_updateSelectedItems: function(args) {
this.updateSelectionState(args);
this.callBase(args)
},
_fireSelectionChanged: function() {
if (!this._isSelectionNormalizing) {
this.callBase.apply(this, arguments)
}
},
_isModeLeavesOnly: function(mode) {
return "leavesOnly" === mode
},
_removeDuplicatedKeys: function(keys) {
var result = [];
var processedKeys = {};
keys.forEach((function(key) {
if (!processedKeys[key]) {
processedKeys[key] = true;
result.push(key)
}
}));
return result
},
_getAllChildKeys: function(key) {
var childKeys = [];
var node = this._dataController.getNodeByKey(key);
node && _m_core.default.foreachNodes(node.children, (function(childNode) {
childKeys.push(childNode.key)
}), true);
return childKeys
},
_getAllSelectedRowKeys: function(keys) {
var _this6 = this;
var result = [];
keys.forEach((function(key) {
var parentKeys = _this6._getSelectedParentKeys(key, [], true);
var childKeys = _this6._getAllChildKeys(key);
result.push.apply(result, parentKeys.concat([key], childKeys))
}));
result = this._removeDuplicatedKeys(result);
return result
},
_getParentSelectedRowKeys: function(keys) {
var that = this;
var result = [];
keys.forEach((function(key) {
var parentKeys = that._getSelectedParentKeys(key, keys);
!parentKeys.length && result.push(key)
}));
return result
},
_getLeafSelectedRowKeys: function(keys) {
var result = [];
var dataController = this._dataController;
keys.forEach((function(key) {
var node = dataController.getNodeByKey(key);
node && !node.hasChildren && result.push(key)
}));
return result
},
isRecursiveSelection: function() {
var selectionMode = this.option("selection.mode");
var isRecursive = this.option("selection.recursive");
return "multiple" === selectionMode && isRecursive
},
updateSelectionState: function(options) {
var removedItemKeys = options.removedItemKeys || [];
var selectedItemKeys = options.selectedItemKeys || [];
if (this.isRecursiveSelection()) {
this._updateSelectionStateCore(removedItemKeys, false);
this._updateSelectionStateCore(selectedItemKeys, true)
}
},
isRowSelected: function(key, isRecursiveSelection) {
var result = this.callBase.apply(this, arguments);
isRecursiveSelection = null !== isRecursiveSelection && void 0 !== isRecursiveSelection ? isRecursiveSelection : this.isRecursiveSelection();
if (!result && isRecursiveSelection) {
if (key in this._selectionStateByKey) {
return this._selectionStateByKey[key]
}
return false
}
return result
},
getSelectedRowKeys: function(mode) {
var that = this;
if (!that._dataController) {
return []
}
var selectedRowKeys = that.callBase.apply(that, arguments);
if (mode) {
if (this.isRecursiveSelection()) {
selectedRowKeys = this._getAllSelectedRowKeys(selectedRowKeys)
}
if ("all" !== mode) {
if ("excludeRecursive" === mode) {
selectedRowKeys = that._getParentSelectedRowKeys(selectedRowKeys)
} else if (that._isModeLeavesOnly(mode)) {
selectedRowKeys = that._getLeafSelectedRowKeys(selectedRowKeys)
}
}
}
return selectedRowKeys
},
getSelectedRowsData: function(mode) {
var dataController = this._dataController;
var selectedKeys = this.getSelectedRowKeys(mode) || [];
var selectedRowsData = [];
selectedKeys.forEach((function(key) {
var node = dataController.getNodeByKey(key);
node && selectedRowsData.push(node.data)
}));
return selectedRowsData
},
refresh: function() {
this._selectionStateByKey = {};
return this.callBase.apply(this, arguments)
}
}
},
views: {
columnHeadersView: {
_processTemplate: function(template, options) {
var that = this;
var resultTemplate;
var renderingTemplate = this.callBase(template, options);
var firstDataColumnIndex = that._columnsController.getFirstDataColumnIndex();
if (renderingTemplate && "header" === options.rowType && options.column.index === firstDataColumnIndex) {
resultTemplate = {
render: function(options) {
if ("multiple" === that.option("selection.mode")) {
that.renderSelectAll(options.container, options.model)
}
renderingTemplate.render(options)
}
}
} else {
resultTemplate = renderingTemplate
}
return resultTemplate
},
renderSelectAll: function($cell, options) {
$cell.addClass("dx-treelist-select-all");
this._renderSelectAllCheckBox($cell)
},
_isSortableElement: function($target) {
return this.callBase($target) && !$target.closest(".".concat("dx-select-checkbox")).length
}
},
rowsView: {
_renderIcons: function($iconContainer, options) {
this.callBase.apply(this, arguments);
if (!options.row.isNewRow && "multiple" === this.option("selection.mode")) {
this.getController("selection").renderSelectCheckBoxContainer($iconContainer, options)
}
return $iconContainer
},
_rowClick: function(e) {
var $targetElement = (0, _renderer.default)(e.event.target);
if (this.isExpandIcon($targetElement)) {
this.callBase.apply(this, arguments)
} else {
originalRowClick.apply(this, arguments)
}
}
}
}
}
}))
},
86988:
/*!***********************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/m_draggable.js ***!
\***********************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _position = _interopRequireDefault(__webpack_require__( /*! ../animation/position */ 49387));
var _translator = __webpack_require__( /*! ../animation/translator */ 31648);
var _component_registrator = _interopRequireDefault(__webpack_require__( /*! ../core/component_registrator */ 99393));
var _dom_adapter = _interopRequireDefault(__webpack_require__( /*! ../core/dom_adapter */ 73349));
var _dom_component = _interopRequireDefault(__webpack_require__( /*! ../core/dom_component */ 13046));
var _element = __webpack_require__( /*! ../core/element */ 6415);
var _renderer = _interopRequireDefault(__webpack_require__( /*! ../core/renderer */ 68374));
var _empty_template = __webpack_require__( /*! ../core/templates/empty_template */ 10688);
var _common = __webpack_require__( /*! ../core/utils/common */ 20576);
var _deferred = __webpack_require__( /*! ../core/utils/deferred */ 62754);
var _extend = __webpack_require__( /*! ../core/utils/extend */ 13306);
var _inflector = __webpack_require__( /*! ../core/utils/inflector */ 78008);
var _position2 = __webpack_require__( /*! ../core/utils/position */ 37518);
var _size = __webpack_require__( /*! ../core/utils/size */ 58664);
var _string = __webpack_require__( /*! ../core/utils/string */ 68752);
var _type = __webpack_require__( /*! ../core/utils/type */ 35922);
var _view_port = __webpack_require__( /*! ../core/utils/view_port */ 77695);
var _window = __webpack_require__( /*! ../core/utils/window */ 58201);
var _events_engine = _interopRequireDefault(__webpack_require__( /*! ../events/core/events_engine */ 55994));
var _drag = __webpack_require__( /*! ../events/drag */ 23174);
var _pointer = _interopRequireDefault(__webpack_require__( /*! ../events/pointer */ 93786));
var _index = __webpack_require__( /*! ../events/utils/index */ 39611);
var _animator = _interopRequireDefault(__webpack_require__( /*! ../ui/scroll_view/animator */ 6866));
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
function _extends() {
_extends = Object.assign ? Object.assign.bind() : 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 _typeof(obj) {
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 _defineProperty(obj, key, value) {
key = function(arg) {
var key = function(input, hint) {
if ("object" !== _typeof(input) || null === input) {
return input
}
var prim = input[Symbol.toPrimitive];
if (void 0 !== prim) {
var res = prim.call(input, hint || "default");
if ("object" !== _typeof(res)) {
return res
}
throw new TypeError("@@toPrimitive must return a primitive value.")
}
return ("string" === hint ? String : Number)(input)
}(arg, "string");
return "symbol" === _typeof(key) ? key : String(key)
}(key);
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
})
} else {
obj[key] = value
}
return obj
}
var window = (0, _window.getWindow)();
var DRAGGABLE = "dxDraggable";
var DRAGSTART_EVENT_NAME = (0, _index.addNamespace)(_drag.start, DRAGGABLE);
var DRAG_EVENT_NAME = (0, _index.addNamespace)(_drag.move, DRAGGABLE);
var DRAGEND_EVENT_NAME = (0, _index.addNamespace)(_drag.end, DRAGGABLE);
var DRAG_ENTER_EVENT_NAME = (0, _index.addNamespace)(_drag.enter, DRAGGABLE);
var DRAGEND_LEAVE_EVENT_NAME = (0, _index.addNamespace)(_drag.leave, DRAGGABLE);
var POINTERDOWN_EVENT_NAME = (0, _index.addNamespace)(_pointer.default.down, DRAGGABLE);
var KEYDOWN_EVENT_NAME = (0, _index.addNamespace)("keydown", DRAGGABLE);
var targetDraggable;
var sourceDraggable;
var getMousePosition = function(event) {
return {
x: event.pageX - (0, _renderer.default)(window).scrollLeft(),
y: event.pageY - (0, _renderer.default)(window).scrollTop()
}
};
var ScrollHelper = function() {
function ScrollHelper(orientation, component) {
this._$scrollableAtPointer = null;
this._preventScroll = true;
this._component = component;
if ("vertical" === orientation) {
this._scrollValue = "scrollTop";
this._overFlowAttr = "overflowY";
this._sizeAttr = "height";
this._scrollSizeProp = "scrollHeight";
this._clientSizeProp = "clientHeight";
this._limitProps = {
start: "top",
end: "bottom"
}
} else {
this._scrollValue = "scrollLeft";
this._overFlowAttr = "overflowX";
this._sizeAttr = "width";
this._scrollSizeProp = "scrollWidth";
this._clientSizeProp = "clientWidth";
this._limitProps = {
start: "left",
end: "right"
}
}
}
var _proto = ScrollHelper.prototype;
_proto.updateScrollable = function(elements, mousePosition) {
var _this = this;
var isScrollableFound = false;
elements.some((function(element) {
var $element = (0, _renderer.default)(element);
var isTargetOverOverlayWrapper = $element.hasClass("dx-overlay-wrapper");
var isTargetOverOverlayContent = $element.hasClass("dx-overlay-content");
if (isTargetOverOverlayWrapper || isTargetOverOverlayContent) {
return true
}
isScrollableFound = _this._trySetScrollable(element, mousePosition);
return isScrollableFound
}));
if (!isScrollableFound) {
this._$scrollableAtPointer = null;
this._scrollSpeed = 0
}
};
_proto.isScrolling = function() {
return !!this._scrollSpeed
};
_proto.isScrollable = function($element) {
return ("auto" === $element.css(this._overFlowAttr) || $element.hasClass("dx-scrollable-container")) && $element.prop(this._scrollSizeProp) > Math.ceil("width" === this._sizeAttr ? (0, _size.getWidth)($element) : (0, _size.getHeight)($element))
};
_proto._trySetScrollable = function(element, mousePosition) {
var $element = (0, _renderer.default)(element);
var distanceToBorders;
var sensitivity = this._component.option("scrollSensitivity");
var isScrollable = this.isScrollable($element);
if (isScrollable) {
distanceToBorders = this._calculateDistanceToBorders($element, mousePosition);
if (sensitivity > distanceToBorders[this._limitProps.start]) {
if (!this._preventScroll) {
this._scrollSpeed = -this._calculateScrollSpeed(distanceToBorders[this._limitProps.start]);
this._$scrollableAtPointer = $element
}
} else if (sensitivity > distanceToBorders[this._limitProps.end]) {
if (!this._preventScroll) {
this._scrollSpeed = this._calculateScrollSpeed(distanceToBorders[this._limitProps.end]);
this._$scrollableAtPointer = $element
}
} else {
isScrollable = false;
this._preventScroll = false
}
}
return isScrollable
};
_proto._calculateDistanceToBorders = function($area, mousePosition) {
var area = $area.get(0);
var areaBoundingRect;
if (area) {
areaBoundingRect = (0, _position2.getBoundingRect)(area);
return {
left: mousePosition.x - areaBoundingRect.left,
top: mousePosition.y - areaBoundingRect.top,
right: areaBoundingRect.right - mousePosition.x,
bottom: areaBoundingRect.bottom - mousePosition.y
}
}
return {}
};
_proto._calculateScrollSpeed = function(distance) {
var component = this._component;
var sensitivity = component.option("scrollSensitivity");
var maxSpeed = component.option("scrollSpeed");
return Math.ceil(Math.pow((sensitivity - distance) / sensitivity, 2) * maxSpeed)
};
_proto.scrollByStep = function() {
if (this._$scrollableAtPointer && this._scrollSpeed) {
if (this._$scrollableAtPointer.hasClass("dx-scrollable-container")) {
var $scrollable = this._$scrollableAtPointer.closest(".dx-scrollable");
var scrollableInstance = $scrollable.data("dxScrollable") || $scrollable.data("dxScrollView");
if (scrollableInstance) {
var nextScrollPosition = scrollableInstance.scrollOffset()[this._limitProps.start] + this._scrollSpeed;
scrollableInstance.scrollTo(_defineProperty({}, this._limitProps.start, nextScrollPosition))
}
} else {
var _nextScrollPosition = this._$scrollableAtPointer[this._scrollValue]() + this._scrollSpeed;
this._$scrollableAtPointer[this._scrollValue](_nextScrollPosition)
}
var dragMoveArgs = this._component._dragMoveArgs;
if (dragMoveArgs) {
this._component._dragMoveHandler(dragMoveArgs)
}
}
};
_proto.reset = function() {
this._$scrollableAtPointer = null;
this._scrollSpeed = 0;
this._preventScroll = true
};
_proto.isOutsideScrollable = function($scrollable, event) {
if (!$scrollable) {
return false
}
var scrollableSize = (0, _position2.getBoundingRect)($scrollable.get(0));
var start = scrollableSize[this._limitProps.start];
var size = scrollableSize[this._sizeAttr];
var mousePosition = getMousePosition(event);
var location = "width" === this._sizeAttr ? mousePosition.x : mousePosition.y;
return location < start || location > start + size
};
return ScrollHelper
}();
var ScrollAnimator = _animator.default.inherit({
ctor: function(strategy) {
this.callBase();
this._strategy = strategy
},
_step: function() {
var horizontalScrollHelper = this._strategy._horizontalScrollHelper;
var verticalScrollHelper = this._strategy._verticalScrollHelper;
horizontalScrollHelper && horizontalScrollHelper.scrollByStep();
verticalScrollHelper && verticalScrollHelper.scrollByStep()
}
});
var Draggable = _dom_component.default.inherit({
reset: _common.noop,
dragMove: _common.noop,
dragEnter: _common.noop,
dragLeave: _common.noop,
dragEnd: function(sourceEvent) {
var sourceDraggable = this._getSourceDraggable();
sourceDraggable._fireRemoveEvent(sourceEvent);
return (0, _deferred.Deferred)().resolve()
},
_fireRemoveEvent: _common.noop,
_getDefaultOptions: function() {
return (0, _extend.extend)(this.callBase(), {
onDragStart: null,
onDragMove: null,
onDragEnd: null,
onDragEnter: null,
onDragLeave: null,
onDragCancel: null,
onCancelByEsc: false,
onDrop: null,
immediate: true,
dragDirection: "both",
boundary: void 0,
boundOffset: 0,
allowMoveByClick: false,
itemData: null,
container: void 0,
dragTemplate: void 0,
contentTemplate: "content",
handle: "",
filter: "",
clone: false,
autoScroll: true,
scrollSpeed: 30,
scrollSensitivity: 60,
group: void 0,
data: void 0
})
},
_setOptionsByReference: function() {
this.callBase.apply(this, arguments);
(0, _extend.extend)(this._optionsByReference, {
component: true,
group: true,
itemData: true,
data: true
})
},
_init: function() {
this.callBase();
this._attachEventHandlers();
this._scrollAnimator = new ScrollAnimator(this);
this._horizontalScrollHelper = new ScrollHelper("horizontal", this);
this._verticalScrollHelper = new ScrollHelper("vertical", this);
this._initScrollTop = 0;
this._initScrollLeft = 0
},
_normalizeCursorOffset: function(offset) {
if ((0, _type.isObject)(offset)) {
offset = {
h: offset.x,
v: offset.y
}
}
offset = (0, _common.splitPair)(offset).map((function(value) {
return parseFloat(value)
}));
return {
left: offset[0],
top: 1 === offset.length ? offset[0] : offset[1]
}
},
_getNormalizedCursorOffset: function(offset, options) {
if ((0, _type.isFunction)(offset)) {
offset = offset.call(this, options)
}
return this._normalizeCursorOffset(offset)
},
_calculateElementOffset: function(options) {
var elementOffset;
var dragElementOffset;
var event = options.event;
var $element = (0, _renderer.default)(options.itemElement);
var $dragElement = (0, _renderer.default)(options.dragElement);
var isCloned = this._dragElementIsCloned();
var cursorOffset = this.option("cursorOffset");
var normalizedCursorOffset = {
left: 0,
top: 0
};
var currentLocate = this._initialLocate = (0, _translator.locate)($dragElement);
if (isCloned || options.initialOffset || cursorOffset) {
elementOffset = options.initialOffset || $element.offset();
if (cursorOffset) {
normalizedCursorOffset = this._getNormalizedCursorOffset(cursorOffset, options);
if (isFinite(normalizedCursorOffset.left)) {
elementOffset.left = event.pageX
}
if (isFinite(normalizedCursorOffset.top)) {
elementOffset.top = event.pageY
}
}
dragElementOffset = $dragElement.offset();
elementOffset.top -= dragElementOffset.top + (normalizedCursorOffset.top || 0) - currentLocate.top;
elementOffset.left -= dragElementOffset.left + (normalizedCursorOffset.left || 0) - currentLocate.left
}
return elementOffset
},
_initPosition: function(options) {
var $dragElement = (0, _renderer.default)(options.dragElement);
var elementOffset = this._calculateElementOffset(options);
if (elementOffset) {
this._move(elementOffset, $dragElement)
}
this._startPosition = (0, _translator.locate)($dragElement)
},
_startAnimator: function() {
if (!this._scrollAnimator.inProgress()) {
this._scrollAnimator.start()
}
},
_stopAnimator: function() {
this._scrollAnimator.stop()
},
_addWidgetPrefix: function(className) {
var componentName = this.NAME;
return (0, _inflector.dasherize)(componentName) + (className ? "-".concat(className) : "")
},
_getItemsSelector: function() {
return this.option("filter") || ""
},
_$content: function() {
var $element = this.$element();
var $wrapper = $element.children(".dx-template-wrapper");
return $wrapper.length ? $wrapper : $element
},
_attachEventHandlers: function() {
var _this2 = this;
if (this.option("disabled")) {
return
}
var $element = this._$content();
var itemsSelector = this._getItemsSelector();
var allowMoveByClick = this.option("allowMoveByClick");
var data = {
direction: this.option("dragDirection"),
immediate: this.option("immediate"),
checkDropTarget: function($target, event) {
var targetGroup = _this2.option("group");
var sourceGroup = _this2._getSourceDraggable().option("group");
var $scrollable = _this2._getScrollable($target);
if (_this2._verticalScrollHelper.isOutsideScrollable($scrollable, event) || _this2._horizontalScrollHelper.isOutsideScrollable($scrollable, event)) {
return false
}
return sourceGroup && sourceGroup === targetGroup
}
};
if (allowMoveByClick) {
$element = this._getArea();
_events_engine.default.on($element, POINTERDOWN_EVENT_NAME, data, this._pointerDownHandler.bind(this))
}
if (">" === itemsSelector[0]) {
itemsSelector = itemsSelector.slice(1)
}
_events_engine.default.on($element, DRAGSTART_EVENT_NAME, itemsSelector, data, this._dragStartHandler.bind(this));
_events_engine.default.on($element, DRAG_EVENT_NAME, data, this._dragMoveHandler.bind(this));
_events_engine.default.on($element, DRAGEND_EVENT_NAME, data, this._dragEndHandler.bind(this));
_events_engine.default.on($element, DRAG_ENTER_EVENT_NAME, data, this._dragEnterHandler.bind(this));
_events_engine.default.on($element, DRAGEND_LEAVE_EVENT_NAME, data, this._dragLeaveHandler.bind(this));
if (this.option("onCancelByEsc")) {
_events_engine.default.on($element, KEYDOWN_EVENT_NAME, this._keydownHandler.bind(this))
}
},
_dragElementIsCloned: function() {
return this._$dragElement && this._$dragElement.hasClass(this._addWidgetPrefix("clone"))
},
_getDragTemplateArgs: function($element, $container) {
return {
container: (0, _element.getPublicElement)($container),
model: {
itemData: this.option("itemData"),
itemElement: (0, _element.getPublicElement)($element)
}
}
},
_createDragElement: function($element) {
var result = $element;
var clone = this.option("clone");
var $container = this._getContainer();
var template = this.option("dragTemplate");
if (template) {
template = this._getTemplate(template);
result = (0, _renderer.default)(" ").appendTo($container);
template.render(this._getDragTemplateArgs($element, result))
} else if (clone) {
result = (0, _renderer.default)(" ").appendTo($container);
$element.clone().css({
width: $element.css("width"),
height: $element.css("height")
}).appendTo(result)
}
return result.toggleClass(this._addWidgetPrefix("clone"), result.get(0) !== $element.get(0)).toggleClass("dx-rtl", this.option("rtlEnabled"))
},
_resetDragElement: function() {
if (this._dragElementIsCloned()) {
this._$dragElement.remove()
} else {
this._toggleDraggingClass(false)
}
this._$dragElement = null
},
_resetSourceElement: function() {
this._toggleDragSourceClass(false);
this._$sourceElement = null
},
_detachEventHandlers: function() {
_events_engine.default.off(this._$content(), ".".concat(DRAGGABLE));
_events_engine.default.off(this._getArea(), ".".concat(DRAGGABLE))
},
_move: function(position, $element) {
(0, _translator.move)($element || this._$dragElement, position)
},
_getDraggableElement: function(e) {
var $sourceElement = this._getSourceElement();
if ($sourceElement) {
return $sourceElement
}
var allowMoveByClick = this.option("allowMoveByClick");
if (allowMoveByClick) {
return this.$element()
}
var $target = (0, _renderer.default)(e && e.target);
var itemsSelector = this._getItemsSelector();
if (">" === itemsSelector[0]) {
var $items = this._$content().find(itemsSelector);
if (!$items.is($target)) {
$target = $target.closest($items)
}
}
return $target
},
_getSourceElement: function() {
var draggable = this._getSourceDraggable();
return draggable._$sourceElement
},
_pointerDownHandler: function(e) {
if ((0, _index.needSkipEvent)(e)) {
return
}
var position = {};
var $element = this.$element();
var dragDirection = this.option("dragDirection");
if ("horizontal" === dragDirection || "both" === dragDirection) {
position.left = e.pageX - $element.offset().left + (0, _translator.locate)($element).left - (0, _size.getWidth)($element) / 2
}
if ("vertical" === dragDirection || "both" === dragDirection) {
position.top = e.pageY - $element.offset().top + (0, _translator.locate)($element).top - (0, _size.getHeight)($element) / 2
}
this._move(position, $element);
this._getAction("onDragMove")(this._getEventArgs(e))
},
_isValidElement: function(event, $element) {
var handle = this.option("handle");
var $target = (0, _renderer.default)(event.originalEvent && event.originalEvent.target);
if (handle && !$target.closest(handle).length) {
return false
}
if (!$element.length) {
return false
}
return !$element.is(".dx-state-disabled, .dx-state-disabled *")
},
_dragStartHandler: function(e) {
var $element = this._getDraggableElement(e);
this.dragInProgress = true;
if (!this._isValidElement(e, $element)) {
e.cancel = true;
return
}
if (this._$sourceElement) {
return
}
var dragStartArgs = this._getDragStartArgs(e, $element);
this._getAction("onDragStart")(dragStartArgs);
if (dragStartArgs.cancel) {
e.cancel = true;
return
}
this.option("itemData", dragStartArgs.itemData);
this._setSourceDraggable();
this._$sourceElement = $element;
var initialOffset = $element.offset();
if (!this._hasClonedDraggable() && this.option("autoScroll")) {
this._initScrollTop = this._getScrollableScrollTop();
this._initScrollLeft = this._getScrollableScrollLeft();
initialOffset = this._getDraggableElementOffset(initialOffset.left, initialOffset.top)
}
var $dragElement = this._$dragElement = this._createDragElement($element);
this._toggleDraggingClass(true);
this._toggleDragSourceClass(true);
this._setGestureCoverCursor($dragElement.children());
var isFixedPosition = "fixed" === $dragElement.css("position");
this._initPosition((0, _extend.extend)({}, dragStartArgs, {
dragElement: $dragElement.get(0),
initialOffset: isFixedPosition && initialOffset
}));
this._getAction("onDraggableElementShown")(_extends(_extends({}, dragStartArgs), {
dragElement: $dragElement
}));
var $area = this._getArea();
var areaOffset = this._getAreaOffset($area);
var boundOffset = this._getBoundOffset();
var areaWidth = (0, _size.getOuterWidth)($area);
var areaHeight = (0, _size.getOuterHeight)($area);
var elementWidth = (0, _size.getWidth)($dragElement);
var elementHeight = (0, _size.getHeight)($dragElement);
var startOffset_left = $dragElement.offset().left - areaOffset.left,
startOffset_top = $dragElement.offset().top - areaOffset.top;
if ($area.length) {
e.maxLeftOffset = startOffset_left - boundOffset.left;
e.maxRightOffset = areaWidth - startOffset_left - elementWidth - boundOffset.right;
e.maxTopOffset = startOffset_top - boundOffset.top;
e.maxBottomOffset = areaHeight - startOffset_top - elementHeight - boundOffset.bottom
}
if (this.option("autoScroll")) {
this._startAnimator()
}
},
_getAreaOffset: function($area) {
var offset = $area && _position.default.offset($area);
return offset || {
left: 0,
top: 0
}
},
_toggleDraggingClass: function(value) {
this._$dragElement && this._$dragElement.toggleClass(this._addWidgetPrefix("dragging"), value)
},
_toggleDragSourceClass: function(value, $element) {
var $sourceElement = $element || this._$sourceElement;
$sourceElement && $sourceElement.toggleClass(this._addWidgetPrefix("source"), value)
},
_setGestureCoverCursor: function($element) {
(0, _renderer.default)(".".concat("dx-gesture-cover")).css("cursor", $element.css("cursor"))
},
_getBoundOffset: function() {
var boundOffset = this.option("boundOffset");
if ((0, _type.isFunction)(boundOffset)) {
boundOffset = boundOffset.call(this)
}
return (0, _string.quadToObject)(boundOffset)
},
_getArea: function() {
var area = this.option("boundary");
if ((0, _type.isFunction)(area)) {
area = area.call(this)
}
return (0, _renderer.default)(area)
},
_getContainer: function() {
var container = this.option("container");
if (void 0 === container) {
container = (0, _view_port.value)()
}
return (0, _renderer.default)(container)
},
_getDraggableElementOffset: function(initialOffsetX, initialOffsetY) {
var _a, _b, _c, _d;
var initScrollTop = this._initScrollTop;
var initScrollLeft = this._initScrollLeft;
var scrollTop = this._getScrollableScrollTop();
var scrollLeft = this._getScrollableScrollLeft();
var elementPosition = (0, _renderer.default)(this.element()).css("position");
var isFixedPosition = "fixed" === elementPosition;
var result = {
left: (null !== (_b = null === (_a = this._startPosition) || void 0 === _a ? void 0 : _a.left) && void 0 !== _b ? _b : 0) + initialOffsetX,
top: (null !== (_d = null === (_c = this._startPosition) || void 0 === _c ? void 0 : _c.top) && void 0 !== _d ? _d : 0) + initialOffsetY
};
if (isFixedPosition || this._hasClonedDraggable()) {
return result
}
return {
left: (0, _type.isNumeric)(scrollLeft) ? result.left + scrollLeft - initScrollLeft : result.left,
top: (0, _type.isNumeric)(scrollTop) ? result.top + scrollTop - initScrollTop : result.top
}
},
_hasClonedDraggable: function() {
return this.option("clone") || this.option("dragTemplate")
},
_dragMoveHandler: function(e) {
this._dragMoveArgs = e;
if (!this._$dragElement) {
e.cancel = true;
return
}
var offset = this._getDraggableElementOffset(e.offset.x, e.offset.y);
this._move(offset);
this._updateScrollable(e);
var eventArgs = this._getEventArgs(e);
this._getAction("onDragMove")(eventArgs);
if (true === eventArgs.cancel) {
return
}
var targetDraggable = this._getTargetDraggable();
targetDraggable.dragMove(e, scrollBy)
},
_updateScrollable: function(e) {
if (this.option("autoScroll")) {
var mousePosition = getMousePosition(e);
var allObjects = _dom_adapter.default.elementsFromPoint(mousePosition.x, mousePosition.y, this.$element().get(0));
this._verticalScrollHelper.updateScrollable(allObjects, mousePosition);
this._horizontalScrollHelper.updateScrollable(allObjects, mousePosition)
}
},
_getScrollable: function($element) {
var _this3 = this;
var $scrollable;
$element.parents().toArray().some((function(parent) {
var $parent = (0, _renderer.default)(parent);
if (_this3._horizontalScrollHelper.isScrollable($parent) || _this3._verticalScrollHelper.isScrollable($parent)) {
$scrollable = $parent;
return true
}
return false
}));
return $scrollable
},
_getScrollableScrollTop: function() {
var _a, _b;
return null !== (_b = null === (_a = this._getScrollable((0, _renderer.default)(this.element()))) || void 0 === _a ? void 0 : _a.scrollTop()) && void 0 !== _b ? _b : 0
},
_getScrollableScrollLeft: function() {
var _a, _b;
return null !== (_b = null === (_a = this._getScrollable((0, _renderer.default)(this.element()))) || void 0 === _a ? void 0 : _a.scrollLeft()) && void 0 !== _b ? _b : 0
},
_defaultActionArgs: function() {
var args = this.callBase.apply(this, arguments);
var component = this.option("component");
if (component) {
args.component = component;
args.element = component.element()
}
return args
},
_getEventArgs: function(e) {
var sourceDraggable = this._getSourceDraggable();
var targetDraggable = this._getTargetDraggable();
return {
event: e,
itemData: sourceDraggable.option("itemData"),
itemElement: (0, _element.getPublicElement)(sourceDraggable._$sourceElement),
fromComponent: sourceDraggable.option("component") || sourceDraggable,
toComponent: targetDraggable.option("component") || targetDraggable,
fromData: sourceDraggable.option("data"),
toData: targetDraggable.option("data")
}
},
_getDragStartArgs: function(e, $itemElement) {
var args = this._getEventArgs(e);
return {
event: args.event,
itemData: args.itemData,
itemElement: $itemElement,
fromData: args.fromData
}
},
_revertItemToInitialPosition: function() {
!this._dragElementIsCloned() && this._move(this._initialLocate, this._$sourceElement)
},
_dragEndHandler: function(e) {
var _this4 = this;
var d = (0, _deferred.Deferred)();
var dragEndEventArgs = this._getEventArgs(e);
var dropEventArgs = this._getEventArgs(e);
var targetDraggable = this._getTargetDraggable();
var needRevertPosition = true;
this.dragInProgress = false;
try {
this._getAction("onDragEnd")(dragEndEventArgs)
} finally {
(0, _deferred.when)((0, _deferred.fromPromise)(dragEndEventArgs.cancel)).done((function(cancel) {
if (!cancel) {
if (targetDraggable !== _this4) {
targetDraggable._getAction("onDrop")(dropEventArgs)
}
if (!dropEventArgs.cancel) {
needRevertPosition = false;
(0, _deferred.when)((0, _deferred.fromPromise)(targetDraggable.dragEnd(dragEndEventArgs))).always(d.resolve);
return
}
}
d.resolve()
})).fail(d.resolve);
d.done((function() {
if (needRevertPosition) {
_this4._revertItemToInitialPosition()
}
_this4._resetDragOptions(targetDraggable)
}))
}
},
_isTargetOverAnotherDraggable: function(e) {
var _this5 = this;
var sourceDraggable = this._getSourceDraggable();
if (this === sourceDraggable) {
return false
}
var $dragElement = sourceDraggable._$dragElement;
var $sourceDraggableElement = sourceDraggable.$element();
var $targetDraggableElement = this.$element();
var mousePosition = getMousePosition(e);
var elements = _dom_adapter.default.elementsFromPoint(mousePosition.x, mousePosition.y, this.element());
var firstWidgetElement = elements.filter((function(element) {
var $element = (0, _renderer.default)(element);
if ($element.hasClass(_this5._addWidgetPrefix())) {
return !$element.closest($dragElement).length
}
return false
}))[0];
var $sourceElement = this._getSourceElement();
var isTargetOverItself = firstWidgetElement === $sourceDraggableElement.get(0);
var isTargetOverNestedDraggable = (0, _renderer.default)(firstWidgetElement).closest($sourceElement).length;
return !firstWidgetElement || firstWidgetElement === $targetDraggableElement.get(0) && !isTargetOverItself && !isTargetOverNestedDraggable
},
_dragEnterHandler: function(e) {
this._fireDragEnterEvent(e);
if (this._isTargetOverAnotherDraggable(e)) {
this._setTargetDraggable()
}
var sourceDraggable = this._getSourceDraggable();
sourceDraggable.dragEnter(e)
},
_dragLeaveHandler: function(e) {
this._fireDragLeaveEvent(e);
this._resetTargetDraggable();
if (this !== this._getSourceDraggable()) {
this.reset()
}
var sourceDraggable = this._getSourceDraggable();
sourceDraggable.dragLeave(e)
},
_keydownHandler: function(e) {
if (this.dragInProgress && "Escape" === e.key) {
this._keydownEscapeHandler(e)
}
},
_keydownEscapeHandler: function(e) {
var $sourceElement = this._getSourceElement();
if (!$sourceElement) {
return
}
var dragCancelEventArgs = this._getEventArgs(e);
this._getAction("onDragCancel")(dragCancelEventArgs);
if (dragCancelEventArgs.cancel) {
return
}
this.dragInProgress = false;
null === sourceDraggable || void 0 === sourceDraggable ? void 0 : sourceDraggable._toggleDraggingClass(false);
this._detachEventHandlers();
this._revertItemToInitialPosition();
var targetDraggable = this._getTargetDraggable();
this._resetDragOptions(targetDraggable);
this._attachEventHandlers()
},
_getAction: function(name) {
return this["_".concat(name, "Action")] || this._createActionByOption(name)
},
_getAnonymousTemplateName: function() {
return "content"
},
_initTemplates: function() {
if (!this.option("contentTemplate")) {
return
}
this._templateManager.addDefaultTemplates({
content: new _empty_template.EmptyTemplate
});
this.callBase.apply(this, arguments)
},
_render: function() {
this.callBase();
this.$element().addClass(this._addWidgetPrefix());
var transclude = this._templateManager.anonymousTemplateName === this.option("contentTemplate");
var template = this._getTemplateByOption("contentTemplate");
if (template) {
(0, _renderer.default)(template.render({
container: this.element(),
transclude: transclude
}))
}
},
_optionChanged: function(args) {
var name = args.name;
switch (name) {
case "onDragStart":
case "onDragMove":
case "onDragEnd":
case "onDrop":
case "onDragEnter":
case "onDragLeave":
case "onDragCancel":
case "onDraggableElementShown":
this["_".concat(name, "Action")] = this._createActionByOption(name);
break;
case "dragTemplate":
case "contentTemplate":
case "container":
case "clone":
break;
case "allowMoveByClick":
case "dragDirection":
case "disabled":
case "boundary":
case "filter":
case "immediate":
this._resetDragElement();
this._detachEventHandlers();
this._attachEventHandlers();
break;
case "onCancelByEsc":
this._keydownHandler();
break;
case "autoScroll":
this._verticalScrollHelper.reset();
this._horizontalScrollHelper.reset();
break;
case "scrollSensitivity":
case "scrollSpeed":
case "boundOffset":
case "handle":
case "group":
case "data":
case "itemData":
break;
default:
this.callBase(args)
}
},
_getTargetDraggable: function() {
return targetDraggable || this
},
_getSourceDraggable: function() {
return sourceDraggable || this
},
_setTargetDraggable: function() {
var currentGroup = this.option("group");
var sourceDraggable = this._getSourceDraggable();
if (currentGroup && currentGroup === sourceDraggable.option("group")) {
targetDraggable = this
}
},
_setSourceDraggable: function() {
sourceDraggable = this
},
_resetSourceDraggable: function() {
sourceDraggable = null
},
_resetTargetDraggable: function() {
targetDraggable = null
},
_resetDragOptions: function(targetDraggable) {
this.reset();
targetDraggable.reset();
this._stopAnimator();
this._horizontalScrollHelper.reset();
this._verticalScrollHelper.reset();
this._resetDragElement();
this._resetSourceElement();
this._resetTargetDraggable();
this._resetSourceDraggable()
},
_dispose: function() {
this.callBase();
this._detachEventHandlers();
this._resetDragElement();
this._resetTargetDraggable();
this._resetSourceDraggable();
this._$sourceElement = null;
this._stopAnimator()
},
_fireDragEnterEvent: function(sourceEvent) {
var args = this._getEventArgs(sourceEvent);
this._getAction("onDragEnter")(args)
},
_fireDragLeaveEvent: function(sourceEvent) {
var args = this._getEventArgs(sourceEvent);
this._getAction("onDragLeave")(args)
}
});
(0, _component_registrator.default)(DRAGGABLE, Draggable);
var _default = Draggable;
exports.default = _default
},
75500:
/*!**********************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/m_sortable.js ***!
\**********************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _fx = _interopRequireDefault(__webpack_require__( /*! ../animation/fx */ 87209));
var _translator = __webpack_require__( /*! ../animation/translator */ 31648);
var _component_registrator = _interopRequireDefault(__webpack_require__( /*! ../core/component_registrator */ 99393));
var _element = __webpack_require__( /*! ../core/element */ 6415);
var _renderer = _interopRequireDefault(__webpack_require__( /*! ../core/renderer */ 68374));
var _deferred = __webpack_require__( /*! ../core/utils/deferred */ 62754);
var _extend = __webpack_require__( /*! ../core/utils/extend */ 13306);
var _position = __webpack_require__( /*! ../core/utils/position */ 37518);
var _size = __webpack_require__( /*! ../core/utils/size */ 58664);
var _window = __webpack_require__( /*! ../core/utils/window */ 58201);
var _events_engine = _interopRequireDefault(__webpack_require__( /*! ../events/core/events_engine */ 55994));
var _m_draggable = _interopRequireDefault(__webpack_require__( /*! ./m_draggable */ 86988));
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
function _typeof(obj) {
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 _defineProperty(obj, key, value) {
key = function(arg) {
var key = function(input, hint) {
if ("object" !== _typeof(input) || null === input) {
return input
}
var prim = input[Symbol.toPrimitive];
if (void 0 !== prim) {
var res = prim.call(input, hint || "default");
if ("object" !== _typeof(res)) {
return res
}
throw new TypeError("@@toPrimitive must return a primitive value.")
}
return ("string" === hint ? String : Number)(input)
}(arg, "string");
return "symbol" === _typeof(key) ? key : String(key)
}(key);
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
})
} else {
obj[key] = value
}
return obj
}
var window = (0, _window.getWindow)();
var isElementVisible = function(itemElement) {
return (0, _renderer.default)(itemElement).is(":visible")
};
var animate = function(element, config) {
var _a, _b;
if (!element) {
return
}
var left = (null === (_a = config.to) || void 0 === _a ? void 0 : _a.left) || 0;
var top = (null === (_b = config.to) || void 0 === _b ? void 0 : _b.top) || 0;
element.style.transform = "translate(".concat(left, "px,").concat(top, "px)");
element.style.transition = _fx.default.off ? "" : "transform ".concat(config.duration, "ms ").concat(config.easing)
};
var stopAnimation = function(element) {
if (!element) {
return
}
element.style.transform = "";
element.style.transition = ""
};
var Sortable = _m_draggable.default.inherit({
_init: function() {
this.callBase();
this._sourceScrollHandler = this._handleSourceScroll.bind(this);
this._sourceScrollableInfo = null
},
_getDefaultOptions: function() {
return (0, _extend.extend)(this.callBase(), {
clone: true,
filter: "> *",
itemOrientation: "vertical",
dropFeedbackMode: "push",
allowDropInsideItem: false,
allowReordering: true,
moveItemOnDrop: false,
onDragChange: null,
onAdd: null,
onRemove: null,
onReorder: null,
onPlaceholderPrepared: null,
animation: {
type: "slide",
duration: 300,
easing: "ease"
},
fromIndex: null,
toIndex: null,
dropInsideItem: false,
itemPoints: null,
fromIndexOffset: 0,
offset: 0,
autoUpdate: false,
draggableElementSize: 0
})
},
reset: function() {
this.option({
dropInsideItem: false,
toIndex: null,
fromIndex: null,
itemPoints: null,
fromIndexOffset: 0,
draggableElementSize: 0
});
if (this._$placeholderElement) {
this._$placeholderElement.remove()
}
this._$placeholderElement = null;
if (!this._isIndicateMode() && this._$modifiedItem) {
this._$modifiedItem.css("marginBottom", this._modifiedItemMargin);
this._$modifiedItem = null
}
},
_getPrevVisibleItem: function(items, index) {
return items.slice(0, index).reverse().filter(isElementVisible)[0]
},
_dragStartHandler: function(e) {
this.callBase.apply(this, arguments);
if (true === e.cancel) {
return
}
var $sourceElement = this._getSourceElement();
this._updateItemPoints();
this._subscribeToSourceScroll(e);
this.option("fromIndex", this._getElementIndex($sourceElement));
this.option("fromIndexOffset", this.option("offset"))
},
_subscribeToSourceScroll: function(e) {
var $scrollable = this._getScrollable((0, _renderer.default)(e.target));
if ($scrollable) {
this._sourceScrollableInfo = {
element: $scrollable,
scrollLeft: $scrollable.scrollLeft(),
scrollTop: $scrollable.scrollTop()
};
_events_engine.default.off($scrollable, "scroll", this._sourceScrollHandler);
_events_engine.default.on($scrollable, "scroll", this._sourceScrollHandler)
}
},
_unsubscribeFromSourceScroll: function() {
if (this._sourceScrollableInfo) {
_events_engine.default.off(this._sourceScrollableInfo.element, "scroll", this._sourceScrollHandler);
this._sourceScrollableInfo = null
}
},
_handleSourceScroll: function(e) {
var _this = this;
var sourceScrollableInfo = this._sourceScrollableInfo;
if (sourceScrollableInfo) {
["scrollLeft", "scrollTop"].forEach((function(scrollProp) {
if (e.target[scrollProp] !== sourceScrollableInfo[scrollProp]) {
var scrollBy = e.target[scrollProp] - sourceScrollableInfo[scrollProp];
_this._correctItemPoints(scrollBy);
_this._movePlaceholder();
sourceScrollableInfo[scrollProp] = e.target[scrollProp]
}
}))
}
},
_dragEnterHandler: function(e) {
this.callBase.apply(this, arguments);
if (this === this._getSourceDraggable()) {
return
}
this._subscribeToSourceScroll(e);
this._updateItemPoints();
this.option("fromIndex", -1);
if (!this._isIndicateMode()) {
var itemPoints = this.option("itemPoints");
var lastItemPoint = itemPoints[itemPoints.length - 1];
if (lastItemPoint) {
var $element = this.$element();
var $sourceElement = this._getSourceElement();
var isVertical = this._isVerticalOrientation();
var sourceElementSize = isVertical ? (0, _size.getOuterHeight)($sourceElement, true) : (0, _size.getOuterWidth)($sourceElement, true);
var scrollSize = $element.get(0)[isVertical ? "scrollHeight" : "scrollWidth"];
var scrollPosition = $element.get(0)[isVertical ? "scrollTop" : "scrollLeft"];
var positionProp = isVertical ? "top" : "left";
var lastPointPosition = lastItemPoint[positionProp];
var elementPosition = $element.offset()[positionProp];
var freeSize = elementPosition + scrollSize - scrollPosition - lastPointPosition;
if (freeSize < sourceElementSize) {
if (isVertical) {
var items = this._getItems();
var $lastItem = (0, _renderer.default)(this._getPrevVisibleItem(items));
this._$modifiedItem = $lastItem;
this._modifiedItemMargin = $lastItem.get(0).style.marginBottom;
$lastItem.css("marginBottom", sourceElementSize - freeSize);
var $sortable = $lastItem.closest(".dx-sortable");
var sortable = $sortable.data("dxScrollable") || $sortable.data("dxScrollView");
sortable && sortable.update()
}
}
}
}
},
_dragLeaveHandler: function() {
this.callBase.apply(this, arguments);
if (this !== this._getSourceDraggable()) {
this._unsubscribeFromSourceScroll()
}
},
dragEnter: function() {
if (this !== this._getTargetDraggable()) {
this.option("toIndex", -1)
}
},
dragLeave: function() {
if (this !== this._getTargetDraggable()) {
this.option("toIndex", this.option("fromIndex"))
}
},
_allowDrop: function(event) {
var targetDraggable = this._getTargetDraggable();
var $targetDraggable = targetDraggable.$element();
var $scrollable = this._getScrollable($targetDraggable);
if ($scrollable) {
var _getScrollableBoundar = function($scrollable) {
var offset = $scrollable.offset();
var style = $scrollable[0].style;
var paddingLeft = parseFloat(style.paddingLeft) || 0;
var paddingRight = parseFloat(style.paddingRight) || 0;
var paddingTop = parseFloat(style.paddingTop) || 0;
var width = $scrollable[0].clientWidth - (paddingLeft + paddingRight);
var height = (0, _size.getHeight)($scrollable);
var left = offset.left + paddingLeft;
var top = offset.top + paddingTop;
return {
left: left,
right: left + width,
top: top,
bottom: top + height
}
}($scrollable),
left = _getScrollableBoundar.left,
right = _getScrollableBoundar.right,
top = _getScrollableBoundar.top,
bottom = _getScrollableBoundar.bottom;
var toIndex = this.option("toIndex");
var itemPoints = this.option("itemPoints");
var itemPoint = null === itemPoints || void 0 === itemPoints ? void 0 : itemPoints.filter((function(item) {
return item.index === toIndex
}))[0];
if (itemPoint && void 0 !== itemPoint.top) {
var isVertical = this._isVerticalOrientation();
if (isVertical) {
return top <= Math.ceil(itemPoint.top) && Math.floor(itemPoint.top) <= bottom
}
return left <= Math.ceil(itemPoint.left) && Math.floor(itemPoint.left) <= right
}
}
return true
},
dragEnd: function(sourceEvent) {
this._unsubscribeFromSourceScroll();
var $sourceElement = this._getSourceElement();
var sourceDraggable = this._getSourceDraggable();
var isSourceDraggable = sourceDraggable.NAME !== this.NAME;
var toIndex = this.option("toIndex");
var event = sourceEvent.event;
var allowDrop = this._allowDrop(event);
if (null !== toIndex && toIndex >= 0 && allowDrop) {
var cancelAdd;
var cancelRemove;
if (sourceDraggable !== this) {
cancelAdd = this._fireAddEvent(event);
if (!cancelAdd) {
cancelRemove = this._fireRemoveEvent(event)
}
}
if (isSourceDraggable) {
(0, _translator.resetPosition)($sourceElement)
}
if (this.option("moveItemOnDrop")) {
!cancelAdd && this._moveItem($sourceElement, toIndex, cancelRemove)
}
if (sourceDraggable === this) {
return this._fireReorderEvent(event)
}
}
return (0, _deferred.Deferred)().resolve()
},
dragMove: function(e) {
var itemPoints = this.option("itemPoints");
if (!itemPoints) {
return
}
var isVertical = this._isVerticalOrientation();
var axisName = isVertical ? "top" : "left";
var cursorPosition = isVertical ? e.pageY : e.pageX;
var rtlEnabled = this.option("rtlEnabled");
var itemPoint;
for (var i = itemPoints.length - 1; i >= 0; i--) {
var centerPosition = itemPoints[i + 1] && (itemPoints[i][axisName] + itemPoints[i + 1][axisName]) / 2;
if ((!isVertical && rtlEnabled ? cursorPosition > centerPosition : centerPosition > cursorPosition) || void 0 === centerPosition) {
itemPoint = itemPoints[i]
} else {
break
}
}
if (itemPoint) {
this._updatePlaceholderPosition(e, itemPoint);
if (this._verticalScrollHelper.isScrolling() && this._isIndicateMode()) {
this._movePlaceholder()
}
}
},
_isIndicateMode: function() {
return "indicate" === this.option("dropFeedbackMode") || this.option("allowDropInsideItem")
},
_createPlaceholder: function() {
var $placeholderContainer;
if (this._isIndicateMode()) {
$placeholderContainer = (0, _renderer.default)(" ").addClass(this._addWidgetPrefix("placeholder")).insertBefore(this._getSourceDraggable()._$dragElement)
}
this._$placeholderElement = $placeholderContainer;
return $placeholderContainer
},
_getItems: function() {
var itemsSelector = this._getItemsSelector();
return this._$content().find(itemsSelector).not(".".concat(this._addWidgetPrefix("placeholder"))).not(".".concat(this._addWidgetPrefix("clone"))).toArray()
},
_allowReordering: function() {
var sourceDraggable = this._getSourceDraggable();
var targetDraggable = this._getTargetDraggable();
return sourceDraggable !== targetDraggable || this.option("allowReordering")
},
_isValidPoint: function(visibleIndex, draggableVisibleIndex, dropInsideItem) {
var allowDropInsideItem = this.option("allowDropInsideItem");
var allowReordering = dropInsideItem || this._allowReordering();
if (!allowReordering && (0 !== visibleIndex || !allowDropInsideItem)) {
return false
}
if (!this._isIndicateMode()) {
return true
}
return -1 === draggableVisibleIndex || visibleIndex !== draggableVisibleIndex && (dropInsideItem || visibleIndex !== draggableVisibleIndex + 1)
},
_getItemPoints: function() {
var result = [];
var $item;
var offset;
var itemWidth;
var rtlEnabled = this.option("rtlEnabled");
var isVertical = this._isVerticalOrientation();
var itemElements = this._getItems();
var visibleItemElements = itemElements.filter(isElementVisible);
var visibleItemCount = visibleItemElements.length;
var $draggableItem = this._getDraggableElement();
var draggableVisibleIndex = visibleItemElements.indexOf($draggableItem.get(0));
if (visibleItemCount) {
for (var i = 0; i <= visibleItemCount; i++) {
var needCorrectLeftPosition = !isVertical && rtlEnabled ^ i === visibleItemCount;
var needCorrectTopPosition = isVertical && i === visibleItemCount;
if (i < visibleItemCount) {
$item = (0, _renderer.default)(visibleItemElements[i]);
offset = $item.offset();
itemWidth = (0, _size.getOuterWidth)($item)
}
result.push({
dropInsideItem: false,
left: offset.left + (needCorrectLeftPosition ? itemWidth : 0),
top: offset.top + (needCorrectTopPosition ? result[i - 1].height : 0),
index: i === visibleItemCount ? itemElements.length : itemElements.indexOf($item.get(0)),
$item: $item,
width: (0, _size.getOuterWidth)($item),
height: (0, _size.getOuterHeight)($item),
isValid: this._isValidPoint(i, draggableVisibleIndex)
})
}
if (this.option("allowDropInsideItem")) {
var points = result;
result = [];
for (var _i = 0; _i < points.length; _i++) {
result.push(points[_i]);
if (points[_i + 1]) {
result.push((0, _extend.extend)({}, points[_i], {
dropInsideItem: true,
top: Math.floor((points[_i].top + points[_i + 1].top) / 2),
left: Math.floor((points[_i].left + points[_i + 1].left) / 2),
isValid: this._isValidPoint(_i, draggableVisibleIndex, true)
}))
}
}
}
} else {
result.push({
dropInsideItem: false,
index: 0,
isValid: true
})
}
return result
},
_updateItemPoints: function(forceUpdate) {
if (forceUpdate || this.option("autoUpdate") || !this.option("itemPoints")) {
this.option("itemPoints", this._getItemPoints())
}
},
_correctItemPoints: function(scrollBy) {
var itemPoints = this.option("itemPoints");
if (scrollBy && itemPoints && !this.option("autoUpdate")) {
var isVertical = this._isVerticalOrientation();
var positionPropName = isVertical ? "top" : "left";
itemPoints.forEach((function(itemPoint) {
itemPoint[positionPropName] -= scrollBy
}))
}
},
_getElementIndex: function($itemElement) {
return this._getItems().indexOf($itemElement.get(0))
},
_getDragTemplateArgs: function($element) {
var args = this.callBase.apply(this, arguments);
args.model.fromIndex = this._getElementIndex($element);
return args
},
_togglePlaceholder: function(value) {
this._$placeholderElement && this._$placeholderElement.toggle(value)
},
_isVerticalOrientation: function() {
return "vertical" === this.option("itemOrientation")
},
_normalizeToIndex: function(toIndex, skipOffsetting) {
var isAnotherDraggable = this._getSourceDraggable() !== this._getTargetDraggable();
var fromIndex = this._getActualFromIndex();
if (null === toIndex) {
return fromIndex
}
return Math.max(isAnotherDraggable || fromIndex >= toIndex || skipOffsetting ? toIndex : toIndex - 1, 0)
},
_updatePlaceholderPosition: function(e, itemPoint) {
var sourceDraggable = this._getSourceDraggable();
var toIndex = this._normalizeToIndex(itemPoint.index, itemPoint.dropInsideItem);
var eventArgs = (0, _extend.extend)(this._getEventArgs(e), {
toIndex: toIndex,
dropInsideItem: itemPoint.dropInsideItem
});
itemPoint.isValid && this._getAction("onDragChange")(eventArgs);
if (eventArgs.cancel || !itemPoint.isValid) {
if (!itemPoint.isValid) {
this.option({
dropInsideItem: false,
toIndex: null
})
}
return
}
this.option({
dropInsideItem: itemPoint.dropInsideItem,
toIndex: itemPoint.index
});
this._getAction("onPlaceholderPrepared")((0, _extend.extend)(this._getEventArgs(e), {
placeholderElement: (0, _element.getPublicElement)(this._$placeholderElement),
dragElement: (0, _element.getPublicElement)(sourceDraggable._$dragElement)
}));
this._updateItemPoints()
},
_makeWidthCorrection: function($item, width) {
this._$scrollable = this._getScrollable($item);
if (this._$scrollable) {
var scrollableWidth = (0, _size.getWidth)(this._$scrollable);
var overflowLeft = this._$scrollable.offset().left - $item.offset().left;
var overflowRight = (0, _size.getOuterWidth)($item) - overflowLeft - scrollableWidth;
if (overflowLeft > 0) {
width -= overflowLeft
}
if (overflowRight > 0) {
width -= overflowRight
}
}
return width
},
_updatePlaceholderSizes: function($placeholderElement, itemElement) {
var dropInsideItem = this.option("dropInsideItem");
var $item = (0, _renderer.default)(itemElement);
var isVertical = this._isVerticalOrientation();
var width = "";
var height = "";
$placeholderElement.toggleClass(this._addWidgetPrefix("placeholder-inside"), dropInsideItem);
if (isVertical || dropInsideItem) {
width = (0, _size.getOuterWidth)($item)
}
if (!isVertical || dropInsideItem) {
height = (0, _size.getOuterHeight)($item)
}
width = this._makeWidthCorrection($item, width);
$placeholderElement.css({
width: width,
height: height
})
},
_moveItem: function($itemElement, index, cancelRemove) {
var $prevTargetItemElement;
var $itemElements = this._getItems();
var $targetItemElement = $itemElements[index];
var sourceDraggable = this._getSourceDraggable();
if (cancelRemove) {
$itemElement = $itemElement.clone();
sourceDraggable._toggleDragSourceClass(false, $itemElement)
}
if (!$targetItemElement) {
$prevTargetItemElement = $itemElements[index - 1]
}
this._moveItemCore($itemElement, $targetItemElement, $prevTargetItemElement)
},
_moveItemCore: function($targetItem, item, prevItem) {
if (!item && !prevItem) {
$targetItem.appendTo(this.$element())
} else if (prevItem) {
$targetItem.insertAfter((0, _renderer.default)(prevItem))
} else {
$targetItem.insertBefore((0, _renderer.default)(item))
}
},
_getDragStartArgs: function(e, $itemElement) {
return (0, _extend.extend)(this.callBase.apply(this, arguments), {
fromIndex: this._getElementIndex($itemElement)
})
},
_getEventArgs: function(e) {
var sourceDraggable = this._getSourceDraggable();
var targetDraggable = this._getTargetDraggable();
var dropInsideItem = targetDraggable.option("dropInsideItem");
return (0, _extend.extend)(this.callBase.apply(this, arguments), {
fromIndex: sourceDraggable.option("fromIndex"),
toIndex: this._normalizeToIndex(targetDraggable.option("toIndex"), dropInsideItem),
dropInsideItem: dropInsideItem
})
},
_optionChanged: function(args) {
var _this2 = this;
var name = args.name;
switch (name) {
case "onDragChange":
case "onPlaceholderPrepared":
case "onAdd":
case "onRemove":
case "onReorder":
this["_".concat(name, "Action")] = this._createActionByOption(name);
break;
case "itemOrientation":
case "allowDropInsideItem":
case "moveItemOnDrop":
case "dropFeedbackMode":
case "itemPoints":
case "animation":
case "allowReordering":
case "fromIndexOffset":
case "offset":
case "draggableElementSize":
case "autoUpdate":
break;
case "fromIndex":
[false, true].forEach((function(isDragSource) {
var fromIndex = isDragSource ? args.value : args.previousValue;
if (null !== fromIndex) {
var $fromElement = (0, _renderer.default)(_this2._getItems()[fromIndex]);
_this2._toggleDragSourceClass(isDragSource, $fromElement)
}
}));
break;
case "dropInsideItem":
this._optionChangedDropInsideItem(args);
break;
case "toIndex":
this._optionChangedToIndex(args);
break;
default:
this.callBase(args)
}
},
_optionChangedDropInsideItem: function() {
if (this._isIndicateMode() && this._$placeholderElement) {
this._movePlaceholder()
}
},
_isPositionVisible: function(position) {
var $element = this.$element();
var scrollContainer;
if ("hidden" !== $element.css("overflow")) {
scrollContainer = $element.get(0)
} else {
$element.parents().each((function() {
if ("visible" !== (0, _renderer.default)(this).css("overflow")) {
scrollContainer = this;
return false
}
return
}))
}
if (scrollContainer) {
var clientRect = (0, _position.getBoundingRect)(scrollContainer);
var isVerticalOrientation = this._isVerticalOrientation();
var start = isVerticalOrientation ? "top" : "left";
var end = isVerticalOrientation ? "bottom" : "right";
var pageOffset = isVerticalOrientation ? window.pageYOffset : window.pageXOffset;
if (position[start] < clientRect[start] + pageOffset || position[start] > clientRect[end] + pageOffset) {
return false
}
}
return true
},
_optionChangedToIndex: function(args) {
var toIndex = args.value;
if (this._isIndicateMode()) {
var showPlaceholder = null !== toIndex && toIndex >= 0;
this._togglePlaceholder(showPlaceholder);
if (showPlaceholder) {
this._movePlaceholder()
}
} else {
this._moveItems(args.previousValue, args.value, args.fullUpdate)
}
},
update: function() {
if (null === this.option("fromIndex") && null === this.option("toIndex")) {
return
}
this._updateItemPoints(true);
this._updateDragSourceClass();
var toIndex = this.option("toIndex");
this._optionChangedToIndex({
value: toIndex,
fullUpdate: true
})
},
_updateDragSourceClass: function() {
var fromIndex = this._getActualFromIndex();
var $fromElement = (0, _renderer.default)(this._getItems()[fromIndex]);
if ($fromElement.length) {
this._$sourceElement = $fromElement;
this._toggleDragSourceClass(true, $fromElement)
}
},
_makeLeftCorrection: function(left) {
var $scrollable = this._$scrollable;
if ($scrollable && this._isVerticalOrientation()) {
var overflowLeft = $scrollable.offset().left - left;
if (overflowLeft > 0) {
left += overflowLeft
}
}
return left
},
_movePlaceholder: function() {
var $placeholderElement = this._$placeholderElement || this._createPlaceholder();
if (!$placeholderElement) {
return
}
var items = this._getItems();
var toIndex = this.option("toIndex");
var isVerticalOrientation = this._isVerticalOrientation();
var rtlEnabled = this.option("rtlEnabled");
var dropInsideItem = this.option("dropInsideItem");
var position = null;
var itemElement = items[toIndex];
if (itemElement) {
var $itemElement = (0, _renderer.default)(itemElement);
position = $itemElement.offset();
if (!isVerticalOrientation && rtlEnabled && !dropInsideItem) {
position.left += (0, _size.getOuterWidth)($itemElement, true)
}
} else {
var prevVisibleItemElement = itemElement = this._getPrevVisibleItem(items, toIndex);
if (prevVisibleItemElement) {
position = (0, _renderer.default)(prevVisibleItemElement).offset();
if (isVerticalOrientation) {
position.top += (0, _size.getOuterHeight)(prevVisibleItemElement, true)
} else if (!rtlEnabled) {
position.left += (0, _size.getOuterWidth)(prevVisibleItemElement, true)
}
}
}
this._updatePlaceholderSizes($placeholderElement, itemElement);
if (position && !this._isPositionVisible(position)) {
position = null
}
if (position) {
var isLastVerticalPosition = isVerticalOrientation && toIndex === items.length;
var outerPlaceholderHeight = (0, _size.getOuterHeight)($placeholderElement);
position.left = this._makeLeftCorrection(position.left);
position.top = isLastVerticalPosition && position.top >= outerPlaceholderHeight ? position.top - outerPlaceholderHeight : position.top;
this._move(position, $placeholderElement)
}
$placeholderElement.toggle(!!position)
},
_getPositions: function(items, elementSize, fromIndex, toIndex) {
var positions = [];
for (var i = 0; i < items.length; i++) {
var position = 0;
if (null === toIndex || null === fromIndex) {
positions.push(position);
continue
}
if (-1 === fromIndex) {
if (i >= toIndex) {
position = elementSize
}
} else if (-1 === toIndex) {
if (i > fromIndex) {
position = -elementSize
}
} else if (fromIndex < toIndex) {
if (i > fromIndex && i < toIndex) {
position = -elementSize
}
} else if (fromIndex > toIndex) {
if (i >= toIndex && i < fromIndex) {
position = elementSize
}
}
positions.push(position)
}
return positions
},
_getDraggableElementSize: function(isVerticalOrientation) {
var $draggableItem = this._getDraggableElement();
var size = this.option("draggableElementSize");
if (!size) {
size = isVerticalOrientation ? ((0, _size.getOuterHeight)($draggableItem) + (0, _size.getOuterHeight)($draggableItem, true)) / 2 : ((0, _size.getOuterWidth)($draggableItem) + (0, _size.getOuterWidth)($draggableItem, true)) / 2;
if (!this.option("autoUpdate")) {
this.option("draggableElementSize", size)
}
}
return size
},
_getActualFromIndex: function() {
var _this$option = this.option(),
fromIndex = _this$option.fromIndex,
fromIndexOffset = _this$option.fromIndexOffset,
offset = _this$option.offset;
return null == fromIndex ? null : fromIndex + fromIndexOffset - offset
},
_moveItems: function(prevToIndex, toIndex, fullUpdate) {
var fromIndex = this._getActualFromIndex();
var isVerticalOrientation = this._isVerticalOrientation();
var positionPropName = isVerticalOrientation ? "top" : "left";
var elementSize = this._getDraggableElementSize(isVerticalOrientation);
var items = this._getItems();
var prevPositions = this._getPositions(items, elementSize, fromIndex, prevToIndex);
var positions = this._getPositions(items, elementSize, fromIndex, toIndex);
var animationConfig = this.option("animation");
var rtlEnabled = this.option("rtlEnabled");
for (var i = 0; i < items.length; i++) {
var itemElement = items[i];
var prevPosition = prevPositions[i];
var position = positions[i];
if (null === toIndex || null === fromIndex) {
stopAnimation(itemElement)
} else if (prevPosition !== position || fullUpdate && position) {
animate(itemElement, (0, _extend.extend)({}, animationConfig, {
to: _defineProperty({}, positionPropName, !isVerticalOrientation && rtlEnabled ? -position : position)
}))
}
}
},
_toggleDragSourceClass: function(value, $element) {
var $sourceElement = $element || this._$sourceElement;
this.callBase.apply(this, arguments);
if (!this._isIndicateMode()) {
$sourceElement && $sourceElement.toggleClass(this._addWidgetPrefix("source-hidden"), value)
}
},
_dispose: function() {
this.reset();
this.callBase()
},
_fireAddEvent: function(sourceEvent) {
var args = this._getEventArgs(sourceEvent);
this._getAction("onAdd")(args);
return args.cancel
},
_fireRemoveEvent: function(sourceEvent) {
var sourceDraggable = this._getSourceDraggable();
var args = this._getEventArgs(sourceEvent);
sourceDraggable._getAction("onRemove")(args);
return args.cancel
},
_fireReorderEvent: function(sourceEvent) {
var args = this._getEventArgs(sourceEvent);
this._getAction("onReorder")(args);
return args.promise || (0, _deferred.Deferred)().resolve()
}
});
(0, _component_registrator.default)("dxSortable", Sortable);
var _default = Sortable;
exports.default = _default
},
18945:
/*!*************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/__internal/utils/memoize.js ***!
\*************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.memoize = void 0;
var _common = __webpack_require__( /*! ../../core/utils/common */ 20576);
function _toConsumableArray(arr) {
return function(arr) {
if (Array.isArray(arr)) {
return _arrayLikeToArray(arr)
}
}(arr) || function(iter) {
if ("undefined" !== typeof Symbol && null != iter[Symbol.iterator] || null != iter["@@iterator"]) {
return Array.from(iter)
}
}(arr) || function(o, minLen) {
if (!o) {
return
}
if ("string" === typeof o) {
return _arrayLikeToArray(o, minLen)
}
var n = Object.prototype.toString.call(o).slice(8, -1);
if ("Object" === n && o.constructor) {
n = o.constructor.name
}
if ("Map" === n || "Set" === n) {
return Array.from(o)
}
if ("Arguments" === n || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) {
return _arrayLikeToArray(o, minLen)
}
}(arr) || function() {
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 _arrayLikeToArray(arr, len) {
if (null == len || len > arr.length) {
len = arr.length
}
for (var i = 0, arr2 = new Array(len); i < len; i++) {
arr2[i] = arr[i]
}
return arr2
}
var compareByReference = function(args, lastArgs) {
return args.length === lastArgs.length && !Object.keys(args).some((function(key) {
return args[key] !== lastArgs[key]
}))
};
var compareByValue = function(args, lastArgs) {
return (0, _common.equalByValue)(args, lastArgs, {
maxDepth: 4
})
};
var createCacheFunc = function(firstArgs, firstResult, originFunc, compareFunc) {
var lastArgs = firstArgs;
var lastResult = firstResult;
return function() {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key]
}
var argsEquals = compareFunc(args, lastArgs);
if (argsEquals) {
return lastResult
}
lastArgs = args;
lastResult = originFunc.apply(void 0, _toConsumableArray(lastArgs));
return lastResult
}
};
var MEMOIZE_DEFAULT_OPTIONS = {
compareType: "reference"
};
exports.memoize = function(func) {
var _ref = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : MEMOIZE_DEFAULT_OPTIONS,
compareType = _ref.compareType;
var cachedFunc = null;
return function() {
for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
args[_key2] = arguments[_key2]
}
if (!cachedFunc) {
var firstResult = func.apply(void 0, args);
cachedFunc = createCacheFunc(args, firstResult, func, "reference" === compareType ? compareByReference : compareByValue);
return firstResult
}
return cachedFunc.apply(void 0, args)
}
}
},
23908:
/*!*****************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/animation/easing.js ***!
\*****************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.convertTransitionTimingFuncToEasing = void 0;
exports.getEasing = function(name) {
return easing[name]
};
exports.setEasing = function(value) {
easing = value
};
var _type = __webpack_require__( /*! ../core/utils/type */ 35922);
var CSS_TRANSITION_EASING_REGEX = /cubic-bezier\((\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\)/;
var TransitionTimingFuncMap = {
linear: "cubic-bezier(0, 0, 1, 1)",
swing: "cubic-bezier(0.445, 0.05, 0.55, 0.95)",
ease: "cubic-bezier(0.25, 0.1, 0.25, 1)",
"ease-in": "cubic-bezier(0.42, 0, 1, 1)",
"ease-out": "cubic-bezier(0, 0, 0.58, 1)",
"ease-in-out": "cubic-bezier(0.42, 0, 0.58, 1)"
};
var polynomBezier = function(x1, y1, x2, y2) {
var Cx = 3 * x1;
var Bx = 3 * (x2 - x1) - Cx;
var Ax = 1 - Cx - Bx;
var Cy = 3 * y1;
var By = 3 * (y2 - y1) - Cy;
var Ay = 1 - Cy - By;
var bezierX = function(t) {
return t * (Cx + t * (Bx + t * Ax))
};
var derivativeX = function(t) {
return Cx + t * (2 * Bx + 3 * t * Ax)
};
return function(t) {
return function(t) {
return t * (Cy + t * (By + t * Ay))
}(function(t) {
var x = t;
var i = 0;
var z;
while (i < 14) {
z = bezierX(x) - t;
if (Math.abs(z) < .001) {
break
}
x -= z / derivativeX(x);
i++
}
return x
}(t))
}
};
var easing = {};
exports.convertTransitionTimingFuncToEasing = function(cssTransitionEasing) {
cssTransitionEasing = TransitionTimingFuncMap[cssTransitionEasing] || cssTransitionEasing;
var coeffs = cssTransitionEasing.match(CSS_TRANSITION_EASING_REGEX);
var forceName;
if (!coeffs) {
forceName = "linear";
coeffs = TransitionTimingFuncMap[forceName].match(CSS_TRANSITION_EASING_REGEX)
}
coeffs = coeffs.slice(1, 5);
for (var i = 0; i < coeffs.length; i++) {
coeffs[i] = parseFloat(coeffs[i])
}
var easingName = forceName || "cubicbezier_" + coeffs.join("_").replace(/\./g, "p");
if (!(0, _type.isFunction)(easing[easingName])) {
easing[easingName] = function(x, t, b, c, d) {
return c * polynomBezier(coeffs[0], coeffs[1], coeffs[2], coeffs[3])(t / d) + b
}
}
return easingName
}
},
90057:
/*!****************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/animation/frame.js ***!
\****************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.cancelAnimationFrame = function() {
setAnimationFrameMethods();
cancel.apply(window, arguments)
};
exports.requestAnimationFrame = function() {
setAnimationFrameMethods();
return request.apply(window, arguments)
};
var _window = __webpack_require__( /*! ../core/utils/window */ 58201);
var _call_once = (obj = __webpack_require__( /*! ../core/utils/call_once */ 39618), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var window = (0, _window.hasWindow)() ? (0, _window.getWindow)() : {};
var request = function(callback) {
return setTimeout(callback, 1e3 / 60)
};
var cancel = function(requestID) {
clearTimeout(requestID)
};
var setAnimationFrameMethods = (0, _call_once.default)((function() {
var nativeRequest = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame;
var nativeCancel = window.cancelAnimationFrame || window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || window.oCancelAnimationFrame || window.msCancelAnimationFrame;
if (nativeRequest && nativeCancel) {
request = nativeRequest;
cancel = nativeCancel
}
}))
},
87209:
/*!*************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/animation/fx.js ***!
\*************************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _renderer = _interopRequireDefault(__webpack_require__( /*! ../core/renderer */ 68374));
var _window = __webpack_require__( /*! ../core/utils/window */ 58201);
var _events_engine = _interopRequireDefault(__webpack_require__( /*! ../events/core/events_engine */ 55994));
var _errors = _interopRequireDefault(__webpack_require__( /*! ../core/errors */ 17381));
var _element = __webpack_require__( /*! ../core/element */ 6415);
var _extend = __webpack_require__( /*! ../core/utils/extend */ 13306);
var _type = __webpack_require__( /*! ../core/utils/type */ 35922);
var _iterator = __webpack_require__( /*! ../core/utils/iterator */ 95479);
var _translator = __webpack_require__( /*! ./translator */ 31648);
var _easing = __webpack_require__( /*! ./easing */ 23908);
var _frame = __webpack_require__( /*! ./frame */ 90057);
var _support = __webpack_require__( /*! ../core/utils/support */ 60137);
var _position = _interopRequireDefault(__webpack_require__( /*! ./position */ 49387));
var _remove = __webpack_require__( /*! ../events/remove */ 29007);
var _index = __webpack_require__( /*! ../events/utils/index */ 39611);
var _deferred = __webpack_require__( /*! ../core/utils/deferred */ 62754);
var _common = __webpack_require__( /*! ../core/utils/common */ 20576);
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
function _typeof(obj) {
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)
}
var window = (0, _window.getWindow)();
var removeEventName = (0, _index.addNamespace)(_remove.removeEvent, "dxFX");
var RELATIVE_VALUE_REGEX = /^([+-])=(.*)/i;
var TransitionAnimationStrategy = {
initAnimation: function($element, config) {
$element.css({
transitionProperty: "none"
});
if ("string" === typeof config.from) {
$element.addClass(config.from)
} else {
setProps($element, config.from)
}
var that = this;
var deferred = new _deferred.Deferred;
var cleanupWhen = config.cleanupWhen;
config.transitionAnimation = {
deferred: deferred,
finish: function() {
that._finishTransition($element);
if (cleanupWhen) {
(0, _deferred.when)(deferred, cleanupWhen).always((function() {
that._cleanup($element, config)
}))
} else {
that._cleanup($element, config)
}
deferred.resolveWith($element, [config, $element])
}
};
this._completeAnimationCallback($element, config).done((function() {
config.transitionAnimation.finish()
})).fail((function() {
deferred.rejectWith($element, [config, $element])
}));
if (!config.duration) {
config.transitionAnimation.finish()
}
$element.css("transform")
},
animate: function($element, config) {
this._startAnimation($element, config);
return config.transitionAnimation.deferred.promise()
},
_completeAnimationCallback: function($element, config) {
var that = this;
var startTime = Date.now() + config.delay;
var deferred = new _deferred.Deferred;
var transitionEndFired = new _deferred.Deferred;
var simulatedTransitionEndFired = new _deferred.Deferred;
var simulatedEndEventTimer;
var transitionEndEventFullName = (0, _support.transitionEndEventName)() + ".dxFX";
config.transitionAnimation.cleanup = function() {
clearTimeout(simulatedEndEventTimer);
clearTimeout(waitForJSCompleteTimer);
_events_engine.default.off($element, transitionEndEventFullName);
_events_engine.default.off($element, removeEventName)
};
_events_engine.default.one($element, transitionEndEventFullName, (function() {
if (Date.now() - startTime >= config.duration) {
transitionEndFired.reject()
}
}));
_events_engine.default.off($element, removeEventName);
_events_engine.default.on($element, removeEventName, (function() {
that.stop($element, config);
deferred.reject()
}));
var waitForJSCompleteTimer = setTimeout((function() {
simulatedEndEventTimer = setTimeout((function() {
simulatedTransitionEndFired.reject()
}), config.duration + config.delay + fx._simulatedTransitionEndDelay);
(0, _deferred.when)(transitionEndFired, simulatedTransitionEndFired).fail(function() {
deferred.resolve()
}.bind(this))
}));
return deferred.promise()
},
_startAnimation: function($element, config) {
$element.css({
transitionProperty: "all",
transitionDelay: config.delay + "ms",
transitionDuration: config.duration + "ms",
transitionTimingFunction: config.easing
});
if ("string" === typeof config.to) {
$element[0].className += " " + config.to
} else if (config.to) {
setProps($element, config.to)
}
},
_finishTransition: function($element) {
$element.css("transition", "none")
},
_cleanup: function($element, config) {
config.transitionAnimation.cleanup();
if ("string" === typeof config.from) {
$element.removeClass(config.from);
$element.removeClass(config.to)
}
},
stop: function($element, config, jumpToEnd) {
if (!config) {
return
}
if (jumpToEnd) {
config.transitionAnimation.finish()
} else {
if ((0, _type.isPlainObject)(config.to)) {
(0, _iterator.each)(config.to, (function(key) {
$element.css(key, $element.css(key))
}))
}
this._finishTransition($element);
this._cleanup($element, config)
}
}
};
var FrameAnimationStrategy = {
initAnimation: function($element, config) {
setProps($element, config.from)
},
animate: function($element, config) {
var deferred = new _deferred.Deferred;
var that = this;
if (!config) {
return deferred.reject().promise()
}(0, _iterator.each)(config.to, (function(prop) {
if (void 0 === config.from[prop]) {
config.from[prop] = that._normalizeValue($element.css(prop))
}
}));
if (config.to.transform) {
config.from.transform = that._parseTransform(config.from.transform);
config.to.transform = that._parseTransform(config.to.transform)
}
config.frameAnimation = {
to: config.to,
from: config.from,
currentValue: config.from,
easing: (0, _easing.convertTransitionTimingFuncToEasing)(config.easing),
duration: config.duration,
startTime: (new Date).valueOf(),
finish: function() {
this.currentValue = this.to;
this.draw();
(0, _frame.cancelAnimationFrame)(config.frameAnimation.animationFrameId);
deferred.resolve()
},
draw: function() {
if (config.draw) {
config.draw(this.currentValue);
return
}
var currentValue = (0, _extend.extend)({}, this.currentValue);
if (currentValue.transform) {
currentValue.transform = (0, _iterator.map)(currentValue.transform, (function(value, prop) {
if ("translate" === prop) {
return (0, _translator.getTranslateCss)(value)
} else if ("scale" === prop) {
return "scale(" + value + ")"
} else if ("rotate" === prop.substr(0, prop.length - 1)) {
return prop + "(" + value + "deg)"
}
})).join(" ")
}
$element.css(currentValue)
}
};
if (config.delay) {
config.frameAnimation.startTime += config.delay;
config.frameAnimation.delayTimeout = setTimeout((function() {
that._startAnimation($element, config)
}), config.delay)
} else {
that._startAnimation($element, config)
}
return deferred.promise()
},
_startAnimation: function($element, config) {
_events_engine.default.off($element, removeEventName);
_events_engine.default.on($element, removeEventName, (function() {
if (config.frameAnimation) {
(0, _frame.cancelAnimationFrame)(config.frameAnimation.animationFrameId)
}
}));
this._animationStep($element, config)
},
_parseTransform: function(transformString) {
var result = {};
(0, _iterator.each)(transformString.match(/\w+\d*\w*\([^)]*\)\s*/g), (function(i, part) {
var translateData = (0, _translator.parseTranslate)(part);
var scaleData = part.match(/scale\((.+?)\)/);
var rotateData = part.match(/(rotate.)\((.+)deg\)/);
if (translateData) {
result.translate = translateData
}
if (scaleData && scaleData[1]) {
result.scale = parseFloat(scaleData[1])
}
if (rotateData && rotateData[1]) {
result[rotateData[1]] = parseFloat(rotateData[2])
}
}));
return result
},
stop: function($element, config, jumpToEnd) {
var frameAnimation = config && config.frameAnimation;
if (!frameAnimation) {
return
}(0, _frame.cancelAnimationFrame)(frameAnimation.animationFrameId);
clearTimeout(frameAnimation.delayTimeout);
if (jumpToEnd) {
frameAnimation.finish()
}
delete config.frameAnimation
},
_animationStep: function($element, config) {
var frameAnimation = config && config.frameAnimation;
if (!frameAnimation) {
return
}
var now = (new Date).valueOf();
if (now >= frameAnimation.startTime + frameAnimation.duration) {
frameAnimation.finish();
return
}
frameAnimation.currentValue = this._calcStepValue(frameAnimation, now - frameAnimation.startTime);
frameAnimation.draw();
var that = this;
frameAnimation.animationFrameId = (0, _frame.requestAnimationFrame)((function() {
that._animationStep($element, config)
}))
},
_calcStepValue: function(frameAnimation, currentDuration) {
return function calcValueRecursively(from, to) {
var result = Array.isArray(to) ? [] : {};
(0, _iterator.each)(to, (function(propName, endPropValue) {
if ("string" === typeof endPropValue && false === parseFloat(endPropValue)) {
return true
}
result[propName] = "object" === _typeof(endPropValue) ? calcValueRecursively(from[propName], endPropValue) : function(propName) {
var x = currentDuration / frameAnimation.duration;
var t = currentDuration;
var b = 1 * from[propName];
var c = to[propName] - from[propName];
var d = frameAnimation.duration;
return (0, _easing.getEasing)(frameAnimation.easing)(x, t, b, c, d)
}(propName)
}));
return result
}(frameAnimation.from, frameAnimation.to)
},
_normalizeValue: function(value) {
var numericValue = parseFloat(value);
if (false === numericValue) {
return value
}
return numericValue
}
};
var FallbackToNoAnimationStrategy = {
initAnimation: function() {},
animate: function() {
return (new _deferred.Deferred).resolve().promise()
},
stop: _common.noop,
isSynchronous: true
};
var baseConfigValidator = function(config, animationType, validate, typeMessage) {
(0, _iterator.each)(["from", "to"], (function() {
if (!validate(config[this])) {
throw _errors.default.Error("E0010", animationType, this, typeMessage)
}
}))
};
var isObjectConfigValidator = function(config, animationType) {
return baseConfigValidator(config, animationType, (function(target) {
return (0, _type.isPlainObject)(target)
}), "a plain object")
};
var CssAnimationConfigurator = {
validateConfig: function(config) {
! function(config, animationType) {
return baseConfigValidator(config, animationType, (function(target) {
return "string" === typeof target
}), "a string")
}(config, "css")
},
setup: function() {}
};
var positionAliases = {
top: {
my: "bottom center",
at: "top center"
},
bottom: {
my: "top center",
at: "bottom center"
},
right: {
my: "left center",
at: "right center"
},
left: {
my: "right center",
at: "left center"
}
};
var SlideAnimationConfigurator = {
validateConfig: function(config) {
isObjectConfigValidator(config, "slide")
},
setup: function($element, config) {
var location = (0, _translator.locate)($element);
if ("slide" !== config.type) {
var positioningConfig = "slideIn" === config.type ? config.from : config.to;
positioningConfig.position = (0, _extend.extend)({
of: window
}, positionAliases[config.direction]);
setupPosition($element, positioningConfig)
}
this._setUpConfig(location, config.from);
this._setUpConfig(location, config.to);
(0, _translator.clearCache)($element)
},
_setUpConfig: function(location, config) {
config.left = "left" in config ? config.left : "+=0";
config.top = "top" in config ? config.top : "+=0";
this._initNewPosition(location, config)
},
_initNewPosition: function(location, config) {
var position = {
left: config.left,
top: config.top
};
delete config.left;
delete config.top;
var relativeValue = this._getRelativeValue(position.left);
if (void 0 !== relativeValue) {
position.left = relativeValue + location.left
} else {
config.left = 0
}
relativeValue = this._getRelativeValue(position.top);
if (void 0 !== relativeValue) {
position.top = relativeValue + location.top
} else {
config.top = 0
}
config.transform = (0, _translator.getTranslateCss)({
x: position.left,
y: position.top
})
},
_getRelativeValue: function(value) {
var relativeValue;
if ("string" === typeof value && (relativeValue = RELATIVE_VALUE_REGEX.exec(value))) {
return parseInt(relativeValue[1] + "1") * relativeValue[2]
}
}
};
var FadeAnimationConfigurator = {
setup: function($element, config) {
var _from$opacity, _to$opacity;
var from = config.from;
var to = config.to;
var defaultFromOpacity = "fadeOut" === config.type ? 1 : 0;
var defaultToOpacity = "fadeOut" === config.type ? 0 : 1;
var fromOpacity = (0, _type.isPlainObject)(from) ? String(null !== (_from$opacity = from.opacity) && void 0 !== _from$opacity ? _from$opacity : defaultFromOpacity) : String(from);
var toOpacity = (0, _type.isPlainObject)(to) ? String(null !== (_to$opacity = to.opacity) && void 0 !== _to$opacity ? _to$opacity : defaultToOpacity) : String(to);
if (!config.skipElementInitialStyles) {
fromOpacity = $element.css("opacity")
}
switch (config.type) {
case "fadeIn":
toOpacity = 1;
break;
case "fadeOut":
toOpacity = 0
}
config.from = {
visibility: "visible",
opacity: fromOpacity
};
config.to = {
opacity: toOpacity
}
}
};
var PopAnimationConfigurator = {
validateConfig: function(config) {
isObjectConfigValidator(config, "pop")
},
setup: function($element, config) {
var from = config.from;
var to = config.to;
var fromOpacity = "opacity" in from ? from.opacity : $element.css("opacity");
var toOpacity = "opacity" in to ? to.opacity : 1;
var fromScale = "scale" in from ? from.scale : 0;
var toScale = "scale" in to ? to.scale : 1;
config.from = {
opacity: fromOpacity
};
var translate = (0, _translator.getTranslate)($element);
config.from.transform = this._getCssTransform(translate, fromScale);
config.to = {
opacity: toOpacity
};
config.to.transform = this._getCssTransform(translate, toScale)
},
_getCssTransform: function(translate, scale) {
return (0, _translator.getTranslateCss)(translate) + "scale(" + scale + ")"
}
};
var animationConfigurators = {
custom: {
setup: function() {}
},
slide: SlideAnimationConfigurator,
slideIn: SlideAnimationConfigurator,
slideOut: SlideAnimationConfigurator,
fade: FadeAnimationConfigurator,
fadeIn: FadeAnimationConfigurator,
fadeOut: FadeAnimationConfigurator,
pop: PopAnimationConfigurator,
css: CssAnimationConfigurator
};
var defaultJSConfig = {
type: "custom",
from: {},
to: {},
duration: 400,
start: _common.noop,
complete: _common.noop,
easing: "ease",
delay: 0
};
var defaultCssConfig = {
duration: 400,
easing: "ease",
delay: 0
};
function setupAnimationOnElement() {
var $element = this.element;
var config = this.config;
setupPosition($element, config.from);
setupPosition($element, config.to);
this.configurator.setup($element, config);
$element.data("dxAnimData", this);
if (fx.off) {
config.duration = 0;
config.delay = 0
}
this.strategy.initAnimation($element, config);
if (config.start) {
var element = (0, _element.getPublicElement)($element);
config.start.apply(this, [element, config])
}
}
var startAnimationOnElement = function() {
var animation = this;
var $element = animation.element;
var config = animation.config;
animation.isStarted = true;
return animation.strategy.animate($element, config).done((function() {
! function(animation) {
var $element = animation.element;
var config = animation.config;
$element.removeData("dxAnimData");
if (config.complete) {
var element = (0, _element.getPublicElement)($element);
config.complete.apply(this, [element, config])
}
animation.deferred.resolveWith(this, [$element, config])
}(animation)
})).fail((function() {
animation.deferred.rejectWith(this, [$element, config])
}))
};
var stopAnimationOnElement = function(jumpToEnd) {
var $element = this.element;
var config = this.config;
clearTimeout(this.startTimeout);
if (!this.isStarted) {
this.start()
}
this.strategy.stop($element, config, jumpToEnd)
};
var scopedRemoveEvent = (0, _index.addNamespace)(_remove.removeEvent, "dxFXStartAnimation");
var createAnimation = function(element, initialConfig) {
var defaultConfig = "css" === initialConfig.type ? defaultCssConfig : defaultJSConfig;
var config = (0, _extend.extend)(true, {}, defaultConfig, initialConfig);
var configurator = function(config) {
var result = animationConfigurators[config.type];
if (!result) {
throw _errors.default.Error("E0011", config.type)
}
return result
}(config);
var strategy = function(config) {
config = config || {};
var animationStrategies = {
transition: (0, _support.transition)() ? TransitionAnimationStrategy : FrameAnimationStrategy,
frame: FrameAnimationStrategy,
noAnimation: FallbackToNoAnimationStrategy
};
var strategy = config.strategy || "transition";
if ("css" === config.type && !(0, _support.transition)()) {
strategy = "noAnimation"
}
return animationStrategies[strategy]
}(config);
var animation = {
element: (0, _renderer.default)(element),
config: config,
configurator: configurator,
strategy: strategy,
isSynchronous: strategy.isSynchronous,
setup: setupAnimationOnElement,
start: startAnimationOnElement,
stop: stopAnimationOnElement,
deferred: new _deferred.Deferred
};
if ((0, _type.isFunction)(configurator.validateConfig)) {
configurator.validateConfig(config)
}! function(animation) {
_events_engine.default.off(animation.element, scopedRemoveEvent);
_events_engine.default.on(animation.element, scopedRemoveEvent, (function() {
fx.stop(animation.element)
}));
animation.deferred.always((function() {
_events_engine.default.off(animation.element, scopedRemoveEvent)
}))
}(animation);
return animation
};
function getAnimQueueData($element) {
return $element.data("dxAnimQueue") || []
}
var destroyAnimQueueData = function($element) {
$element.removeData("dxAnimQueue")
};
function isAnimating($element) {
return !!$element.data("dxAnimData")
}
function shiftFromAnimationQueue($element, queueData) {
queueData = getAnimQueueData($element);
if (!queueData.length) {
return
}
var animation = queueData.shift();
if (0 === queueData.length) {
destroyAnimQueueData($element)
}(function(animation) {
animation.setup();
if (fx.off || animation.isSynchronous) {
animation.start()
} else {
animation.startTimeout = setTimeout((function() {
animation.start()
}))
}
return animation.deferred.promise()
})(animation).done((function() {
if (!isAnimating($element)) {
shiftFromAnimationQueue($element)
}
}))
}
function setupPosition($element, config) {
if (!config || !config.position) {
return
}
var win = (0, _renderer.default)(window);
var left = 0;
var top = 0;
var position = _position.default.calculate($element, config.position);
var offset = $element.offset();
var currentPosition = $element.position();
if (currentPosition.top > offset.top) {
top = win.scrollTop()
}
if (currentPosition.left > offset.left) {
left = win.scrollLeft()
}(0, _extend.extend)(config, {
left: position.h.location - offset.left + currentPosition.left - left,
top: position.v.location - offset.top + currentPosition.top - top
});
delete config.position
}
function setProps($element, props) {
(0, _iterator.each)(props, (function(key, value) {
try {
$element.css(key, (0, _type.isFunction)(value) ? value() : value)
} catch (e) {}
}))
}
var fx = {
off: false,
animationTypes: animationConfigurators,
animate: function(element, config) {
var $element = (0, _renderer.default)(element);
if (!$element.length) {
return (new _deferred.Deferred).resolve().promise()
}
var animation = createAnimation($element, config);
! function($element, animation) {
var queueData = getAnimQueueData($element);
! function($element, queueData) {
$element.data("dxAnimQueue", queueData)
}($element, queueData);
queueData.push(animation);
if (!isAnimating($element)) {
shiftFromAnimationQueue($element, queueData)
}
}($element, animation);
return animation.deferred.promise()
},
createAnimation: createAnimation,
isAnimating: isAnimating,
stop: function(element, jumpToEnd) {
var $element = (0, _renderer.default)(element);
var queueData = getAnimQueueData($element);
(0, _iterator.each)(queueData, (function(_, animation) {
animation.config.delay = 0;
animation.config.duration = 0;
animation.isSynchronous = true
}));
if (!isAnimating($element)) {
shiftFromAnimationQueue($element, queueData)
}
var animation = $element.data("dxAnimData");
if (animation) {
animation.stop(jumpToEnd)
}
$element.removeData("dxAnimData");
destroyAnimQueueData($element)
},
_simulatedTransitionEndDelay: 100
};
var _default = fx;
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
49387:
/*!*******************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/animation/position.js ***!
\*******************************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _size = __webpack_require__( /*! ../core/utils/size */ 58664);
var _renderer = _interopRequireDefault(__webpack_require__( /*! ../core/renderer */ 68374));
var _common = __webpack_require__( /*! ../core/utils/common */ 20576);
var _iterator = __webpack_require__( /*! ../core/utils/iterator */ 95479);
var _window = __webpack_require__( /*! ../core/utils/window */ 58201);
var _dom_adapter = _interopRequireDefault(__webpack_require__( /*! ../core/dom_adapter */ 73349));
var _type = __webpack_require__( /*! ../core/utils/type */ 35922);
var _extend = __webpack_require__( /*! ../core/utils/extend */ 13306);
var _position = __webpack_require__( /*! ../core/utils/position */ 37518);
var _browser = _interopRequireDefault(__webpack_require__( /*! ../core/utils/browser */ 47810));
var _translator = __webpack_require__( /*! ./translator */ 31648);
var _support = __webpack_require__( /*! ../core/utils/support */ 60137);
var _devices = _interopRequireDefault(__webpack_require__( /*! ../core/devices */ 20530));
var _style = __webpack_require__( /*! ../core/utils/style */ 80968);
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var window = (0, _window.getWindow)();
var horzRe = /left|right/;
var vertRe = /top|bottom/;
var collisionRe = /fit|flip|none/;
var scaleRe = /scale\(.+?\)/;
var IS_SAFARI = _browser.default.safari;
var normalizeAlign = function(raw) {
var result = {
h: "center",
v: "center"
};
var pair = (0, _common.splitPair)(raw);
if (pair) {
(0, _iterator.each)(pair, (function() {
var w = String(this).toLowerCase();
if (horzRe.test(w)) {
result.h = w
} else if (vertRe.test(w)) {
result.v = w
}
}))
}
return result
};
var normalizeOffset = function(raw) {
return (0, _common.pairToObject)(raw)
};
var getAlignFactor = function(align) {
switch (align) {
case "center":
return .5;
case "right":
case "bottom":
return 1;
default:
return 0
}
};
var inverseAlign = function(align) {
switch (align) {
case "left":
return "right";
case "right":
return "left";
case "top":
return "bottom";
case "bottom":
return "top";
default:
return align
}
};
var calculateOversize = function(data, bounds) {
var oversize = 0;
if (data.myLocation < bounds.min) {
oversize += bounds.min - data.myLocation
}
if (data.myLocation > bounds.max) {
oversize += data.myLocation - bounds.max
}
return oversize
};
var collisionSide = function(direction, data, bounds) {
if (data.myLocation < bounds.min) {
return "h" === direction ? "left" : "top"
}
if (data.myLocation > bounds.max) {
return "h" === direction ? "right" : "bottom"
}
return "none"
};
var initMyLocation = function(data) {
data.myLocation = data.atLocation + getAlignFactor(data.atAlign) * data.atSize - getAlignFactor(data.myAlign) * data.mySize + data.offset
};
var collisionResolvers = {
fit: function(data, bounds) {
var result = false;
if (data.myLocation > bounds.max) {
data.myLocation = bounds.max;
result = true
}
if (data.myLocation < bounds.min) {
data.myLocation = bounds.min;
result = true
}
data.fit = result
},
flip: function(data, bounds) {
data.flip = false;
if ("center" === data.myAlign && "center" === data.atAlign) {
return
}
if (data.myLocation < bounds.min || data.myLocation > bounds.max) {
var inverseData = (0, _extend.extend)({}, data, {
myAlign: inverseAlign(data.myAlign),
atAlign: inverseAlign(data.atAlign),
offset: -data.offset
});
initMyLocation(inverseData);
inverseData.oversize = calculateOversize(inverseData, bounds);
if (inverseData.myLocation >= bounds.min && inverseData.myLocation <= bounds.max || data.oversize > inverseData.oversize) {
data.myLocation = inverseData.myLocation;
data.oversize = inverseData.oversize;
data.flip = true
}
}
},
flipfit: function(data, bounds) {
this.flip(data, bounds);
this.fit(data, bounds)
},
none: function(data) {
data.oversize = 0
}
};
var scrollbarWidth;
var calculateScrollbarWidth = function() {
var $scrollDiv = (0, _renderer.default)(" ").css({
width: 100,
height: 100,
overflow: "scroll",
position: "absolute",
top: -9999
}).appendTo((0, _renderer.default)("body"));
var result = $scrollDiv.get(0).offsetWidth - $scrollDiv.get(0).clientWidth;
$scrollDiv.remove();
scrollbarWidth = result
};
var defaultPositionResult = {
h: {
location: 0,
flip: false,
fit: false,
oversize: 0
},
v: {
location: 0,
flip: false,
fit: false,
oversize: 0
}
};
var calculatePosition = function(what, options) {
var $what = (0, _renderer.default)(what);
var currentOffset = $what.offset();
var result = (0, _extend.extend)(true, {}, defaultPositionResult, {
h: {
location: currentOffset.left
},
v: {
location: currentOffset.top
}
});
if (!options) {
return result
}
var my = normalizeAlign(options.my);
var at = normalizeAlign(options.at);
var of = (0, _renderer.default)(options.of).length && options.of || window;
var offset = normalizeOffset(options.offset);
var collision = function(raw) {
var pair = (0, _common.splitPair)(raw);
var h = String(pair && pair[0]).toLowerCase();
var v = String(pair && pair[1]).toLowerCase();
if (!collisionRe.test(h)) {
h = "none"
}
if (!collisionRe.test(v)) {
v = h
}
return {
h: h,
v: v
}
}(options.collision);
var boundary = options.boundary;
var boundaryOffset = normalizeOffset(options.boundaryOffset);
var h = {
mySize: (0, _size.getOuterWidth)($what),
myAlign: my.h,
atAlign: at.h,
offset: offset.h,
collision: collision.h,
boundaryOffset: boundaryOffset.h
};
var v = {
mySize: (0, _size.getOuterHeight)($what),
myAlign: my.v,
atAlign: at.v,
offset: offset.v,
collision: collision.v,
boundaryOffset: boundaryOffset.v
};
if (of.preventDefault) {
h.atLocation = of.pageX;
v.atLocation = of.pageY;
h.atSize = 0;
v.atSize = 0
} else {
of = (0, _renderer.default)(of);
if ((0, _type.isWindow)(of [0])) {
h.atLocation = of.scrollLeft();
v.atLocation = of.scrollTop();
if ("phone" === _devices.default.real().deviceType && of [0].visualViewport) {
h.atLocation = Math.max(h.atLocation, of [0].visualViewport.offsetLeft);
v.atLocation = Math.max(v.atLocation, of [0].visualViewport.offsetTop);
h.atSize = of [0].visualViewport.width;
v.atSize = of [0].visualViewport.height
} else {
h.atSize = of [0].innerWidth > of [0].outerWidth ? of [0].innerWidth : (0, _size.getWidth)(of);
v.atSize = of [0].innerHeight > of [0].outerHeight || IS_SAFARI ? of [0].innerHeight : (0, _size.getHeight)(of)
}
} else if (9 === of [0].nodeType) {
h.atLocation = 0;
v.atLocation = 0;
h.atSize = (0, _size.getWidth)(of);
v.atSize = (0, _size.getHeight)(of)
} else {
var ofRect = (0, _position.getBoundingRect)(of.get(0));
var o = getOffsetWithoutScale(of);
h.atLocation = o.left;
v.atLocation = o.top;
h.atSize = Math.max(ofRect.width, (0, _size.getOuterWidth)(of));
v.atSize = Math.max(ofRect.height, (0, _size.getOuterHeight)(of))
}
}
initMyLocation(h);
initMyLocation(v);
var bounds = function() {
var win = (0, _renderer.default)(window);
var windowWidth = (0, _size.getWidth)(win);
var windowHeight = (0, _size.getHeight)(win);
var left = win.scrollLeft();
var top = win.scrollTop();
var documentElement = _dom_adapter.default.getDocumentElement();
var hZoomLevel = _support.touch ? documentElement.clientWidth / windowWidth : 1;
var vZoomLevel = _support.touch ? documentElement.clientHeight / windowHeight : 1;
if (void 0 === scrollbarWidth) {
calculateScrollbarWidth()
}
var boundaryWidth = windowWidth;
var boundaryHeight = windowHeight;
if (boundary && !(0, _type.isWindow)(boundary)) {
var $boundary = (0, _renderer.default)(boundary);
var boundaryPosition = $boundary.offset();
left = boundaryPosition.left;
top = boundaryPosition.top;
boundaryWidth = (0, _size.getWidth)($boundary);
boundaryHeight = (0, _size.getHeight)($boundary)
}
return {
h: {
min: left + h.boundaryOffset,
max: left + boundaryWidth / hZoomLevel - h.mySize - h.boundaryOffset
},
v: {
min: top + v.boundaryOffset,
max: top + boundaryHeight / vZoomLevel - v.mySize - v.boundaryOffset
}
}
}();
h.oversize = calculateOversize(h, bounds.h);
v.oversize = calculateOversize(v, bounds.v);
h.collisionSide = collisionSide("h", h, bounds.h);
v.collisionSide = collisionSide("v", v, bounds.v);
if (collisionResolvers[h.collision]) {
collisionResolvers[h.collision](h, bounds.h)
}
if (collisionResolvers[v.collision]) {
collisionResolvers[v.collision](v, bounds.v)
}
var preciser = function(number) {
return options.precise ? number : Math.round(number)
};
(0, _extend.extend)(true, result, {
h: {
location: preciser(h.myLocation),
oversize: preciser(h.oversize),
fit: h.fit,
flip: h.flip,
collisionSide: h.collisionSide
},
v: {
location: preciser(v.myLocation),
oversize: preciser(v.oversize),
fit: v.fit,
flip: v.flip,
collisionSide: v.collisionSide
},
precise: options.precise
});
return result
};
var setScaleProperty = function(element, scale, styleAttr, isEmpty) {
var stylePropIsValid = (0, _type.isDefined)(element.style) && !_dom_adapter.default.isNode(element.style);
var newStyleValue = isEmpty ? styleAttr.replace(scale, "") : styleAttr;
if (stylePropIsValid) {
(0, _style.setStyle)(element, newStyleValue, false)
} else {
var styleAttributeNode = _dom_adapter.default.createAttribute("style");
styleAttributeNode.value = newStyleValue;
element.setAttributeNode(styleAttributeNode)
}
};
var getOffsetWithoutScale = function getOffsetWithoutScale($startElement) {
var _currentElement$getAt, _style$match;
var $currentElement = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : $startElement;
var currentElement = $currentElement.get(0);
if (!currentElement) {
return $startElement.offset()
}
var style = (null === (_currentElement$getAt = currentElement.getAttribute) || void 0 === _currentElement$getAt ? void 0 : _currentElement$getAt.call(currentElement, "style")) || "";
var scale = null === (_style$match = style.match(scaleRe)) || void 0 === _style$match ? void 0 : _style$match[0];
var offset;
if (scale) {
setScaleProperty(currentElement, scale, style, true);
offset = getOffsetWithoutScale($startElement, $currentElement.parent());
setScaleProperty(currentElement, scale, style, false)
} else {
offset = getOffsetWithoutScale($startElement, $currentElement.parent())
}
return offset
};
var position = function(what, options) {
var $what = (0, _renderer.default)(what);
if (!options) {
return $what.offset()
}(0, _translator.resetPosition)($what, true);
var offset = getOffsetWithoutScale($what);
var targetPosition = options.h && options.v ? options : calculatePosition($what, options);
var preciser = function(number) {
return options.precise ? number : Math.round(number)
};
(0, _translator.move)($what, {
left: targetPosition.h.location - preciser(offset.left),
top: targetPosition.v.location - preciser(offset.top)
});
return targetPosition
};
if (!position.inverseAlign) {
position.inverseAlign = inverseAlign
}
if (!position.normalizeAlign) {
position.normalizeAlign = normalizeAlign
}
var _default = {
calculateScrollbarWidth: calculateScrollbarWidth,
calculate: calculatePosition,
setup: position,
offset: function(element) {
element = (0, _renderer.default)(element).get(0);
if ((0, _type.isWindow)(element)) {
return null
} else if (element && "pageY" in element && "pageX" in element) {
return {
top: element.pageY,
left: element.pageX
}
}
return (0, _renderer.default)(element).offset()
}
};
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
42814:
/*!**************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/animation/presets/presets.js ***!
\**************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.presets = exports.PresetCollection = void 0;
var _size = __webpack_require__( /*! ../../core/utils/size */ 58664);
var _component = __webpack_require__( /*! ../../core/component */ 44297);
var _iterator = __webpack_require__( /*! ../../core/utils/iterator */ 95479);
var _extend = __webpack_require__( /*! ../../core/utils/extend */ 13306);
var _devices = _interopRequireDefault(__webpack_require__( /*! ../../core/devices */ 20530));
var _fx = _interopRequireDefault(__webpack_require__( /*! ../fx */ 87209));
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var directionPostfixes = {
forward: " dx-forward",
backward: " dx-backward",
none: " dx-no-direction",
undefined: " dx-no-direction"
};
var AnimationPresetCollection = _component.Component.inherit({
ctor: function() {
this.callBase.apply(this, arguments);
this._registeredPresets = [];
this.resetToDefaults()
},
_getDefaultOptions: function() {
return (0, _extend.extend)(this.callBase(), {
defaultAnimationDuration: 400,
defaultAnimationDelay: 0,
defaultStaggerAnimationDuration: 300,
defaultStaggerAnimationDelay: 40,
defaultStaggerAnimationStartDelay: 500
})
},
_defaultOptionsRules: function() {
return this.callBase().concat([{
device: function(_device) {
return _device.phone
},
options: {
defaultStaggerAnimationDuration: 350,
defaultStaggerAnimationDelay: 50,
defaultStaggerAnimationStartDelay: 0
}
}, {
device: function() {
return _devices.default.current().android || _devices.default.real.android
},
options: {
defaultAnimationDelay: 100
}
}])
},
_getPresetOptionName: function(animationName) {
return "preset_" + animationName
},
_createAndroidSlideAnimationConfig: function(throughOpacity, widthMultiplier) {
var that = this;
var createBaseConfig = function(configModifier) {
return {
type: "slide",
delay: void 0 === configModifier.delay ? that.option("defaultAnimationDelay") : configModifier.delay,
duration: void 0 === configModifier.duration ? that.option("defaultAnimationDuration") : configModifier.duration
}
};
return {
enter: function($element, configModifier) {
var width = (0, _size.getWidth)($element.parent()) * widthMultiplier;
var direction = configModifier.direction;
var config = createBaseConfig(configModifier);
config.to = {
left: 0,
opacity: 1
};
if ("forward" === direction) {
config.from = {
left: width,
opacity: throughOpacity
}
} else if ("backward" === direction) {
config.from = {
left: -width,
opacity: throughOpacity
}
} else {
config.from = {
left: 0,
opacity: 0
}
}
return _fx.default.createAnimation($element, config)
},
leave: function($element, configModifier) {
var width = (0, _size.getWidth)($element.parent()) * widthMultiplier;
var direction = configModifier.direction;
var config = createBaseConfig(configModifier);
config.from = {
left: 0,
opacity: 1
};
if ("forward" === direction) {
config.to = {
left: -width,
opacity: throughOpacity
}
} else if ("backward" === direction) {
config.to = {
left: width,
opacity: throughOpacity
}
} else {
config.to = {
left: 0,
opacity: 0
}
}
return _fx.default.createAnimation($element, config)
}
}
},
_createOpenDoorConfig: function() {
var that = this;
var createBaseConfig = function(configModifier) {
return {
type: "css",
extraCssClasses: "dx-opendoor-animation",
delay: void 0 === configModifier.delay ? that.option("defaultAnimationDelay") : configModifier.delay,
duration: void 0 === configModifier.duration ? that.option("defaultAnimationDuration") : configModifier.duration
}
};
return {
enter: function($element, configModifier) {
var direction = configModifier.direction;
var config = createBaseConfig(configModifier);
config.delay = "none" === direction ? config.delay : config.duration;
config.from = "dx-enter dx-opendoor-animation" + directionPostfixes[direction];
config.to = "dx-enter-active";
return _fx.default.createAnimation($element, config)
},
leave: function($element, configModifier) {
var direction = configModifier.direction;
var config = createBaseConfig(configModifier);
config.from = "dx-leave dx-opendoor-animation" + directionPostfixes[direction];
config.to = "dx-leave-active";
return _fx.default.createAnimation($element, config)
}
}
},
_createWinPopConfig: function() {
var that = this;
var baseConfig = {
type: "css",
extraCssClasses: "dx-win-pop-animation",
duration: that.option("defaultAnimationDuration")
};
return {
enter: function($element, configModifier) {
var config = baseConfig;
var direction = configModifier.direction;
config.delay = "none" === direction ? that.option("defaultAnimationDelay") : that.option("defaultAnimationDuration") / 2;
config.from = "dx-enter dx-win-pop-animation" + directionPostfixes[direction];
config.to = "dx-enter-active";
return _fx.default.createAnimation($element, config)
},
leave: function($element, configModifier) {
var config = baseConfig;
var direction = configModifier.direction;
config.delay = that.option("defaultAnimationDelay");
config.from = "dx-leave dx-win-pop-animation" + directionPostfixes[direction];
config.to = "dx-leave-active";
return _fx.default.createAnimation($element, config)
}
}
},
resetToDefaults: function() {
this.clear();
this.registerDefaultPresets();
this.applyChanges()
},
clear: function(name) {
var that = this;
var newRegisteredPresets = [];
(0, _iterator.each)(this._registeredPresets, (function(index, preset) {
if (!name || name === preset.name) {
that.option(that._getPresetOptionName(preset.name), void 0)
} else {
newRegisteredPresets.push(preset)
}
}));
this._registeredPresets = newRegisteredPresets;
this.applyChanges()
},
registerPreset: function(name, config) {
this._registeredPresets.push({
name: name,
config: config
})
},
applyChanges: function() {
var that = this;
var customRules = [];
(0, _iterator.each)(this._registeredPresets, (function(index, preset) {
var rule = {
device: preset.config.device,
options: {}
};
rule.options[that._getPresetOptionName(preset.name)] = preset.config.animation;
customRules.push(rule)
}));
this._setOptionsByDevice(customRules)
},
getPreset: function(name) {
var result = name;
while ("string" === typeof result) {
result = this.option(this._getPresetOptionName(result))
}
return result
},
registerDefaultPresets: function() {
this.registerPreset("pop", {
animation: {
extraCssClasses: "dx-android-pop-animation",
delay: this.option("defaultAnimationDelay"),
duration: this.option("defaultAnimationDuration")
}
});
this.registerPreset("openDoor", {
animation: this._createOpenDoorConfig()
});
this.registerPreset("win-pop", {
animation: this._createWinPopConfig()
});
this.registerPreset("fade", {
animation: {
extraCssClasses: "dx-fade-animation",
delay: this.option("defaultAnimationDelay"),
duration: this.option("defaultAnimationDuration")
}
});
this.registerPreset("slide", {
device: function() {
return _devices.default.current().android || _devices.default.real.android
},
animation: this._createAndroidSlideAnimationConfig(1, 1)
});
this.registerPreset("slide", {
device: function() {
return !_devices.default.current().android && !_devices.default.real.android
},
animation: {
extraCssClasses: "dx-slide-animation",
delay: this.option("defaultAnimationDelay"),
duration: this.option("defaultAnimationDuration")
}
});
this.registerPreset("ios7-slide", {
animation: {
extraCssClasses: "dx-ios7-slide-animation",
delay: this.option("defaultAnimationDelay"),
duration: this.option("defaultAnimationDuration")
}
});
this.registerPreset("overflow", {
animation: {
extraCssClasses: "dx-overflow-animation",
delay: this.option("defaultAnimationDelay"),
duration: this.option("defaultAnimationDuration")
}
});
this.registerPreset("ios7-toolbar", {
device: function() {
return !_devices.default.current().android && !_devices.default.real.android
},
animation: {
extraCssClasses: "dx-ios7-toolbar-animation",
delay: this.option("defaultAnimationDelay"),
duration: this.option("defaultAnimationDuration")
}
});
this.registerPreset("ios7-toolbar", {
device: function() {
return _devices.default.current().android || _devices.default.real.android
},
animation: this._createAndroidSlideAnimationConfig(0, .4)
});
this.registerPreset("stagger-fade", {
animation: {
extraCssClasses: "dx-fade-animation",
staggerDelay: this.option("defaultStaggerAnimationDelay"),
duration: this.option("defaultStaggerAnimationDuration"),
delay: this.option("defaultStaggerAnimationStartDelay")
}
});
this.registerPreset("stagger-slide", {
animation: {
extraCssClasses: "dx-slide-animation",
staggerDelay: this.option("defaultStaggerAnimationDelay"),
duration: this.option("defaultStaggerAnimationDuration"),
delay: this.option("defaultStaggerAnimationStartDelay")
}
});
this.registerPreset("stagger-fade-slide", {
animation: {
extraCssClasses: "dx-fade-slide-animation",
staggerDelay: this.option("defaultStaggerAnimationDelay"),
duration: this.option("defaultStaggerAnimationDuration"),
delay: this.option("defaultStaggerAnimationStartDelay")
}
});
this.registerPreset("stagger-drop", {
animation: {
extraCssClasses: "dx-drop-animation",
staggerDelay: this.option("defaultStaggerAnimationDelay"),
duration: this.option("defaultStaggerAnimationDuration"),
delay: this.option("defaultStaggerAnimationStartDelay")
}
});
this.registerPreset("stagger-fade-drop", {
animation: {
extraCssClasses: "dx-fade-drop-animation",
staggerDelay: this.option("defaultStaggerAnimationDelay"),
duration: this.option("defaultStaggerAnimationDuration"),
delay: this.option("defaultStaggerAnimationStartDelay")
}
});
this.registerPreset("stagger-fade-rise", {
animation: {
extraCssClasses: "dx-fade-rise-animation",
staggerDelay: this.option("defaultStaggerAnimationDelay"),
duration: this.option("defaultStaggerAnimationDuration"),
delay: this.option("defaultStaggerAnimationStartDelay")
}
});
this.registerPreset("stagger-3d-drop", {
animation: {
extraCssClasses: "dx-3d-drop-animation",
staggerDelay: this.option("defaultStaggerAnimationDelay"),
duration: this.option("defaultStaggerAnimationDuration"),
delay: this.option("defaultStaggerAnimationStartDelay")
}
});
this.registerPreset("stagger-fade-zoom", {
animation: {
extraCssClasses: "dx-fade-zoom-animation",
staggerDelay: this.option("defaultStaggerAnimationDelay"),
duration: this.option("defaultStaggerAnimationDuration"),
delay: this.option("defaultStaggerAnimationStartDelay")
}
})
}
});
exports.PresetCollection = AnimationPresetCollection;
var animationPresets = new AnimationPresetCollection;
exports.presets = animationPresets
},
52431:
/*!**************************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/animation/transition_executor/transition_executor.js ***!
\**************************************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.TransitionExecutor = void 0;
var _renderer = _interopRequireDefault(__webpack_require__( /*! ../../core/renderer */ 68374));
var _class = _interopRequireDefault(__webpack_require__( /*! ../../core/class */ 38377));
var _extend = __webpack_require__( /*! ../../core/utils/extend */ 13306);
var _common = __webpack_require__( /*! ../../core/utils/common */ 20576);
var _type = __webpack_require__( /*! ../../core/utils/type */ 35922);
var _iterator = __webpack_require__( /*! ../../core/utils/iterator */ 95479);
var _fx = _interopRequireDefault(__webpack_require__( /*! ../fx */ 87209));
var _presets = __webpack_require__( /*! ../presets/presets */ 42814);
var _deferred = __webpack_require__( /*! ../../core/utils/deferred */ 62754);
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var directionPostfixes = {
forward: " dx-forward",
backward: " dx-backward",
none: " dx-no-direction",
undefined: " dx-no-direction"
};
var TransitionExecutor = _class.default.inherit({
ctor: function() {
this._accumulatedDelays = {
enter: 0,
leave: 0
};
this._animations = [];
this.reset()
},
_createAnimations: function($elements, initialConfig, configModifier, type) {
$elements = (0, _renderer.default)($elements);
var that = this;
var result = [];
configModifier = configModifier || {};
var animationConfig = this._prepareElementAnimationConfig(initialConfig, configModifier, type);
if (animationConfig) {
$elements.each((function() {
var animation = that._createAnimation((0, _renderer.default)(this), animationConfig, configModifier);
if (animation) {
animation.element.addClass("dx-animating");
animation.setup();
result.push(animation)
}
}))
}
return result
},
_prepareElementAnimationConfig: function(config, configModifier, type) {
var result;
if ("string" === typeof config) {
var presetName = config;
config = _presets.presets.getPreset(presetName)
}
if (!config) {
result = void 0
} else if ((0, _type.isFunction)(config[type])) {
result = config[type]
} else {
result = (0, _extend.extend)({
skipElementInitialStyles: true,
cleanupWhen: this._completePromise
}, config, configModifier);
if (!result.type || "css" === result.type) {
var cssClass = "dx-" + type;
var extraCssClasses = (result.extraCssClasses ? " " + result.extraCssClasses : "") + directionPostfixes[result.direction];
result.type = "css";
result.from = (result.from || cssClass) + extraCssClasses;
result.to = result.to || cssClass + "-active"
}
result.staggerDelay = result.staggerDelay || 0;
result.delay = result.delay || 0;
if (result.staggerDelay) {
result.delay += this._accumulatedDelays[type];
this._accumulatedDelays[type] += result.staggerDelay
}
}
return result
},
_createAnimation: function($element, animationConfig, configModifier) {
var result;
if ((0, _type.isPlainObject)(animationConfig)) {
result = _fx.default.createAnimation($element, animationConfig)
} else if ((0, _type.isFunction)(animationConfig)) {
result = animationConfig($element, configModifier)
}
return result
},
_startAnimations: function() {
var animations = this._animations;
for (var i = 0; i < animations.length; i++) {
animations[i].start()
}
},
_stopAnimations: function(jumpToEnd) {
var animations = this._animations;
for (var i = 0; i < animations.length; i++) {
animations[i].stop(jumpToEnd)
}
},
_clearAnimations: function() {
var animations = this._animations;
for (var i = 0; i < animations.length; i++) {
animations[i].element.removeClass("dx-animating")
}
this._animations.length = 0
},
reset: function() {
this._accumulatedDelays.enter = 0;
this._accumulatedDelays.leave = 0;
this._clearAnimations();
this._completeDeferred = new _deferred.Deferred;
this._completePromise = this._completeDeferred.promise()
},
enter: function($elements, animationConfig, configModifier) {
var animations = this._createAnimations($elements, animationConfig, configModifier, "enter");
this._animations.push.apply(this._animations, animations)
},
leave: function($elements, animationConfig, configModifier) {
var animations = this._createAnimations($elements, animationConfig, configModifier, "leave");
this._animations.push.apply(this._animations, animations)
},
start: function() {
var that = this;
var result;
if (!this._animations.length) {
that.reset();
result = (new _deferred.Deferred).resolve().promise()
} else {
var animationDeferreds = (0, _iterator.map)(this._animations, (function(animation) {
var result = new _deferred.Deferred;
animation.deferred.always((function() {
result.resolve()
}));
return result.promise()
}));
result = _deferred.when.apply(_renderer.default, animationDeferreds).always((function() {
that._completeDeferred.resolve();
that.reset()
}));
(0, _common.executeAsync)((function() {
that._startAnimations()
}))
}
return result
},
stop: function(jumpToEnd) {
this._stopAnimations(jumpToEnd)
}
});
exports.TransitionExecutor = TransitionExecutor
},
31648:
/*!*********************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/animation/translator.js ***!
\*********************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.resetPosition = exports.parseTranslate = exports.move = exports.locate = exports.getTranslateCss = exports.getTranslate = exports.clearCache = void 0;
var _renderer = (obj = __webpack_require__( /*! ../core/renderer */ 68374), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var _element_data = __webpack_require__( /*! ../core/element_data */ 97906);
var _type = __webpack_require__( /*! ../core/utils/type */ 35922);
var TRANSFORM_MATRIX_REGEX = /matrix(3d)?\((.+?)\)/;
var TRANSLATE_REGEX = /translate(?:3d)?\((.+?)\)/;
exports.locate = function($element) {
$element = (0, _renderer.default)($element);
var translate = getTranslate($element);
return {
left: translate.x,
top: translate.y
}
};
function isPercentValue(value) {
return "string" === (0, _type.type)(value) && "%" === value[value.length - 1]
}
function cacheTranslate($element, translate) {
if ($element.length) {
(0, _element_data.data)($element.get(0), "dxTranslator", translate)
}
}
var clearCache = function($element) {
if ($element.length) {
(0, _element_data.removeData)($element.get(0), "dxTranslator")
}
};
exports.clearCache = clearCache;
var getTranslateCss = function(translate) {
translate.x = translate.x || 0;
translate.y = translate.y || 0;
var xValueString = isPercentValue(translate.x) ? translate.x : translate.x + "px";
var yValueString = isPercentValue(translate.y) ? translate.y : translate.y + "px";
return "translate(" + xValueString + ", " + yValueString + ")"
};
exports.getTranslateCss = getTranslateCss;
var getTranslate = function($element) {
var result = $element.length ? (0, _element_data.data)($element.get(0), "dxTranslator") : null;
if (!result) {
var transformValue = $element.css("transform") || getTranslateCss({
x: 0,
y: 0
});
var matrix = transformValue.match(TRANSFORM_MATRIX_REGEX);
var is3D = matrix && matrix[1];
if (matrix) {
matrix = matrix[2].split(",");
if ("3d" === is3D) {
matrix = matrix.slice(12, 15)
} else {
matrix.push(0);
matrix = matrix.slice(4, 7)
}
} else {
matrix = [0, 0, 0]
}
result = {
x: parseFloat(matrix[0]),
y: parseFloat(matrix[1]),
z: parseFloat(matrix[2])
};
cacheTranslate($element, result)
}
return result
};
exports.getTranslate = getTranslate;
exports.move = function($element, position) {
$element = (0, _renderer.default)($element);
var left = position.left;
var top = position.top;
var translate;
if (void 0 === left) {
translate = getTranslate($element);
translate.y = top || 0
} else if (void 0 === top) {
translate = getTranslate($element);
translate.x = left || 0
} else {
translate = {
x: left || 0,
y: top || 0,
z: 0
};
cacheTranslate($element, translate)
}
$element.css({
transform: getTranslateCss(translate)
});
if (isPercentValue(left) || isPercentValue(top)) {
clearCache($element)
}
};
exports.resetPosition = function($element, finishTransition) {
$element = (0, _renderer.default)($element);
var originalTransition;
var stylesConfig = {
left: 0,
top: 0,
transform: "none"
};
if (finishTransition) {
originalTransition = $element.css("transition");
stylesConfig.transition = "none"
}
$element.css(stylesConfig);
clearCache($element);
if (finishTransition) {
$element.get(0).offsetHeight;
$element.css("transition", originalTransition)
}
};
exports.parseTranslate = function(translateString) {
var result = translateString.match(TRANSLATE_REGEX);
if (!result || !result[1]) {
return
}
result = result[1].split(",");
result = {
x: parseFloat(result[0]),
y: parseFloat(result[1]),
z: parseFloat(result[2])
};
return result
}
},
16354:
/*!***************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/bundles/dx.all.js ***!
\***************************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
__webpack_require__( /*! ./modules/parts/widgets-web */ 2025);
__webpack_require__( /*! ./modules/parts/viz */ 66312);
var _core = (obj = __webpack_require__( /*! ./modules/core */ 36991), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var _events_strategy = __webpack_require__( /*! ../core/events_strategy */ 80566);
var _index = __webpack_require__( /*! ../core/options/index */ 95683);
_core.default.integration = {};
_core.default.integration.EventsStrategy = _events_strategy.EventsStrategy;
_core.default.integration.Options = _index.Options;
var _default = _core.default;
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
72505:
/*!******************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/bundles/modules/common.charts.js ***!
\******************************************************************************/
function(module, __unused_webpack_exports, __webpack_require__) {
var DevExpress = __webpack_require__( /*! ./core */ 36991);
DevExpress.common = DevExpress.common || {};
DevExpress.common.charts = __webpack_require__( /*! ../../common/charts */ 29932);
module.exports = DevExpress.common.charts
},
36991:
/*!*********************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/bundles/modules/core.js ***!
\*********************************************************************/
function(module, __unused_webpack_exports, __webpack_require__) {
var windowUtils = __webpack_require__( /*! ../../core/utils/window */ 58201);
var window = windowUtils.getWindow();
var DevExpress = window.DevExpress = window.DevExpress || {};
var errors = DevExpress.errors = __webpack_require__( /*! ../../core/errors */ 17381);
if (DevExpress._DEVEXTREME_BUNDLE_INITIALIZED) {
throw errors.Error("E0024")
}
DevExpress._DEVEXTREME_BUNDLE_INITIALIZED = true;
DevExpress.clientExporter = __webpack_require__( /*! ../../exporter */ 78292);
DevExpress.excelExporter = __webpack_require__( /*! ../../excel_exporter */ 2994);
DevExpress.pdfExporter = __webpack_require__( /*! ../../pdf_exporter */ 44194);
DevExpress.VERSION = __webpack_require__( /*! ../../core/version */ 36739).version;
DevExpress.Class = __webpack_require__( /*! ../../core/class */ 38377);
DevExpress.DOMComponent = __webpack_require__( /*! ../../core/dom_component */ 13046);
DevExpress.Component = __webpack_require__( /*! ../../core/component */ 44297).Component;
DevExpress.registerComponent = __webpack_require__( /*! ../../core/component_registrator */ 99393);
DevExpress.devices = __webpack_require__( /*! ../../core/devices */ 20530);
DevExpress.Color = __webpack_require__( /*! ../../color */ 52752);
var animationFrame = __webpack_require__( /*! ../../animation/frame */ 90057);
DevExpress.utils = {};
DevExpress.utils.requestAnimationFrame = animationFrame.requestAnimationFrame;
DevExpress.utils.cancelAnimationFrame = animationFrame.cancelAnimationFrame;
DevExpress.utils.initMobileViewport = __webpack_require__( /*! ../../mobile/init_mobile_viewport/init_mobile_viewport */ 88185).p;
DevExpress.utils.getTimeZones = __webpack_require__( /*! ../../time_zone_utils */ 88673).Z;
DevExpress.utils.extendFromObject = __webpack_require__( /*! ../../core/utils/extend */ 13306).extendFromObject;
DevExpress.utils.triggerShownEvent = __webpack_require__( /*! ../../events/visibility_change */ 80506).triggerShownEvent;
DevExpress.utils.triggerHidingEvent = __webpack_require__( /*! ../../events/visibility_change */ 80506).triggerHidingEvent;
DevExpress.utils.resetActiveElement = __webpack_require__( /*! ../../core/utils/dom */ 3532).resetActiveElement;
DevExpress.utils.findBestMatches = __webpack_require__( /*! ../../core/utils/common */ 20576).findBestMatches;
DevExpress.createQueue = __webpack_require__( /*! ../../core/utils/queue */ 59504).create;
DevExpress.utils.dom = __webpack_require__( /*! ../../core/utils/dom */ 3532);
DevExpress.utils.common = __webpack_require__( /*! ../../core/utils/common */ 20576);
DevExpress.utils.date = __webpack_require__( /*! ../../core/utils/date */ 91198);
DevExpress.utils.browser = __webpack_require__( /*! ../../core/utils/browser */ 47810);
DevExpress.utils.inflector = __webpack_require__( /*! ../../core/utils/inflector */ 78008);
DevExpress.utils.iterator = __webpack_require__( /*! ../../core/utils/iterator */ 95479);
DevExpress.utils.readyCallbacks = __webpack_require__( /*! ../../core/utils/ready_callbacks */ 24311);
DevExpress.utils.resizeCallbacks = __webpack_require__( /*! ../../core/utils/resize_callbacks */ 55814);
DevExpress.utils.console = __webpack_require__( /*! ../../core/utils/console */ 30869);
DevExpress.utils.string = __webpack_require__( /*! ../../core/utils/string */ 68752);
DevExpress.utils.support = __webpack_require__( /*! ../../core/utils/support */ 60137);
DevExpress.utils.ajax = __webpack_require__( /*! ../../core/utils/ajax */ 37208);
DevExpress.viewPort = __webpack_require__( /*! ../../core/utils/view_port */ 77695).value;
DevExpress.hideTopOverlay = __webpack_require__( /*! ../../mobile/hide_top_overlay */ 60628);
DevExpress.formatHelper = __webpack_require__( /*! ../../format_helper */ 30343);
DevExpress.config = __webpack_require__( /*! ../../core/config */ 80209);
DevExpress.animationPresets = __webpack_require__( /*! ../../animation/presets/presets */ 42814).presets;
DevExpress.fx = __webpack_require__( /*! ../../animation/fx */ 87209);
DevExpress.TransitionExecutor = __webpack_require__( /*! ../../animation/transition_executor/transition_executor */ 52431).TransitionExecutor;
DevExpress.AnimationPresetCollection = __webpack_require__( /*! ../../animation/presets/presets */ 42814).PresetCollection;
DevExpress.events = __webpack_require__( /*! ../../events */ 66365);
DevExpress.events.click = __webpack_require__( /*! ../../events/click */ 95429);
DevExpress.events.utils = __webpack_require__( /*! ../../events/utils */ 39611);
DevExpress.events.GestureEmitter = __webpack_require__( /*! ../../events/gesture/emitter.gesture */ 98621);
DevExpress.localization = __webpack_require__( /*! ../../localization */ 94484);
DevExpress.templateRendered = __webpack_require__( /*! ../../core/templates/template_base */ 81033).renderedCallbacks;
DevExpress.setTemplateEngine = __webpack_require__( /*! ../../core/templates/template_engine_registry */ 72987).setTemplateEngine;
module.exports = DevExpress
},
86635:
/*!*********************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/bundles/modules/data.js ***!
\*********************************************************************/
function(module, __unused_webpack_exports, __webpack_require__) {
var DevExpress = __webpack_require__( /*! ./core */ 36991);
var errors = __webpack_require__( /*! ../../core/errors */ 17381);
module.exports = DevExpress.data = DevExpress.data || {};
Object.defineProperty(DevExpress.data, "errorHandler", {
get: function() {
return __webpack_require__( /*! ../../data/errors */ 18438).errorHandler
},
set: function(value) {
errors.log("W0003", "DevExpress.data", "errorHandler", "21.1", "Use the 'setErrorHandler' method instead");
__webpack_require__( /*! ../../data/errors */ 18438).setErrorHandler(value)
}
});
Object.defineProperty(DevExpress.data, "_errorHandler", {
get: function() {
return __webpack_require__( /*! ../../data/errors */ 18438).handleError
},
set: function(value) {
errors.log("W0003", "DevExpress.data", "_errorHandler", "21.1", "Use the 'setErrorHandler' method instead");
__webpack_require__( /*! ../../data/errors */ 18438).setErrorHandler(value)
}
});
DevExpress.data.setErrorHandler = __webpack_require__( /*! ../../data/errors */ 18438).setErrorHandler;
DevExpress.data.DataSource = __webpack_require__( /*! ../../data/data_source */ 33546);
DevExpress.data.query = __webpack_require__( /*! ../../data/query */ 96687);
DevExpress.data.Store = __webpack_require__( /*! ../../data/abstract_store */ 67403);
DevExpress.data.ArrayStore = __webpack_require__( /*! ../../data/array_store */ 26562);
DevExpress.data.CustomStore = __webpack_require__( /*! ../../data/custom_store */ 88036);
DevExpress.data.LocalStore = __webpack_require__( /*! ../../data/local_store */ 82837);
DevExpress.data.base64_encode = __webpack_require__( /*! ../../data/utils */ 16454).base64_encode;
DevExpress.data.applyChanges = __webpack_require__( /*! ../../data/apply_changes */ 36893);
DevExpress.data.Guid = __webpack_require__( /*! ../../core/guid */ 73176);
DevExpress.data.utils = {};
DevExpress.data.utils.compileGetter = __webpack_require__( /*! ../../core/utils/data */ 47617).compileGetter;
DevExpress.data.utils.compileSetter = __webpack_require__( /*! ../../core/utils/data */ 47617).compileSetter;
DevExpress.EndpointSelector = __webpack_require__( /*! ../../data/endpoint_selector */ 8162);
DevExpress.data.queryImpl = __webpack_require__( /*! ../../data/query_implementation */ 77549).queryImpl;
DevExpress.data.queryAdapters = __webpack_require__( /*! ../../data/query_adapters */ 16135);
var dataUtils = __webpack_require__( /*! ../../data/utils */ 16454);
DevExpress.data.utils.normalizeBinaryCriterion = dataUtils.normalizeBinaryCriterion;
DevExpress.data.utils.normalizeSortingInfo = dataUtils.normalizeSortingInfo;
DevExpress.data.utils.errorMessageFromXhr = dataUtils.errorMessageFromXhr;
DevExpress.data.utils.aggregators = dataUtils.aggregators;
DevExpress.data.utils.keysEqual = dataUtils.keysEqual;
DevExpress.data.utils.isDisjunctiveOperator = dataUtils.isDisjunctiveOperator;
DevExpress.data.utils.isConjunctiveOperator = dataUtils.isConjunctiveOperator;
DevExpress.data.utils.processRequestResultLock = dataUtils.processRequestResultLock;
DevExpress.data.utils.toComparable = __webpack_require__( /*! ../../core/utils/data */ 47617).toComparable;
DevExpress.data.utils.multiLevelGroup = __webpack_require__( /*! ../../data/store_helper */ 99236).multiLevelGroup;
DevExpress.data.utils.arrangeSortingInfo = __webpack_require__( /*! ../../data/store_helper */ 99236).arrangeSortingInfo;
DevExpress.data.utils.normalizeDataSourceOptions = __webpack_require__( /*! ../../data/data_source/utils */ 9234).normalizeDataSourceOptions
},
72343:
/*!***************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/bundles/modules/data.odata.js ***!
\***************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
__webpack_require__( /*! ./data */ 86635);
DevExpress.data.ODataStore = __webpack_require__( /*! ../../data/odata/store */ 341);
DevExpress.data.ODataContext = __webpack_require__( /*! ../../data/odata/context */ 47256);
DevExpress.data.utils = DevExpress.data.utils || {};
DevExpress.data.utils.odata = {};
DevExpress.data.utils.odata.keyConverters = __webpack_require__( /*! ../../data/odata/utils */ 77869).keyConverters;
DevExpress.data.EdmLiteral = __webpack_require__( /*! ../../data/odata/utils */ 77869).EdmLiteral;
var ODataUtilsModule = __webpack_require__( /*! ../../data/odata/utils */ 77869);
DevExpress.data.utils.odata.serializePropName = ODataUtilsModule.serializePropName;
DevExpress.data.utils.odata.serializeValue = ODataUtilsModule.serializeValue;
DevExpress.data.utils.odata.serializeKey = ODataUtilsModule.serializeKey;
DevExpress.data.utils.odata.sendRequest = ODataUtilsModule.sendRequest;
DevExpress.data.queryAdapters = DevExpress.data.queryAdapters || {};
DevExpress.data.queryAdapters.odata = __webpack_require__( /*! ../../data/odata/query_adapter */ 54263).odata
},
56208:
/*!********************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/bundles/modules/file_management.js ***!
\********************************************************************************/
function(module, __unused_webpack_exports, __webpack_require__) {
var _core = _interopRequireDefault(__webpack_require__( /*! ./core */ 36991));
var _error = _interopRequireDefault(__webpack_require__( /*! ../../file_management/error */ 49816));
var _file_system_item = _interopRequireDefault(__webpack_require__( /*! ../../file_management/file_system_item */ 45765));
var _object_provider = _interopRequireDefault(__webpack_require__( /*! ../../file_management/object_provider */ 4323));
var _remote_provider = _interopRequireDefault(__webpack_require__( /*! ../../file_management/remote_provider */ 41332));
var _custom_provider = _interopRequireDefault(__webpack_require__( /*! ../../file_management/custom_provider */ 98831));
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
module.exports = _core.default.fileManagement = _core.default.fileManagement || {};
_core.default.fileManagement.FileSystemError = _error.default;
_core.default.fileManagement.FileSystemItem = _file_system_item.default;
_core.default.fileManagement.ObjectFileSystemProvider = _object_provider.default;
_core.default.fileManagement.RemoteFileSystemProvider = _remote_provider.default;
_core.default.fileManagement.CustomFileSystemProvider = _custom_provider.default
},
85357:
/*!***************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/bundles/modules/parts/core.js ***!
\***************************************************************************/
function(module, __unused_webpack_exports, __webpack_require__) {
var DevExpress = __webpack_require__( /*! ../../../bundles/modules/core */ 36991);
__webpack_require__( /*! ../../../integration/jquery */ 78475);
__webpack_require__( /*! ../../../integration/angular */ 71582);
__webpack_require__( /*! ../../../integration/knockout */ 49281);
__webpack_require__( /*! ../../../localization/globalize/core */ 74872);
__webpack_require__( /*! ../../../localization/globalize/message */ 46949);
__webpack_require__( /*! ../../../localization/globalize/number */ 908);
__webpack_require__( /*! ../../../localization/globalize/date */ 60316);
__webpack_require__( /*! ../../../localization/globalize/currency */ 7239);
__webpack_require__( /*! ../../../events/click */ 95429);
__webpack_require__( /*! ../../../events/contextmenu */ 49166);
__webpack_require__( /*! ../../../events/double_click */ 85272);
__webpack_require__( /*! ../../../events/drag */ 23174);
__webpack_require__( /*! ../../../events/hold */ 11699);
__webpack_require__( /*! ../../../events/hover */ 24028);
__webpack_require__( /*! ../../../events/pointer */ 93786);
__webpack_require__( /*! ../../../events/swipe */ 34309);
__webpack_require__( /*! ../../../events/transform */ 91093);
module.exports = DevExpress
},
94620:
/*!***************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/bundles/modules/parts/data.js ***!
\***************************************************************************/
function(module, __unused_webpack_exports, __webpack_require__) {
var DevExpress = __webpack_require__( /*! ./core */ 85357);
var data = DevExpress.data = __webpack_require__( /*! ../../../bundles/modules/data */ 86635);
data.odata = __webpack_require__( /*! ../../../bundles/modules/data.odata */ 72343);
module.exports = data
},
70527:
/*!**************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/bundles/modules/parts/file_management.js ***!
\**************************************************************************************/
function(module, __unused_webpack_exports, __webpack_require__) {
var _core = (obj = __webpack_require__( /*! ./core */ 85357), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var fileManagement = __webpack_require__( /*! ../../../bundles/modules/file_management */ 56208);
_core.default.fileManagement = fileManagement;
module.exports = fileManagement
},
66312:
/*!**************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/bundles/modules/parts/viz.js ***!
\**************************************************************************/
function(module, __unused_webpack_exports, __webpack_require__) {
var DevExpress = __webpack_require__( /*! ./core */ 85357);
__webpack_require__( /*! ./data */ 94620);
__webpack_require__( /*! ../common.charts */ 72505);
var viz = DevExpress.viz = __webpack_require__( /*! ../../../bundles/modules/viz */ 20802);
viz.currentTheme = __webpack_require__( /*! ../../../viz/themes */ 86231).currentTheme;
viz.registerTheme = __webpack_require__( /*! ../../../viz/themes */ 86231).registerTheme;
viz.exportFromMarkup = __webpack_require__( /*! ../../../viz/export */ 5259).exportFromMarkup;
viz.getMarkup = __webpack_require__( /*! ../../../viz/export */ 5259).getMarkup;
viz.exportWidgets = __webpack_require__( /*! ../../../viz/export */ 5259).exportWidgets;
viz.currentPalette = __webpack_require__( /*! ../../../viz/palette */ 23696).currentPalette;
viz.getPalette = __webpack_require__( /*! ../../../viz/palette */ 23696).getPalette;
viz.generateColors = __webpack_require__( /*! ../../../viz/palette */ 23696).generateColors;
viz.registerPalette = __webpack_require__( /*! ../../../viz/palette */ 23696).registerPalette;
viz.refreshTheme = __webpack_require__( /*! ../../../viz/themes */ 86231).refreshTheme;
viz.dxChart = __webpack_require__( /*! ../../../viz/chart */ 99511);
viz.dxPieChart = __webpack_require__( /*! ../../../viz/pie_chart */ 72111);
viz.dxPolarChart = __webpack_require__( /*! ../../../viz/polar_chart */ 80919);
viz.dxLinearGauge = __webpack_require__( /*! ../../../viz/linear_gauge */ 99630);
viz.dxCircularGauge = __webpack_require__( /*! ../../../viz/circular_gauge */ 39847);
viz.dxBarGauge = __webpack_require__( /*! ../../../viz/bar_gauge */ 45888);
viz.dxRangeSelector = __webpack_require__( /*! ../../../viz/range_selector */ 82879);
viz.dxVectorMap = __webpack_require__( /*! ../../../viz/vector_map */ 81849);
viz.map = {};
viz.map.sources = {};
viz.map.projection = __webpack_require__( /*! ../../../viz/vector_map/projection */ 102).projection;
viz.dxSparkline = __webpack_require__( /*! ../../../viz/sparkline */ 43759);
viz.dxBullet = __webpack_require__( /*! ../../../viz/bullet */ 88950);
viz.dxTreeMap = __webpack_require__( /*! ../../../viz/tree_map */ 15584);
viz.dxFunnel = __webpack_require__( /*! ../../../viz/funnel */ 30187);
viz.dxSankey = __webpack_require__( /*! ../../../viz/sankey */ 34377);
viz.BaseWidget = __webpack_require__( /*! ../../../viz/core/base_widget */ 59063);
viz.getTheme = __webpack_require__( /*! ../../../viz/themes */ 86231).getTheme;
viz.findTheme = __webpack_require__( /*! ../../../viz/themes */ 86231).getTheme;
viz.refreshAll = __webpack_require__( /*! ../../../viz/themes */ 86231).refreshTheme;
viz.refreshPaths = __webpack_require__( /*! ../../../viz/utils */ 34434).refreshPaths;
viz.gauges = {
__internals: {}
};
viz._dashboard = {};
viz._dashboard.Renderer = __webpack_require__( /*! ../../../viz/core/renderers/renderer */ 56453).Renderer;
viz._dashboard.SvgElement = __webpack_require__( /*! ../../../viz/core/renderers/renderer */ 56453).SvgElement;
viz._dashboard.patchFontOptions = __webpack_require__( /*! ../../../viz/core/utils */ 19157).patchFontOptions;
module.exports = viz
},
50779:
/*!***********************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/bundles/modules/parts/widgets-base.js ***!
\***********************************************************************************/
function(module, __unused_webpack_exports, __webpack_require__) {
var DevExpress = __webpack_require__( /*! ./core */ 85357);
__webpack_require__( /*! ./data */ 94620);
__webpack_require__( /*! ./file_management */ 70527);
var ui = DevExpress.ui = __webpack_require__( /*! ../../../bundles/modules/ui */ 26864);
ui.themes = __webpack_require__( /*! ../../../ui/themes */ 75811);
ui.setTemplateEngine = __webpack_require__( /*! ../../../core/templates/template_engine_registry */ 72987).setTemplateEngine;
ui.dialog = __webpack_require__( /*! ../../../ui/dialog */ 15029);
ui.notify = __webpack_require__( /*! ../../../ui/notify */ 59958);
ui.repaintFloatingActionButton = __webpack_require__( /*! ../../../ui/speed_dial_action/repaint_floating_action_button */ 81374);
ui.hideToasts = __webpack_require__( /*! ../../../ui/toast/hide_toasts */ 33964);
ui.dxActionSheet = __webpack_require__( /*! ../../../ui/action_sheet */ 81476);
ui.dxAutocomplete = __webpack_require__( /*! ../../../ui/autocomplete */ 65418);
ui.dxBox = __webpack_require__( /*! ../../../ui/box */ 55551);
ui.dxButton = __webpack_require__( /*! ../../../ui/button */ 63008);
ui.dxDropDownButton = __webpack_require__( /*! ../../../ui/drop_down_button */ 45231);
ui.dxButtonGroup = __webpack_require__( /*! ../../../ui/button_group */ 28236);
ui.dxCalendar = __webpack_require__( /*! ../../../ui/calendar */ 26559);
ui.dxCheckBox = __webpack_require__( /*! ../../../ui/check_box */ 18859);
ui.dxColorBox = __webpack_require__( /*! ../../../ui/color_box */ 4278);
ui.dxDateBox = __webpack_require__( /*! ../../../ui/date_box */ 29589);
ui.dxDateRangeBox = __webpack_require__( /*! ../../../ui/date_range_box */ 56258);
ui.dxDrawer = __webpack_require__( /*! ../../../ui/drawer */ 45065);
ui.dxDeferRendering = __webpack_require__( /*! ../../../ui/defer_rendering */ 28414);
ui.dxDropDownBox = __webpack_require__( /*! ../../../ui/drop_down_box */ 36646);
ui.dxFileUploader = __webpack_require__( /*! ../../../ui/file_uploader */ 53749);
ui.dxForm = __webpack_require__( /*! ../../../ui/form */ 17737);
ui.dxGallery = __webpack_require__( /*! ../../../ui/gallery */ 49433);
ui.dxHtmlEditor = __webpack_require__( /*! ../../../ui/html_editor */ 9619);
ui.dxList = __webpack_require__( /*! ../../../ui/list */ 86e3);
ui.dxLoadIndicator = __webpack_require__( /*! ../../../ui/load_indicator */ 2492);
ui.dxLoadPanel = __webpack_require__( /*! ../../../ui/load_panel */ 97218);
ui.dxLookup = __webpack_require__( /*! ../../../ui/lookup */ 55935);
ui.dxMap = __webpack_require__( /*! ../../../ui/map */ 64304);
ui.dxMultiView = __webpack_require__( /*! ../../../ui/multi_view */ 86478);
ui.dxNumberBox = __webpack_require__( /*! ../../../ui/number_box */ 34171);
ui.dxOverlay = __webpack_require__( /*! ../../../ui/overlay/ui.overlay */ 89799);
ui.dxPopover = __webpack_require__( /*! ../../../ui/popover */ 22348);
ui.dxPopup = __webpack_require__( /*! ../../../ui/popup */ 39114);
ui.dxProgressBar = __webpack_require__( /*! ../../../ui/progress_bar */ 28080);
ui.dxRadioGroup = __webpack_require__( /*! ../../../ui/radio_group */ 14305);
ui.dxRangeSlider = __webpack_require__( /*! ../../../ui/range_slider */ 36992);
ui.dxResizable = __webpack_require__( /*! ../../../ui/resizable */ 46743);
ui.dxResponsiveBox = __webpack_require__( /*! ../../../ui/responsive_box */ 21643);
ui.dxScrollView = __webpack_require__( /*! ../../../ui/scroll_view */ 4741);
ui.dxSelectBox = __webpack_require__( /*! ../../../ui/select_box */ 78665);
ui.dxSlider = __webpack_require__( /*! ../../../ui/slider */ 97834);
ui.dxSpeedDialAction = __webpack_require__( /*! ../../../ui/speed_dial_action */ 17017);
ui.dxSwitch = __webpack_require__( /*! ../../../ui/switch */ 31609);
ui.dxTabPanel = __webpack_require__( /*! ../../../ui/tab_panel */ 21807);
ui.dxTabs = __webpack_require__( /*! ../../../ui/tabs */ 13453);
ui.dxTagBox = __webpack_require__( /*! ../../../ui/tag_box */ 31362);
ui.dxTextArea = __webpack_require__( /*! ../../../ui/text_area */ 51237);
ui.dxTextBox = __webpack_require__( /*! ../../../ui/text_box */ 29837);
ui.dxTileView = __webpack_require__( /*! ../../../ui/tile_view */ 93094);
ui.dxToast = __webpack_require__( /*! ../../../ui/toast */ 37748);
ui.dxToolbar = __webpack_require__( /*! ../../../ui/toolbar */ 71042);
ui.dxTooltip = __webpack_require__( /*! ../../../ui/tooltip */ 94920);
ui.dxTrackBar = __webpack_require__( /*! ../../../ui/track_bar */ 39661);
ui.dxDraggable = __webpack_require__( /*! ../../../ui/draggable */ 42160);
ui.dxSortable = __webpack_require__( /*! ../../../ui/sortable */ 66843);
DevExpress.validationEngine = __webpack_require__( /*! ../../../ui/validation_engine */ 90964);
ui.dxValidationSummary = __webpack_require__( /*! ../../../ui/validation_summary */ 97289);
ui.dxValidationGroup = __webpack_require__( /*! ../../../ui/validation_group */ 4401);
ui.dxValidator = __webpack_require__( /*! ../../../ui/validator */ 39562);
__webpack_require__( /*! ../../../ui/html_editor/converters/markdown */ 52935);
ui.CollectionWidget = __webpack_require__( /*! ../../../ui/collection/ui.collection_widget.edit */ 11050);
ui.dxDropDownEditor = __webpack_require__( /*! ../../../ui/drop_down_editor/ui.drop_down_editor */ 44687);
module.exports = ui
},
2025:
/*!**********************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/bundles/modules/parts/widgets-web.js ***!
\**********************************************************************************/
function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var data = __webpack_require__( /*! ./data */ 94620);
var ui = __webpack_require__( /*! ./widgets-base */ 50779);
ui.dxAccordion = __webpack_require__( /*! ../../../ui/accordion */ 76219);
ui.dxContextMenu = __webpack_require__( /*! ../../../ui/context_menu */ 10042);
ui.dxDataGrid = __webpack_require__( /*! ../../../ui/data_grid */ 1186);
ui.dxTreeList = __webpack_require__( /*! ../../../ui/tree_list */ 82655);
ui.dxMenu = __webpack_require__( /*! ../../../ui/menu */ 76995);
ui.dxPivotGrid = __webpack_require__( /*! ../../../ui/pivot_grid */ 96089);
ui.dxPivotGridFieldChooser = __webpack_require__( /*! ../../../ui/pivot_grid_field_chooser */ 32014);
data.PivotGridDataSource = __webpack_require__( /*! ../../../ui/pivot_grid/data_source */ 98713);
data.XmlaStore = __webpack_require__( /*! ../../../ui/pivot_grid/xmla_store */ 9170);
ui.dxScheduler = __webpack_require__( /*! ../../../ui/scheduler */ 9508);
ui.dxTreeView = __webpack_require__( /*! ../../../ui/tree_view */ 30254);
ui.dxFilterBuilder = __webpack_require__( /*! ../../../ui/filter_builder */ 20301);
ui.dxFileManager = __webpack_require__( /*! ../../../ui/file_manager */ 87446);
ui.dxDiagram = __webpack_require__( /*! ../../../ui/diagram */ 52311);
ui.dxGantt = __webpack_require__( /*! ../../../ui/gantt */ 33465)
},
26864:
/*!*******************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/bundles/modules/ui.js ***!
\*******************************************************************/
function(module, __unused_webpack_exports, __webpack_require__) {
__webpack_require__( /*! ./core */ 36991);
module.exports = DevExpress.ui = {}
},
20802:
/*!********************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/bundles/modules/viz.js ***!
\********************************************************************/
function(module, __unused_webpack_exports, __webpack_require__) {
__webpack_require__( /*! ./core */ 36991);
module.exports = DevExpress.viz = DevExpress.viz || {}
},
52752:
/*!******************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/color.js ***!
\******************************************************/
function(module, exports) {
exports.default = void 0;
var standardColorNames = {
aliceblue: "f0f8ff",
antiquewhite: "faebd7",
aqua: "00ffff",
aquamarine: "7fffd4",
azure: "f0ffff",
beige: "f5f5dc",
bisque: "ffe4c4",
black: "000000",
blanchedalmond: "ffebcd",
blue: "0000ff",
blueviolet: "8a2be2",
brown: "a52a2a",
burlywood: "deb887",
cadetblue: "5f9ea0",
chartreuse: "7fff00",
chocolate: "d2691e",
coral: "ff7f50",
cornflowerblue: "6495ed",
cornsilk: "fff8dc",
crimson: "dc143c",
cyan: "00ffff",
darkblue: "00008b",
darkcyan: "008b8b",
darkgoldenrod: "b8860b",
darkgray: "a9a9a9",
darkgreen: "006400",
darkgrey: "a9a9a9",
darkkhaki: "bdb76b",
darkmagenta: "8b008b",
darkolivegreen: "556b2f",
darkorange: "ff8c00",
darkorchid: "9932cc",
darkred: "8b0000",
darksalmon: "e9967a",
darkseagreen: "8fbc8f",
darkslateblue: "483d8b",
darkslategray: "2f4f4f",
darkslategrey: "2f4f4f",
darkturquoise: "00ced1",
darkviolet: "9400d3",
deeppink: "ff1493",
deepskyblue: "00bfff",
dimgray: "696969",
dimgrey: "696969",
dodgerblue: "1e90ff",
feldspar: "d19275",
firebrick: "b22222",
floralwhite: "fffaf0",
forestgreen: "228b22",
fuchsia: "ff00ff",
gainsboro: "dcdcdc",
ghostwhite: "f8f8ff",
gold: "ffd700",
goldenrod: "daa520",
gray: "808080",
green: "008000",
greenyellow: "adff2f",
grey: "808080",
honeydew: "f0fff0",
hotpink: "ff69b4",
indianred: "cd5c5c",
indigo: "4b0082",
ivory: "fffff0",
khaki: "f0e68c",
lavender: "e6e6fa",
lavenderblush: "fff0f5",
lawngreen: "7cfc00",
lemonchiffon: "fffacd",
lightblue: "add8e6",
lightcoral: "f08080",
lightcyan: "e0ffff",
lightgoldenrodyellow: "fafad2",
lightgray: "d3d3d3",
lightgreen: "90ee90",
lightgrey: "d3d3d3",
lightpink: "ffb6c1",
lightsalmon: "ffa07a",
lightseagreen: "20b2aa",
lightskyblue: "87cefa",
lightslateblue: "8470ff",
lightslategray: "778899",
lightslategrey: "778899",
lightsteelblue: "b0c4de",
lightyellow: "ffffe0",
lime: "00ff00",
limegreen: "32cd32",
linen: "faf0e6",
magenta: "ff00ff",
maroon: "800000",
mediumaquamarine: "66cdaa",
mediumblue: "0000cd",
mediumorchid: "ba55d3",
mediumpurple: "9370d8",
mediumseagreen: "3cb371",
mediumslateblue: "7b68ee",
mediumspringgreen: "00fa9a",
mediumturquoise: "48d1cc",
mediumvioletred: "c71585",
midnightblue: "191970",
mintcream: "f5fffa",
mistyrose: "ffe4e1",
moccasin: "ffe4b5",
navajowhite: "ffdead",
navy: "000080",
oldlace: "fdf5e6",
olive: "808000",
olivedrab: "6b8e23",
orange: "ffa500",
orangered: "ff4500",
orchid: "da70d6",
palegoldenrod: "eee8aa",
palegreen: "98fb98",
paleturquoise: "afeeee",
palevioletred: "d87093",
papayawhip: "ffefd5",
peachpuff: "ffdab9",
peru: "cd853f",
pink: "ffc0cb",
plum: "dda0dd",
powderblue: "b0e0e6",
purple: "800080",
rebeccapurple: "663399",
red: "ff0000",
rosybrown: "bc8f8f",
royalblue: "4169e1",
saddlebrown: "8b4513",
salmon: "fa8072",
sandybrown: "f4a460",
seagreen: "2e8b57",
seashell: "fff5ee",
sienna: "a0522d",
silver: "c0c0c0",
skyblue: "87ceeb",
slateblue: "6a5acd",
slategray: "708090",
slategrey: "708090",
snow: "fffafa",
springgreen: "00ff7f",
steelblue: "4682b4",
tan: "d2b48c",
teal: "008080",
thistle: "d8bfd8",
tomato: "ff6347",
turquoise: "40e0d0",
violet: "ee82ee",
violetred: "d02090",
wheat: "f5deb3",
white: "ffffff",
whitesmoke: "f5f5f5",
yellow: "ffff00",
yellowgreen: "9acd32"
};
var standardColorTypes = [{
re: /^rgb\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\)$/,
process: function(colorString) {
return [parseInt(colorString[1], 10), parseInt(colorString[2], 10), parseInt(colorString[3], 10)]
}
}, {
re: /^rgba\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3}),\s*(\d*\.*\d+)\)$/,
process: function(colorString) {
return [parseInt(colorString[1], 10), parseInt(colorString[2], 10), parseInt(colorString[3], 10), parseFloat(colorString[4])]
}
}, {
re: /^#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})$/,
process: function(colorString) {
return [parseInt(colorString[1], 16), parseInt(colorString[2], 16), parseInt(colorString[3], 16)]
}
}, {
re: /^#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})$/,
process: function(colorString) {
return [parseInt(colorString[1], 16), parseInt(colorString[2], 16), parseInt(colorString[3], 16), Number((parseInt(colorString[4], 16) / 255).toFixed(2))]
}
}, {
re: /^#([a-f0-9]{1})([a-f0-9]{1})([a-f0-9]{1})([a-f0-9]{1})$/,
process: function(colorString) {
return [parseInt(colorString[1] + colorString[1], 16), parseInt(colorString[2] + colorString[2], 16), parseInt(colorString[3] + colorString[3], 16), Number((parseInt(colorString[4] + colorString[4], 16) / 255).toFixed(2))]
}
}, {
re: /^#([a-f0-9]{1})([a-f0-9]{1})([a-f0-9]{1})$/,
process: function(colorString) {
return [parseInt(colorString[1] + colorString[1], 16), parseInt(colorString[2] + colorString[2], 16), parseInt(colorString[3] + colorString[3], 16)]
}
}, {
re: /^hsv\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\)$/,
process: function(colorString) {
var h = parseInt(colorString[1], 10);
var s = parseInt(colorString[2], 10);
var v = parseInt(colorString[3], 10);
var rgb = hsvToRgb(h, s, v);
return [rgb[0], rgb[1], rgb[2], 1, [h, s, v]]
}
}, {
re: /^hsl\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\)$/,
process: function(colorString) {
var h = parseInt(colorString[1], 10);
var s = parseInt(colorString[2], 10);
var l = parseInt(colorString[3], 10);
var rgb = hslToRgb(h, s, l);
return [rgb[0], rgb[1], rgb[2], 1, null, [h, s, l]]
}
}];
var _round = Math.round;
function Color(value) {
this.baseColor = value;
var color;
if (value) {
color = String(value).toLowerCase().replace(/ /g, "");
color = standardColorNames[color] ? "#" + standardColorNames[color] : color;
color = function(color) {
if ("transparent" === color) {
return [0, 0, 0, 0]
}
var i = 0;
var ii = standardColorTypes.length;
var str;
for (; i < ii; ++i) {
str = standardColorTypes[i].re.exec(color);
if (str) {
return standardColorTypes[i].process(str)
}
}
return null
}(color)
}
if (!color) {
this.colorIsInvalid = true
}
color = color || {};
this.r = normalize(color[0]);
this.g = normalize(color[1]);
this.b = normalize(color[2]);
this.a = normalize(color[3], 1, 1);
if (color[4]) {
this.hsv = {
h: color[4][0],
s: color[4][1],
v: color[4][2]
}
} else {
this.hsv = function(r, g, b) {
var max = Math.max(r, g, b);
var min = Math.min(r, g, b);
var delta = max - min;
var H;
var S;
var V = max;
S = 0 === max ? 0 : 1 - min / max;
if (max === min) {
H = 0
} else {
switch (max) {
case r:
H = (g - b) / delta * 60;
if (g < b) {
H += 360
}
break;
case g:
H = (b - r) / delta * 60 + 120;
break;
case b:
H = (r - g) / delta * 60 + 240
}
}
S *= 100;
V *= 100 / 255;
return {
h: Math.round(H),
s: Math.round(S),
v: Math.round(V)
}
}(this.r, this.g, this.b)
}
if (color[5]) {
this.hsl = {
h: color[5][0],
s: color[5][1],
l: color[5][2]
}
} else {
this.hsl = function(r, g, b) {
r = convertTo01Bounds(r, 255);
g = convertTo01Bounds(g, 255);
b = convertTo01Bounds(b, 255);
var max = Math.max(r, g, b);
var min = Math.min(r, g, b);
var maxMinSum = max + min;
var h;
var s;
var l = maxMinSum / 2;
if (max === min) {
h = s = 0
} else {
var delta = max - min;
if (l > .5) {
s = delta / (2 - maxMinSum)
} else {
s = delta / maxMinSum
}
h = function(r, g, b, delta) {
var max = Math.max(r, g, b);
switch (max) {
case r:
return (g - b) / delta + (g < b ? 6 : 0);
case g:
return (b - r) / delta + 2;
case b:
return (r - g) / delta + 4
}
}(r, g, b, delta);
h /= 6
}
return {
h: _round(360 * h),
s: _round(100 * s),
l: _round(100 * l)
}
}(this.r, this.g, this.b)
}
}
function normalize(colorComponent, def, max) {
def = def || 0;
max = max || 255;
return colorComponent < 0 || isNaN(colorComponent) ? def : colorComponent > max ? max : colorComponent
}
function hsvToRgb(h, s, v) {
var index = Math.floor(h % 360 / 60);
var vMin = (100 - s) * v / 100;
var a = h % 60 / 60 * (v - vMin);
var vInc = vMin + a;
var vDec = v - a;
var r;
var g;
var b;
switch (index) {
case 0:
r = v;
g = vInc;
b = vMin;
break;
case 1:
r = vDec;
g = v;
b = vMin;
break;
case 2:
r = vMin;
g = v;
b = vInc;
break;
case 3:
r = vMin;
g = vDec;
b = v;
break;
case 4:
r = vInc;
g = vMin;
b = v;
break;
case 5:
r = v;
g = vMin;
b = vDec
}
return [Math.round(2.55 * r), Math.round(2.55 * g), Math.round(2.55 * b)]
}
function makeColorTint(colorPart, h) {
var colorTint = h;
if ("r" === colorPart) {
colorTint = h + 1 / 3
}
if ("b" === colorPart) {
colorTint = h - 1 / 3
}
return colorTint
}
function hueToRgb(p, q, colorTint) {
colorTint = function(colorTint) {
if (colorTint < 0) {
colorTint += 1
}
if (colorTint > 1) {
colorTint -= 1
}
return colorTint
}(colorTint);
if (colorTint < 1 / 6) {
return p + 6 * (q - p) * colorTint
}
if (colorTint < .5) {
return q
}
if (colorTint < 2 / 3) {
return p + (q - p) * (2 / 3 - colorTint) * 6
}
return p
}
function hslToRgb(h, s, l) {
var r;
var g;
var b;
h = convertTo01Bounds(h, 360);
s = convertTo01Bounds(s, 100);
l = convertTo01Bounds(l, 100);
if (0 === s) {
r = g = b = l
} else {
var q = l < .5 ? l * (1 + s) : l + s - l * s;
var p = 2 * l - q;
r = hueToRgb(p, q, makeColorTint("r", h));
g = hueToRgb(p, q, makeColorTint("g", h));
b = hueToRgb(p, q, makeColorTint("b", h))
}
return [_round(255 * r), _round(255 * g), _round(255 * b)]
}
function convertTo01Bounds(n, max) {
n = Math.min(max, Math.max(0, parseFloat(n)));
if (Math.abs(n - max) < 1e-6) {
return 1
}
return n % max / parseFloat(max)
}
function isIntegerBetweenMinAndMax(number, min, max) {
min = min || 0;
max = max || 255;
if (number % 1 !== 0 || number < min || number > max || "number" !== typeof number || isNaN(number)) {
return false
}
return true
}
Color.prototype = {
constructor: Color,
highlight: function(step) {
step = step || 10;
return this.alter(step).toHex()
},
darken: function(step) {
step = step || 10;
return this.alter(-step).toHex()
},
alter: function(step) {
var result = new Color;
result.r = normalize(this.r + step);
result.g = normalize(this.g + step);
result.b = normalize(this.b + step);
return result
},
blend: function(blendColor, opacity) {
var other = blendColor instanceof Color ? blendColor : new Color(blendColor);
var result = new Color;
result.r = normalize(_round(this.r * (1 - opacity) + other.r * opacity));
result.g = normalize(_round(this.g * (1 - opacity) + other.g * opacity));
result.b = normalize(_round(this.b * (1 - opacity) + other.b * opacity));
return result
},
toHex: function() {
return r = this.r, g = this.g, b = this.b, "#" + (16777216 | r << 16 | g << 8 | b).toString(16).slice(1);
var r, g, b
},
getPureColor: function() {
var rgb = hsvToRgb(this.hsv.h, 100, 100);
return new Color("rgb(" + rgb.join(",") + ")")
},
isValidHex: function(hex) {
return /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(hex)
},
isValidRGB: function(r, g, b) {
if (!isIntegerBetweenMinAndMax(r) || !isIntegerBetweenMinAndMax(g) || !isIntegerBetweenMinAndMax(b)) {
return false
}
return true
},
isValidAlpha: function(a) {
if (isNaN(a) || a < 0 || a > 1 || "number" !== typeof a) {
return false
}
return true
},
colorIsInvalid: false,
fromHSL: function(hsl) {
var color = new Color;
var rgb = hslToRgb(hsl.h, hsl.s, hsl.l);
color.r = rgb[0];
color.g = rgb[1];
color.b = rgb[2];
return color
}
};
var _default = Color;
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
29932:
/*!**************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/common/charts.js ***!
\**************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.registerPattern = exports.registerGradient = exports.getGraphicObjects = void 0;
var _utils = __webpack_require__( /*! ../viz/core/utils */ 19157);
function _extends() {
_extends = Object.assign ? Object.assign.bind() : 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)
}
var graphicObjects = {};
exports.registerPattern = function(options) {
var id = (0, _utils.getNextDefsSvgId)();
graphicObjects[id] = _extends({
type: "pattern"
}, options);
return id
};
exports.registerGradient = function(type, options) {
var id = (0, _utils.getNextDefsSvgId)();
graphicObjects[id] = _extends({
type: type
}, options);
return id
};
exports.getGraphicObjects = function() {
return graphicObjects
}
},
62414:
/*!************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/action.js ***!
\************************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _renderer = (obj = __webpack_require__( /*! ./renderer */ 68374), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var _window = __webpack_require__( /*! ./utils/window */ 58201);
var _type = __webpack_require__( /*! ./utils/type */ 35922);
var _iterator = __webpack_require__( /*! ./utils/iterator */ 95479);
var Action = function() {
function Action(action, config) {
config = config || {};
this._action = action;
this._context = config.context || (0, _window.getWindow)();
this._beforeExecute = config.beforeExecute;
this._afterExecute = config.afterExecute;
this._component = config.component;
this._validatingTargetName = config.validatingTargetName;
var excludeValidators = this._excludeValidators = {};
if (config.excludeValidators) {
for (var i = 0; i < config.excludeValidators.length; i++) {
excludeValidators[config.excludeValidators[i]] = true
}
}
}
var _proto = Action.prototype;
_proto.execute = function() {
var e = {
action: this._action,
args: Array.prototype.slice.call(arguments),
context: this._context,
component: this._component,
validatingTargetName: this._validatingTargetName,
cancel: false,
handled: false
};
var beforeExecute = this._beforeExecute;
var afterExecute = this._afterExecute;
var argsBag = e.args[0] || {};
if (!this._validateAction(e)) {
return
}
null === beforeExecute || void 0 === beforeExecute ? void 0 : beforeExecute.call(this._context, e);
if (e.cancel) {
return
}
var result = this._executeAction(e);
if (argsBag.cancel) {
return
}
null === afterExecute || void 0 === afterExecute ? void 0 : afterExecute.call(this._context, e);
return result
};
_proto._validateAction = function(e) {
var excludeValidators = this._excludeValidators;
var executors = Action.executors;
for (var name in executors) {
if (!excludeValidators[name]) {
var _executor$validate;
var executor = executors[name];
null === (_executor$validate = executor.validate) || void 0 === _executor$validate ? void 0 : _executor$validate.call(executor, e);
if (e.cancel) {
return false
}
}
}
return true
};
_proto._executeAction = function(e) {
var result;
var executors = Action.executors;
for (var name in executors) {
var _executor$execute;
var executor = executors[name];
null === (_executor$execute = executor.execute) || void 0 === _executor$execute ? void 0 : _executor$execute.call(executor, e);
if (e.handled) {
result = e.result;
break
}
}
return result
};
Action.registerExecutor = function(name, executor) {
if ((0, _type.isPlainObject)(name)) {
(0, _iterator.each)(name, Action.registerExecutor);
return
}
Action.executors[name] = executor
};
Action.unregisterExecutor = function() {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key]
}(0, _iterator.each)(args, (function() {
delete Action.executors[this]
}))
};
return Action
}();
exports.default = Action;
Action.executors = {};
var createValidatorByTargetElement = function(condition) {
return function(e) {
if (!e.args.length) {
return
}
var args = e.args[0];
var element = args[e.validatingTargetName] || args.element;
if (element && condition((0, _renderer.default)(element))) {
e.cancel = true
}
}
};
Action.registerExecutor({
disabled: {
validate: createValidatorByTargetElement((function($target) {
return $target.is(".dx-state-disabled, .dx-state-disabled *")
}))
},
readOnly: {
validate: createValidatorByTargetElement((function($target) {
return $target.is(".dx-state-readonly, .dx-state-readonly *:not(.dx-state-independent)")
}))
},
undefined: {
execute: function(e) {
if (!e.action) {
e.result = void 0;
e.handled = true
}
}
},
func: {
execute: function(e) {
if ((0, _type.isFunction)(e.action)) {
e.result = e.action.call(e.context, e.args[0]);
e.handled = true
}
}
}
});
module.exports = exports.default;
module.exports.default = exports.default
},
38377:
/*!***********************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/class.js ***!
\***********************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _errors = (obj = __webpack_require__( /*! ./errors */ 17381), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var _type = __webpack_require__( /*! ./utils/type */ 35922);
var wrapOverridden = function(baseProto, methodName, method) {
return function() {
var prevCallBase = this.callBase;
this.callBase = baseProto[methodName];
try {
return method.apply(this, arguments)
} finally {
this.callBase = prevCallBase
}
}
};
var redefine = function(members) {
var overridden;
var memberName;
var member;
if (!members) {
return this
}
for (memberName in members) {
member = members[memberName];
overridden = "function" === typeof this.prototype[memberName] && "function" === typeof member;
this.prototype[memberName] = overridden ? wrapOverridden(this.parent.prototype, memberName, member) : member
}
return this
};
var include = function() {
var classObj = this;
var argument;
var name;
var i;
var hasClassObjOwnProperty = Object.prototype.hasOwnProperty.bind(classObj);
var isES6Class = !hasClassObjOwnProperty("_includedCtors") && !hasClassObjOwnProperty("_includedPostCtors");
if (isES6Class) {
classObj._includedCtors = classObj._includedCtors.slice(0);
classObj._includedPostCtors = classObj._includedPostCtors.slice(0)
}
for (i = 0; i < arguments.length; i++) {
argument = arguments[i];
if (argument.ctor) {
classObj._includedCtors.push(argument.ctor)
}
if (argument.postCtor) {
classObj._includedPostCtors.push(argument.postCtor)
}
for (name in argument) {
if ("ctor" === name || "postCtor" === name || "default" === name) {
continue
}
classObj.prototype[name] = argument[name]
}
}
return classObj
};
var subclassOf = function(parentClass) {
var hasParentProperty = Object.prototype.hasOwnProperty.bind(this)("parent");
var isES6Class = !hasParentProperty && this.parent;
if (isES6Class) {
var baseClass = Object.getPrototypeOf(this);
return baseClass === parentClass || baseClass.subclassOf(parentClass)
} else {
if (this.parent === parentClass) {
return true
}
if (!this.parent || !this.parent.subclassOf) {
return false
}
return this.parent.subclassOf(parentClass)
}
};
var abstract = function() {
throw _errors.default.Error("E0001")
};
var copyStatic = (hasOwn = Object.prototype.hasOwnProperty, function(source, destination) {
for (var key in source) {
if (!hasOwn.call(source, key)) {
return
}
destination[key] = source[key]
}
});
var hasOwn;
var classImpl = function() {};
classImpl.inherit = function(members) {
var inheritor = function() {
if (!this || (0, _type.isWindow)(this) || "function" !== typeof this.constructor) {
throw _errors.default.Error("E0003")
}
var instance = this;
var ctor = instance.ctor;
var includedCtors = instance.constructor._includedCtors;
var includedPostCtors = instance.constructor._includedPostCtors;
var i;
for (i = 0; i < includedCtors.length; i++) {
includedCtors[i].call(instance)
}
if (ctor) {
ctor.apply(instance, arguments)
}
for (i = 0; i < includedPostCtors.length; i++) {
includedPostCtors[i].call(instance)
}
};
inheritor.prototype = function(obj) {
var func = function() {};
func.prototype = obj.prototype;
return new func
}(this);
copyStatic(this, inheritor);
inheritor.inherit = this.inherit;
inheritor.abstract = abstract;
inheritor.redefine = redefine;
inheritor.include = include;
inheritor.subclassOf = subclassOf;
inheritor.parent = this;
inheritor._includedCtors = this._includedCtors ? this._includedCtors.slice(0) : [];
inheritor._includedPostCtors = this._includedPostCtors ? this._includedPostCtors.slice(0) : [];
inheritor.prototype.constructor = inheritor;
inheritor.redefine(members);
return inheritor
};
classImpl.abstract = abstract;
var _default = classImpl;
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
44297:
/*!***************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/component.js ***!
\***************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.Component = void 0;
var _config = _interopRequireDefault(__webpack_require__( /*! ./config */ 80209));
var _extend = __webpack_require__( /*! ./utils/extend */ 13306);
var _index = __webpack_require__( /*! ./options/index */ 95683);
var _utils = __webpack_require__( /*! ./options/utils */ 45434);
var _class = _interopRequireDefault(__webpack_require__( /*! ./class */ 38377));
var _action = _interopRequireDefault(__webpack_require__( /*! ./action */ 62414));
var _errors = _interopRequireDefault(__webpack_require__( /*! ./errors */ 17381));
var _callbacks = _interopRequireDefault(__webpack_require__( /*! ./utils/callbacks */ 44504));
var _events_strategy = __webpack_require__( /*! ./events_strategy */ 80566);
var _public_component = __webpack_require__( /*! ./utils/public_component */ 9321);
var _postponed_operations = __webpack_require__( /*! ./postponed_operations */ 90889);
var _type = __webpack_require__( /*! ./utils/type */ 35922);
var _common = __webpack_require__( /*! ./utils/common */ 20576);
var _data = __webpack_require__( /*! ./utils/data */ 47617);
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var getEventName = function(actionName) {
return actionName.charAt(2).toLowerCase() + actionName.substr(3)
};
var Component = _class.default.inherit({
_setDeprecatedOptions: function() {
this._deprecatedOptions = {}
},
_getDeprecatedOptions: function() {
return this._deprecatedOptions
},
_getDefaultOptions: function() {
return {
onInitialized: null,
onOptionChanged: null,
onDisposing: null,
defaultOptionsRules: null
}
},
_defaultOptionsRules: function() {
return []
},
_setOptionsByDevice: function(rules) {
this._options.applyRules(rules)
},
_convertRulesToOptions: function(rules) {
return (0, _utils.convertRulesToOptions)(rules)
},
_isInitialOptionValue: function(name) {
return this._options.isInitial(name)
},
_setOptionsByReference: function() {
this._optionsByReference = {}
},
_getOptionsByReference: function() {
return this._optionsByReference
},
ctor: function() {
var options = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {};
var _optionChangedCallbacks = options._optionChangedCallbacks,
_disposingCallbacks = options._disposingCallbacks;
this.NAME = (0, _public_component.name)(this.constructor);
this._eventsStrategy = _events_strategy.EventsStrategy.create(this, options.eventsStrategy);
this._updateLockCount = 0;
this._optionChangedCallbacks = _optionChangedCallbacks || (0, _callbacks.default)();
this._disposingCallbacks = _disposingCallbacks || (0, _callbacks.default)();
this.postponedOperations = new _postponed_operations.PostponedOperations;
this._createOptions(options)
},
_createOptions: function(options) {
var _this = this;
this.beginUpdate();
try {
this._setOptionsByReference();
this._setDeprecatedOptions();
this._options = new _index.Options(this._getDefaultOptions(), this._getDefaultOptions(), this._getOptionsByReference(), this._getDeprecatedOptions());
this._options.onChanging((function(name, previousValue, value) {
return _this._initialized && _this._optionChanging(name, previousValue, value)
}));
this._options.onDeprecated((function(option, info) {
return _this._logDeprecatedOptionWarning(option, info)
}));
this._options.onChanged((function(name, value, previousValue) {
return _this._notifyOptionChanged(name, value, previousValue)
}));
this._options.onStartChange((function() {
return _this.beginUpdate()
}));
this._options.onEndChange((function() {
return _this.endUpdate()
}));
this._options.addRules(this._defaultOptionsRules());
if (options && options.onInitializing) {
options.onInitializing.apply(this, [options])
}
this._setOptionsByDevice(options.defaultOptionsRules);
this._initOptions(options)
} finally {
this.endUpdate()
}
},
_initOptions: function(options) {
this.option(options)
},
_init: function() {
var _this2 = this;
this._createOptionChangedAction();
this.on("disposing", (function(args) {
_this2._disposingCallbacks.fireWith(_this2, [args])
}))
},
_logDeprecatedOptionWarning: function(option, info) {
var message = info.message || "Use the '".concat(info.alias, "' option instead");
_errors.default.log("W0001", this.NAME, option, info.since, message)
},
_logDeprecatedComponentWarning: function(since, alias) {
_errors.default.log("W0000", this.NAME, since, "Use the '".concat(alias, "' widget instead"))
},
_createOptionChangedAction: function() {
this._optionChangedAction = this._createActionByOption("onOptionChanged", {
excludeValidators: ["disabled", "readOnly"]
})
},
_createDisposingAction: function() {
this._disposingAction = this._createActionByOption("onDisposing", {
excludeValidators: ["disabled", "readOnly"]
})
},
_optionChanged: function(args) {
switch (args.name) {
case "onDisposing":
case "onInitialized":
break;
case "onOptionChanged":
this._createOptionChangedAction()
}
},
_dispose: function() {
this._optionChangedCallbacks.empty();
this._createDisposingAction();
this._disposingAction();
this._eventsStrategy.dispose();
this._options.dispose();
this._disposed = true
},
_lockUpdate: function() {
this._updateLockCount++
},
_unlockUpdate: function() {
this._updateLockCount = Math.max(this._updateLockCount - 1, 0)
},
_isUpdateAllowed: function() {
return 0 === this._updateLockCount
},
_isInitializingRequired: function() {
return !this._initializing && !this._initialized
},
isInitialized: function() {
return this._initialized
},
_commitUpdate: function() {
this.postponedOperations.callPostponedOperations();
this._isInitializingRequired() && this._initializeComponent()
},
_initializeComponent: function() {
this._initializing = true;
try {
this._init()
} finally {
this._initializing = false;
this._lockUpdate();
this._createActionByOption("onInitialized", {
excludeValidators: ["disabled", "readOnly"]
})();
this._unlockUpdate();
this._initialized = true
}
},
instance: function() {
return this
},
beginUpdate: function() {
this._lockUpdate()
},
endUpdate: function() {
this._unlockUpdate();
this._isUpdateAllowed() && this._commitUpdate()
},
_optionChanging: _common.noop,
_notifyOptionChanged: function(option, value, previousValue) {
if (this._initialized) {
var optionNames = [option].concat(this._options.getAliasesByName(option));
for (var i = 0; i < optionNames.length; i++) {
var name = optionNames[i];
var args = {
name: (0, _data.getPathParts)(name)[0],
fullName: name,
value: value,
previousValue: previousValue
};
if (!(optionName = name, 0 === optionName.indexOf("_", 0))) {
this._optionChangedCallbacks.fireWith(this, [(0, _extend.extend)(this._defaultActionArgs(), args)]);
this._optionChangedAction((0, _extend.extend)({}, args))
}
if (!this._disposed && this._cancelOptionChange !== name) {
this._optionChanged(args)
}
}
}
var optionName
},
initialOption: function(name) {
return this._options.initial(name)
},
_defaultActionConfig: function() {
return {
context: this,
component: this
}
},
_defaultActionArgs: function() {
return {
component: this
}
},
_createAction: function(actionSource, config) {
var _this3 = this;
var action;
return function(e) {
if (!(0, _type.isDefined)(e)) {
e = {}
}
if (!(0, _type.isPlainObject)(e)) {
e = {
actionValue: e
}
}
action = action || new _action.default(actionSource, (0, _extend.extend)(config, _this3._defaultActionConfig()));
return action.execute.call(action, (0, _extend.extend)(e, _this3._defaultActionArgs()))
}
},
_createActionByOption: function(optionName, config) {
var _this4 = this;
var action;
var eventName;
var actionFunc;
var result = function() {
if (!eventName) {
config = config || {};
if ("string" !== typeof optionName) {
throw _errors.default.Error("E0008")
}
if (0 === optionName.indexOf("on")) {
eventName = getEventName(optionName)
}
actionFunc = _this4.option(optionName)
}
if (!action && !actionFunc && !config.beforeExecute && !config.afterExecute && !_this4._eventsStrategy.hasEvent(eventName)) {
return
}
if (!action) {
var beforeExecute = config.beforeExecute;
config.beforeExecute = function() {
for (var _len2 = arguments.length, props = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
props[_key2] = arguments[_key2]
}
beforeExecute && beforeExecute.apply(_this4, props);
_this4._eventsStrategy.fireEvent(eventName, props[0].args)
};
action = _this4._createAction(actionFunc, config)
}
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key]
}
if ((0, _config.default)().wrapActionsBeforeExecute) {
var beforeActionExecute = _this4.option("beforeActionExecute") || _common.noop;
var wrappedAction = beforeActionExecute(_this4, action, config) || action;
return wrappedAction.apply(_this4, args)
}
return action.apply(_this4, args)
};
if ((0, _config.default)().wrapActionsBeforeExecute) {
return result
}
var onActionCreated = this.option("onActionCreated") || _common.noop;
return onActionCreated(this, result, config) || result
},
on: function(eventName, eventHandler) {
this._eventsStrategy.on(eventName, eventHandler);
return this
},
off: function(eventName, eventHandler) {
this._eventsStrategy.off(eventName, eventHandler);
return this
},
hasActionSubscription: function(actionName) {
return !!this._options.silent(actionName) || this._eventsStrategy.hasEvent(getEventName(actionName))
},
isOptionDeprecated: function(name) {
return this._options.isDeprecated(name)
},
_setOptionWithoutOptionChange: function(name, value) {
this._cancelOptionChange = name;
this.option(name, value);
this._cancelOptionChange = false
},
_getOptionValue: function(name, context) {
var value = this.option(name);
if ((0, _type.isFunction)(value)) {
return value.bind(context)()
}
return value
},
option: function() {
var _this$_options;
return (_this$_options = this._options).option.apply(_this$_options, arguments)
},
resetOption: function(name) {
this.beginUpdate();
this._options.reset(name);
this.endUpdate()
}
});
exports.Component = Component
},
99393:
/*!***************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/component_registrator.js ***!
\***************************************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _renderer = _interopRequireDefault(__webpack_require__( /*! ./renderer */ 68374));
var _component_registrator_callbacks = _interopRequireDefault(__webpack_require__( /*! ./component_registrator_callbacks */ 5554));
var _errors = _interopRequireDefault(__webpack_require__( /*! ./errors */ 17381));
var _public_component = __webpack_require__( /*! ./utils/public_component */ 9321);
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
_component_registrator_callbacks.default.add((function(name, componentClass) {
_renderer.default.fn[name] = function(options) {
var isMemberInvoke = "string" === typeof options;
var result;
if (isMemberInvoke) {
var memberName = options;
var memberArgs = [].slice.call(arguments).slice(1);
this.each((function() {
var instance = componentClass.getInstance(this);
if (!instance) {
throw _errors.default.Error("E0009", name)
}
var member = instance[memberName];
var memberValue = member.apply(instance, memberArgs);
if (void 0 === result) {
result = memberValue
}
}))
} else {
this.each((function() {
var instance = componentClass.getInstance(this);
if (instance) {
instance.option(options)
} else {
new componentClass(this, options)
}
}));
result = this
}
return result
}
}));
var _default = function(name, namespace, componentClass) {
if (!componentClass) {
componentClass = namespace
} else {
namespace[name] = componentClass
}(0, _public_component.name)(componentClass, name);
_component_registrator_callbacks.default.fire(name, componentClass)
};
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
5554:
/*!*************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/component_registrator_callbacks.js ***!
\*************************************************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _memorized_callbacks = (obj = __webpack_require__( /*! ./memorized_callbacks */ 83358), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var _default = new _memorized_callbacks.default;
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
80209:
/*!************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/config.js ***!
\************************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _extend = __webpack_require__( /*! ./utils/extend */ 13306);
var _errors = (obj = __webpack_require__( /*! ./errors */ 17381), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var config = {
rtlEnabled: false,
defaultCurrency: "USD",
defaultUseCurrencyAccountingStyle: true,
oDataFilterToLower: true,
serverDecimalSeparator: ".",
decimalSeparator: ".",
thousandsSeparator: ",",
forceIsoDateParsing: true,
wrapActionsBeforeExecute: true,
useLegacyStoreResult: false,
useJQuery: void 0,
editorStylingMode: void 0,
useLegacyVisibleIndex: false,
floatingActionButtonConfig: {
icon: "add",
closeIcon: "close",
label: "",
position: {
at: "right bottom",
my: "right bottom",
offset: {
x: -16,
y: -16
}
},
maxSpeedDialActionCount: 5,
shading: false,
direction: "auto"
},
optionsParser: function(optionsString) {
if ("{" !== optionsString.trim().charAt(0)) {
optionsString = "{" + optionsString + "}"
}
try {
return JSON.parse(optionsString)
} catch (ex) {
try {
return JSON.parse(normalizeToJSONString(optionsString))
} catch (exNormalize) {
throw _errors.default.Error("E3018", ex, optionsString)
}
}
}
};
var normalizeToJSONString = function(optionsString) {
return optionsString.replace(/'/g, '"').replace(/,\s*([\]}])/g, "$1").replace(/([{,])\s*([^":\s]+)\s*:/g, '$1"$2":')
};
var deprecatedFields = ["decimalSeparator", "thousandsSeparator"];
var configMethod = function() {
if (!arguments.length) {
return config
}
var newConfig = arguments.length <= 0 ? void 0 : arguments[0];
deprecatedFields.forEach((function(deprecatedField) {
if (newConfig[deprecatedField]) {
var message = "Now, the ".concat(deprecatedField, " is selected based on the specified locale.");
_errors.default.log("W0003", "config", deprecatedField, "19.2", message)
}
}));
(0, _extend.extend)(config, newConfig)
};
if ("undefined" !== typeof DevExpress && DevExpress.config) {
configMethod(DevExpress.config)
}
var _default = configMethod;
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
20530:
/*!*************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/devices.js ***!
\*************************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _size = __webpack_require__( /*! ./utils/size */ 58664);
var _renderer = _interopRequireDefault(__webpack_require__( /*! ../core/renderer */ 68374));
var _window = __webpack_require__( /*! ./utils/window */ 58201);
var _extend = __webpack_require__( /*! ./utils/extend */ 13306);
var _type = __webpack_require__( /*! ./utils/type */ 35922);
var _iterator = __webpack_require__( /*! ./utils/iterator */ 95479);
var _errors = _interopRequireDefault(__webpack_require__( /*! ./errors */ 17381));
var _callbacks = _interopRequireDefault(__webpack_require__( /*! ./utils/callbacks */ 44504));
var _ready_callbacks = _interopRequireDefault(__webpack_require__( /*! ./utils/ready_callbacks */ 24311));
var _resize_callbacks = _interopRequireDefault(__webpack_require__( /*! ./utils/resize_callbacks */ 55814));
var _events_strategy = __webpack_require__( /*! ./events_strategy */ 80566);
var _storage = __webpack_require__( /*! ./utils/storage */ 36613);
var _view_port = __webpack_require__( /*! ./utils/view_port */ 77695);
var _config = _interopRequireDefault(__webpack_require__( /*! ./config */ 80209));
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var navigator = (0, _window.getNavigator)();
var window = (0, _window.getWindow)();
var KNOWN_UA_TABLE = {
iPhone: "iPhone",
iPhone5: "iPhone",
iPhone6: "iPhone",
iPhone6plus: "iPhone",
iPad: "iPad",
iPadMini: "iPad Mini",
androidPhone: "Android Mobile",
androidTablet: "Android",
msSurface: "Windows ARM Tablet PC",
desktop: "desktop"
};
var DEFAULT_DEVICE = {
deviceType: "desktop",
platform: "generic",
version: [],
phone: false,
tablet: false,
android: false,
ios: false,
generic: true,
grade: "A",
mac: false
};
var uaParsers = {
generic: function(userAgent) {
var isPhone = /windows phone/i.test(userAgent) || userAgent.match(/WPDesktop/);
var isTablet = !isPhone && /Windows(.*)arm(.*)Tablet PC/i.test(userAgent);
var isDesktop = !isPhone && !isTablet && /msapphost/i.test(userAgent);
var isMac = /((intel|ppc) mac os x)/.test(userAgent.toLowerCase());
if (!(isPhone || isTablet || isDesktop || isMac)) {
return
}
return {
deviceType: isPhone ? "phone" : isTablet ? "tablet" : "desktop",
platform: "generic",
version: [],
grade: "A",
mac: isMac
}
},
ios: function(userAgent) {
if (!/ip(hone|od|ad)/i.test(userAgent)) {
return
}
var isPhone = /ip(hone|od)/i.test(userAgent);
var matches = userAgent.match(/os (\d+)_(\d+)_?(\d+)?/i);
var version = matches ? [parseInt(matches[1], 10), parseInt(matches[2], 10), parseInt(matches[3] || 0, 10)] : [];
var isIPhone4 = 480 === window.screen.height;
var grade = isIPhone4 ? "B" : "A";
return {
deviceType: isPhone ? "phone" : "tablet",
platform: "ios",
version: version,
grade: grade
}
},
android: function(userAgent) {
if (!/android|htc_|silk/i.test(userAgent)) {
return
}
var isPhone = /mobile/i.test(userAgent);
var matches = userAgent.match(/android (\d+)\.?(\d+)?\.?(\d+)?/i);
var version = matches ? [parseInt(matches[1], 10), parseInt(matches[2] || 0, 10), parseInt(matches[3] || 0, 10)] : [];
var worseThan4_4 = version.length > 1 && (version[0] < 4 || 4 === version[0] && version[1] < 4);
var grade = worseThan4_4 ? "B" : "A";
return {
deviceType: isPhone ? "phone" : "tablet",
platform: "android",
version: version,
grade: grade
}
}
};
var Devices = function() {
function Devices(options) {
this._window = (null === options || void 0 === options ? void 0 : options.window) || window;
this._realDevice = this._getDevice();
this._currentDevice = void 0;
this._currentOrientation = void 0;
this._eventsStrategy = new _events_strategy.EventsStrategy(this);
this.changed = (0, _callbacks.default)();
if ((0, _window.hasWindow)()) {
_ready_callbacks.default.add(this._recalculateOrientation.bind(this));
_resize_callbacks.default.add(this._recalculateOrientation.bind(this))
}
}
var _proto = Devices.prototype;
_proto.current = function(deviceOrName) {
if (deviceOrName) {
this._currentDevice = this._getDevice(deviceOrName);
this._forced = true;
this.changed.fire();
return
}
if (!this._currentDevice) {
deviceOrName = void 0;
try {
deviceOrName = this._getDeviceOrNameFromWindowScope()
} catch (e) {
deviceOrName = this._getDeviceNameFromSessionStorage()
} finally {
if (!deviceOrName) {
deviceOrName = this._getDeviceNameFromSessionStorage()
}
if (deviceOrName) {
this._forced = true
}
}
this._currentDevice = this._getDevice(deviceOrName)
}
return this._currentDevice
};
_proto.real = function(forceDevice) {
return (0, _extend.extend)({}, this._realDevice)
};
_proto.orientation = function() {
return this._currentOrientation
};
_proto.isForced = function() {
return this._forced
};
_proto.isRippleEmulator = function() {
return !!this._window.tinyHippos
};
_proto._getCssClasses = function(device) {
var result = [];
var realDevice = this._realDevice;
device = device || this.current();
if (device.deviceType) {
result.push("dx-device-".concat(device.deviceType));
if ("desktop" !== device.deviceType) {
result.push("dx-device-mobile")
}
}
result.push("dx-device-".concat(realDevice.platform));
if (realDevice.version && realDevice.version.length) {
result.push("dx-device-".concat(realDevice.platform, "-").concat(realDevice.version[0]))
}
if (this.isSimulator()) {
result.push("dx-simulator")
}
if ((0, _config.default)().rtlEnabled) {
result.push("dx-rtl")
}
return result
};
_proto.attachCssClasses = function(element, device) {
this._deviceClasses = this._getCssClasses(device).join(" ");
(0, _renderer.default)(element).addClass(this._deviceClasses)
};
_proto.detachCssClasses = function(element) {
(0, _renderer.default)(element).removeClass(this._deviceClasses)
};
_proto.isSimulator = function() {
try {
return this._isSimulator || (0, _window.hasWindow)() && this._window.top !== this._window.self && this._window.top["dx-force-device"] || this.isRippleEmulator()
} catch (e) {
return false
}
};
_proto.forceSimulator = function() {
this._isSimulator = true
};
_proto._getDevice = function(deviceName) {
if ("genericPhone" === deviceName) {
deviceName = {
deviceType: "phone",
platform: "generic",
generic: true
}
}
if ((0, _type.isPlainObject)(deviceName)) {
return this._fromConfig(deviceName)
} else {
var ua;
if (deviceName) {
ua = KNOWN_UA_TABLE[deviceName];
if (!ua) {
throw _errors.default.Error("E0005")
}
} else {
ua = navigator.userAgent
}
return this._fromUA(ua)
}
};
_proto._getDeviceOrNameFromWindowScope = function() {
var result;
if ((0, _window.hasWindow)() && (this._window.top["dx-force-device-object"] || this._window.top["dx-force-device"])) {
result = this._window.top["dx-force-device-object"] || this._window.top["dx-force-device"]
}
return result
};
_proto._getDeviceNameFromSessionStorage = function() {
var sessionStorage = (0, _storage.sessionStorage)();
if (!sessionStorage) {
return
}
var deviceOrName = sessionStorage.getItem("dx-force-device");
try {
return JSON.parse(deviceOrName)
} catch (ex) {
return deviceOrName
}
};
_proto._fromConfig = function(config) {
var result = (0, _extend.extend)({}, DEFAULT_DEVICE, this._currentDevice, config);
var shortcuts = {
phone: "phone" === result.deviceType,
tablet: "tablet" === result.deviceType,
android: "android" === result.platform,
ios: "ios" === result.platform,
generic: "generic" === result.platform
};
return (0, _extend.extend)(result, shortcuts)
};
_proto._fromUA = function(ua) {
var config;
(0, _iterator.each)(uaParsers, (function(platform, parser) {
config = parser(ua);
return !config
}));
if (config) {
return this._fromConfig(config)
}
return DEFAULT_DEVICE
};
_proto._changeOrientation = function() {
var $window = (0, _renderer.default)(this._window);
var orientation = (0, _size.getHeight)($window) > (0, _size.getWidth)($window) ? "portrait" : "landscape";
if (this._currentOrientation === orientation) {
return
}
this._currentOrientation = orientation;
this._eventsStrategy.fireEvent("orientationChanged", [{
orientation: orientation
}])
};
_proto._recalculateOrientation = function() {
var windowWidth = (0, _size.getWidth)(this._window);
if (this._currentWidth === windowWidth) {
return
}
this._currentWidth = windowWidth;
this._changeOrientation()
};
_proto.on = function(eventName, eventHandler) {
this._eventsStrategy.on(eventName, eventHandler);
return this
};
_proto.off = function(eventName, eventHandler) {
this._eventsStrategy.off(eventName, eventHandler);
return this
};
return Devices
}();
var devices = new Devices;
var viewPortElement = (0, _view_port.value)();
if (viewPortElement) {
devices.attachCssClasses(viewPortElement)
}
_view_port.changeCallback.add((function(viewPort, prevViewport) {
devices.detachCssClasses(prevViewport);
devices.attachCssClasses(viewPort)
}));
var _default = devices;
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
73349:
/*!*****************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/dom_adapter.js ***!
\*****************************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _dependency_injector = (obj = __webpack_require__( /*! ./utils/dependency_injector */ 20476), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var _common = __webpack_require__( /*! ./utils/common */ 20576);
var _shadow_dom = __webpack_require__( /*! ./utils/shadow_dom */ 90330);
function _typeof(obj) {
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)
}
var nativeDOMAdapterStrategy = {
querySelectorAll: function(element, selector) {
return element.querySelectorAll(selector)
},
elementMatches: function(element, selector) {
var _this = this;
var matches = element.matches || element.matchesSelector || element.mozMatchesSelector || element.msMatchesSelector || element.oMatchesSelector || element.webkitMatchesSelector || function(selector) {
var doc = element.document || element.ownerDocument;
if (!doc) {
return false
}
var items = _this.querySelectorAll(doc, selector);
for (var i = 0; i < items.length; i++) {
if (items[i] === element) {
return true
}
}
};
return matches.call(element, selector)
},
createElement: function(tagName, context) {
context = context || this._document;
return context.createElement(tagName)
},
createElementNS: function(ns, tagName, context) {
context = context || this._document;
return context.createElementNS(ns, tagName)
},
createTextNode: function(text, context) {
context = context || this._document;
return context.createTextNode(text)
},
createAttribute: function(text, context) {
context = context || this._document;
return context.createAttribute(text)
},
isNode: function(element) {
return element && "object" === _typeof(element) && "nodeType" in element && "nodeName" in element
},
isElementNode: function(element) {
return element && 1 === element.nodeType
},
isTextNode: function(element) {
return element && 3 === element.nodeType
},
isDocument: function(element) {
return element && 9 === element.nodeType
},
isDocumentFragment: function(element) {
return element && 11 === element.nodeType
},
removeElement: function(element) {
var parentNode = element && element.parentNode;
if (parentNode) {
parentNode.removeChild(element)
}
},
insertElement: function(parentElement, newElement, nextSiblingElement) {
if (parentElement && newElement && parentElement !== newElement) {
if (nextSiblingElement) {
parentElement.insertBefore(newElement, nextSiblingElement)
} else {
parentElement.appendChild(newElement)
}
}
},
getAttribute: function(element, name) {
return element.getAttribute(name)
},
setAttribute: function(element, name, value) {
if ("style" === name) {
element.style.cssText = value
} else {
element.setAttribute(name, value)
}
},
removeAttribute: function(element, name) {
element.removeAttribute(name)
},
setProperty: function(element, name, value) {
element[name] = value
},
setText: function(element, text) {
if (element) {
element.textContent = text
}
},
setClass: function(element, className, isAdd) {
if (1 === element.nodeType && className) {
isAdd ? element.classList.add(className) : element.classList.remove(className)
}
},
setStyle: function(element, name, value) {
element.style[name] = value || ""
},
_document: "undefined" === typeof document ? void 0 : document,
getDocument: function() {
return this._document
},
getActiveElement: function(element) {
var activeElementHolder = this.getRootNode(element);
return activeElementHolder.activeElement
},
getRootNode: function(element) {
var _element$getRootNode, _element$getRootNode2;
return null !== (_element$getRootNode = null === element || void 0 === element ? void 0 : null === (_element$getRootNode2 = element.getRootNode) || void 0 === _element$getRootNode2 ? void 0 : _element$getRootNode2.call(element)) && void 0 !== _element$getRootNode ? _element$getRootNode : this._document
},
getBody: function() {
return this._document.body
},
createDocumentFragment: function() {
return this._document.createDocumentFragment()
},
getDocumentElement: function() {
return this._document.documentElement
},
getLocation: function() {
return this._document.location
},
getSelection: function() {
return this._document.selection
},
getReadyState: function() {
return this._document.readyState
},
getHead: function() {
return this._document.head
},
hasDocumentProperty: function(property) {
return property in this._document
},
listen: function(element, event, callback, options) {
if (!element || !("addEventListener" in element)) {
return _common.noop
}
element.addEventListener(event, callback, options);
return function() {
element.removeEventListener(event, callback)
}
},
elementsFromPoint: function(x, y, element) {
var activeElementHolder = this.getRootNode(element);
if (activeElementHolder.host) {
return (0, _shadow_dom.getShadowElementsFromPoint)(x, y, activeElementHolder)
}
return activeElementHolder.elementsFromPoint(x, y)
}
};
var _default = (0, _dependency_injector.default)(nativeDOMAdapterStrategy);
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
13046:
/*!*******************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/dom_component.js ***!
\*******************************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _renderer = _interopRequireDefault(__webpack_require__( /*! ../core/renderer */ 68374));
var _config = _interopRequireDefault(__webpack_require__( /*! ./config */ 80209));
var _errors = _interopRequireDefault(__webpack_require__( /*! ./errors */ 17381));
var _resize_callbacks = _interopRequireDefault(__webpack_require__( /*! ../core/utils/resize_callbacks */ 55814));
var _component = __webpack_require__( /*! ./component */ 44297);
var _template_manager = __webpack_require__( /*! ./template_manager */ 14192);
var _public_component = __webpack_require__( /*! ./utils/public_component */ 9321);
var _shadow_dom = __webpack_require__( /*! ./utils/shadow_dom */ 90330);
var _element_data = __webpack_require__( /*! ./element_data */ 97906);
var _iterator = __webpack_require__( /*! ./utils/iterator */ 95479);
var _extend = __webpack_require__( /*! ./utils/extend */ 13306);
var _element = __webpack_require__( /*! ../core/element */ 6415);
var _common = __webpack_require__( /*! ./utils/common */ 20576);
var _type = __webpack_require__( /*! ./utils/type */ 35922);
var _window = __webpack_require__( /*! ../core/utils/window */ 58201);
var _short = __webpack_require__( /*! ../events/short */ 72918);
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var abstract = _component.Component.abstract;
var DOMComponent = _component.Component.inherit({
_getDefaultOptions: function() {
return (0, _extend.extend)(this.callBase(), {
width: void 0,
height: void 0,
rtlEnabled: (0, _config.default)().rtlEnabled,
elementAttr: {},
disabled: false,
integrationOptions: {}
}, this._useTemplates() ? _template_manager.TemplateManager.createDefaultOptions() : {})
},
ctor: function(element, options) {
this._customClass = null;
this._createElement(element);
(0, _public_component.attachInstanceToElement)(this._$element, this, this._dispose);
this.callBase(options)
},
_createElement: function(element) {
this._$element = (0, _renderer.default)(element)
},
_getSynchronizableOptionsForCreateComponent: function() {
return ["rtlEnabled", "disabled", "templatesRenderAsynchronously"]
},
_checkFunctionValueDeprecation: function(optionNames) {
var _this = this;
if (!this.option("_ignoreFunctionValueDeprecation")) {
optionNames.forEach((function(optionName) {
if ((0, _type.isFunction)(_this.option(optionName))) {
_errors.default.log("W0017", optionName)
}
}))
}
},
_visibilityChanged: abstract,
_dimensionChanged: abstract,
_init: function() {
this.callBase();
this._checkFunctionValueDeprecation(["width", "height", "maxHeight", "maxWidth", "minHeight", "minWidth", "popupHeight", "popupWidth"]);
this._attachWindowResizeCallback();
this._initTemplateManager()
},
_setOptionsByDevice: function(instanceCustomRules) {
this.callBase([].concat(this.constructor._classCustomRules || [], instanceCustomRules || []))
},
_isInitialOptionValue: function(name) {
var isCustomOption = this.constructor._classCustomRules && Object.prototype.hasOwnProperty.call(this._convertRulesToOptions(this.constructor._classCustomRules), name);
return !isCustomOption && this.callBase(name)
},
_attachWindowResizeCallback: function() {
if (this._isDimensionChangeSupported()) {
var windowResizeCallBack = this._windowResizeCallBack = this._dimensionChanged.bind(this);
_resize_callbacks.default.add(windowResizeCallBack)
}
},
_isDimensionChangeSupported: function() {
return this._dimensionChanged !== abstract
},
_renderComponent: function() {
this._initMarkup();
(0, _window.hasWindow)() && this._render()
},
_initMarkup: function() {
var _ref = this.option() || {},
rtlEnabled = _ref.rtlEnabled;
this._renderElementAttributes();
this._toggleRTLDirection(rtlEnabled);
this._renderVisibilityChange();
this._renderDimensions()
},
_render: function() {
this._attachVisibilityChangeHandlers();
(0, _shadow_dom.addShadowDomStyles)(this.$element())
},
_renderElementAttributes: function() {
var _ref2 = this.option() || {},
elementAttr = _ref2.elementAttr;
var attributes = (0, _extend.extend)({}, elementAttr);
var classNames = attributes.class;
delete attributes.class;
this.$element().attr(attributes).removeClass(this._customClass).addClass(classNames);
this._customClass = classNames
},
_renderVisibilityChange: function() {
if (this._isDimensionChangeSupported()) {
this._attachDimensionChangeHandlers()
}
if (this._isVisibilityChangeSupported()) {
var $element = this.$element();
$element.addClass("dx-visibility-change-handler")
}
},
_renderDimensions: function() {
var $element = this.$element();
var element = $element.get(0);
var width = this._getOptionValue("width", element);
var height = this._getOptionValue("height", element);
if (this._isCssUpdateRequired(element, height, width)) {
$element.css({
width: null === width ? "" : width,
height: null === height ? "" : height
})
}
},
_isCssUpdateRequired: function(element, height, width) {
return !!((0, _type.isDefined)(width) || (0, _type.isDefined)(height) || element.style.width || element.style.height)
},
_attachDimensionChangeHandlers: function() {
var _this2 = this;
var $el = this.$element();
var namespace = "".concat(this.NAME, "VisibilityChange");
_short.resize.off($el, {
namespace: namespace
});
_short.resize.on($el, (function() {
return _this2._dimensionChanged()
}), {
namespace: namespace
})
},
_attachVisibilityChangeHandlers: function() {
var _this3 = this;
if (this._isVisibilityChangeSupported()) {
var $el = this.$element();
var namespace = "".concat(this.NAME, "VisibilityChange");
this._isHidden = !this._isVisible();
_short.visibility.off($el, {
namespace: namespace
});
_short.visibility.on($el, (function() {
return _this3._checkVisibilityChanged("shown")
}), (function() {
return _this3._checkVisibilityChanged("hiding")
}), {
namespace: namespace
})
}
},
_isVisible: function() {
var $element = this.$element();
return $element.is(":visible")
},
_checkVisibilityChanged: function(action) {
var isVisible = this._isVisible();
if (isVisible) {
if ("hiding" === action && !this._isHidden) {
this._visibilityChanged(false);
this._isHidden = true
} else if ("shown" === action && this._isHidden) {
this._isHidden = false;
this._visibilityChanged(true)
}
}
},
_isVisibilityChangeSupported: function() {
return this._visibilityChanged !== abstract && (0, _window.hasWindow)()
},
_clean: _common.noop,
_modelByElement: function() {
var _this$option = this.option(),
modelByElement = _this$option.modelByElement;
var $element = this.$element();
return modelByElement ? modelByElement($element) : void 0
},
_invalidate: function() {
if (this._isUpdateAllowed()) {
throw _errors.default.Error("E0007")
}
this._requireRefresh = true
},
_refresh: function() {
this._clean();
this._renderComponent()
},
_dispose: function() {
this._templateManager && this._templateManager.dispose();
this.callBase();
this._clean();
this._detachWindowResizeCallback()
},
_detachWindowResizeCallback: function() {
if (this._isDimensionChangeSupported()) {
_resize_callbacks.default.remove(this._windowResizeCallBack)
}
},
_toggleRTLDirection: function(rtl) {
var $element = this.$element();
$element.toggleClass("dx-rtl", rtl)
},
_createComponent: function(element, component) {
var _this4 = this;
var config = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
var synchronizableOptions = (0, _common.grep)(this._getSynchronizableOptionsForCreateComponent(), (function(value) {
return !(value in config)
}));
var _this$option2 = this.option(),
integrationOptions = _this$option2.integrationOptions;
var _this$option3 = this.option(),
nestedComponentOptions = _this$option3.nestedComponentOptions;
nestedComponentOptions = nestedComponentOptions || _common.noop;
var nestedComponentConfig = (0, _extend.extend)({
integrationOptions: integrationOptions
}, nestedComponentOptions(this));
synchronizableOptions.forEach((function(optionName) {
return nestedComponentConfig[optionName] = _this4.option(optionName)
}));
this._extendConfig(config, nestedComponentConfig);
var instance = void 0;
if ((0, _type.isString)(component)) {
var $element = (0, _renderer.default)(element)[component](config);
instance = $element[component]("instance")
} else if (element) {
instance = component.getInstance(element);
if (instance) {
instance.option(config)
} else {
instance = new component(element, config)
}
}
if (instance) {
var optionChangedHandler = function(_ref3) {
var name = _ref3.name,
value = _ref3.value;
if (synchronizableOptions.includes(name)) {
instance.option(name, value)
}
};
this.on("optionChanged", optionChangedHandler);
instance.on("disposing", (function() {
return _this4.off("optionChanged", optionChangedHandler)
}))
}
return instance
},
_extendConfig: function(config, extendConfig) {
(0, _iterator.each)(extendConfig, (function(key, value) {
!Object.prototype.hasOwnProperty.call(config, key) && (config[key] = value)
}))
},
_defaultActionConfig: function() {
var $element = this.$element();
var context = this._modelByElement($element);
return (0, _extend.extend)(this.callBase(), {
context: context
})
},
_defaultActionArgs: function() {
var $element = this.$element();
var model = this._modelByElement($element);
var element = this.element();
return (0, _extend.extend)(this.callBase(), {
element: element,
model: model
})
},
_optionChanged: function(args) {
switch (args.name) {
case "width":
case "height":
this._renderDimensions();
break;
case "rtlEnabled":
this._invalidate();
break;
case "elementAttr":
this._renderElementAttributes();
break;
case "disabled":
case "integrationOptions":
break;
default:
this.callBase(args)
}
},
_removeAttributes: function(element) {
var attrs = element.attributes;
for (var i = attrs.length - 1; i >= 0; i--) {
var attr = attrs[i];
if (attr) {
var name = attr.name;
if (!name.indexOf("aria-") || -1 !== name.indexOf("dx-") || "role" === name || "style" === name || "tabindex" === name) {
element.removeAttribute(name)
}
}
}
},
_removeClasses: function(element) {
element.className = element.className.split(" ").filter((function(cssClass) {
return 0 !== cssClass.lastIndexOf("dx-", 0)
})).join(" ")
},
_updateDOMComponent: function(renderRequired) {
if (renderRequired) {
this._renderComponent()
} else if (this._requireRefresh) {
this._requireRefresh = false;
this._refresh()
}
},
endUpdate: function() {
var renderRequired = this._isInitializingRequired();
this.callBase();
this._isUpdateAllowed() && this._updateDOMComponent(renderRequired)
},
$element: function() {
return this._$element
},
element: function() {
var $element = this.$element();
return (0, _element.getPublicElement)($element)
},
dispose: function() {
var element = this.$element().get(0);
(0, _element_data.cleanDataRecursive)(element, true);
element.textContent = "";
this._removeAttributes(element);
this._removeClasses(element)
},
resetOption: function(optionName) {
this.callBase(optionName);
if ("width" === optionName || "height" === optionName) {
var initialOption = this.initialOption(optionName);
!(0, _type.isDefined)(initialOption) && this.$element().css(optionName, "")
}
},
_getAnonymousTemplateName: function() {
return
},
_initTemplateManager: function() {
if (this._templateManager || !this._useTemplates()) {
return
}
var _this$option4 = this.option(),
_this$option4$integra = _this$option4.integrationOptions,
integrationOptions = void 0 === _this$option4$integra ? {} : _this$option4$integra;
var createTemplate = integrationOptions.createTemplate;
this._templateManager = new _template_manager.TemplateManager(createTemplate, this._getAnonymousTemplateName());
this._initTemplates()
},
_initTemplates: function() {
var _this5 = this;
var _this$_templateManage = this._templateManager.extractTemplates(this.$element()),
templates = _this$_templateManage.templates,
anonymousTemplateMeta = _this$_templateManage.anonymousTemplateMeta;
var anonymousTemplate = this.option("integrationOptions.templates.".concat(anonymousTemplateMeta.name));
templates.forEach((function(_ref4) {
var name = _ref4.name,
template = _ref4.template;
_this5._options.silent("integrationOptions.templates.".concat(name), template)
}));
if (anonymousTemplateMeta.name && !anonymousTemplate) {
this._options.silent("integrationOptions.templates.".concat(anonymousTemplateMeta.name), anonymousTemplateMeta.template);
this._options.silent("_hasAnonymousTemplateContent", true)
}
},
_getTemplateByOption: function(optionName) {
return this._getTemplate(this.option(optionName))
},
_getTemplate: function(templateSource) {
var templates = this.option("integrationOptions.templates");
var isAsyncTemplate = this.option("templatesRenderAsynchronously");
var skipTemplates = this.option("integrationOptions.skipTemplates");
return this._templateManager.getTemplate(templateSource, templates, {
isAsyncTemplate: isAsyncTemplate,
skipTemplates: skipTemplates
}, this)
},
_saveTemplate: function(name, template) {
this._setOptionWithoutOptionChange("integrationOptions.templates." + name, this._templateManager._createTemplate(template))
},
_useTemplates: function() {
return true
}
});
DOMComponent.getInstance = function(element) {
return (0, _public_component.getInstanceByElement)((0, _renderer.default)(element), this)
};
DOMComponent.defaultOptions = function(rule) {
this._classCustomRules = this._classCustomRules || [];
this._classCustomRules.push(rule)
};
var _default = DOMComponent;
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
6415:
/*!*************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/element.js ***!
\*************************************************************/
function(__unused_webpack_module, exports) {
exports.getPublicElement = function(element) {
return strategy(element)
};
exports.setPublicElementWrapper = function(newStrategy) {
strategy = newStrategy
};
var strategy = function(element) {
return element && element.get(0)
}
},
97906:
/*!******************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/element_data.js ***!
\******************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.afterCleanData = function(callback) {
afterCleanDataFunc = callback
};
exports.beforeCleanData = function(callback) {
beforeCleanDataFunc = callback
};
exports.cleanData = function(nodes) {
return strategy.cleanData.call(this, nodes)
};
exports.cleanDataRecursive = function(element, cleanSelf) {
if (!_dom_adapter.default.isElementNode(element)) {
return
}
var childElements = element.getElementsByTagName("*");
strategy.cleanData(childElements);
if (cleanSelf) {
strategy.cleanData([element])
}
};
exports.data = function() {
return strategy.data.apply(this, arguments)
};
exports.getDataStrategy = function() {
return strategy
};
exports.removeData = function(element, key) {
return strategy.removeData.call(this, element, key)
};
exports.strategyChanging = exports.setDataStrategy = void 0;
var _dom_adapter = _interopRequireDefault(__webpack_require__( /*! ./dom_adapter */ 73349));
var _events_engine = _interopRequireDefault(__webpack_require__( /*! ../events/core/events_engine */ 55994));
var _memorized_callbacks = _interopRequireDefault(__webpack_require__( /*! ./memorized_callbacks */ 83358));
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var dataMap = new WeakMap;
var strategy;
var strategyChanging = new _memorized_callbacks.default;
exports.strategyChanging = strategyChanging;
var beforeCleanDataFunc = function() {};
var afterCleanDataFunc = function() {};
var setDataStrategy = function(value) {
strategyChanging.fire(value);
strategy = value;
var cleanData = strategy.cleanData;
strategy.cleanData = function(nodes) {
beforeCleanDataFunc(nodes);
var result = cleanData.call(this, nodes);
afterCleanDataFunc(nodes);
return result
}
};
exports.setDataStrategy = setDataStrategy;
setDataStrategy({
data: function() {
var element = arguments[0];
var key = arguments[1];
var value = arguments[2];
if (!element) {
return
}
var elementData = dataMap.get(element);
if (!elementData) {
elementData = {};
dataMap.set(element, elementData)
}
if (void 0 === key) {
return elementData
}
if (2 === arguments.length) {
return elementData[key]
}
elementData[key] = value;
return value
},
removeData: function(element, key) {
if (!element) {
return
}
if (void 0 === key) {
dataMap.delete(element)
} else {
var elementData = dataMap.get(element);
if (elementData) {
delete elementData[key]
}
}
},
cleanData: function(elements) {
for (var i = 0; i < elements.length; i++) {
_events_engine.default.off(elements[i]);
dataMap.delete(elements[i])
}
}
})
},
17381:
/*!************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/errors.js ***!
\************************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _error = (obj = __webpack_require__( /*! ./utils/error */ 95640), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var _default = (0, _error.default)({
E0001: "Method is not implemented",
E0002: "Member name collision: {0}",
E0003: "A class must be instantiated using the 'new' keyword",
E0004: "The NAME property of the component is not specified",
E0005: "Unknown device",
E0006: "Unknown endpoint key is requested",
E0007: "'Invalidate' method is called outside the update transaction",
E0008: "Type of the option name is not appropriate to create an action",
E0009: "Component '{0}' has not been initialized for an element",
E0010: "Animation configuration with the '{0}' type requires '{1}' configuration as {2}",
E0011: "Unknown animation type '{0}'",
E0012: "jQuery version is too old. Please upgrade jQuery to 1.10.0 or later",
E0013: "KnockoutJS version is too old. Please upgrade KnockoutJS to 2.3.0 or later",
E0014: "The 'release' method shouldn't be called for an unlocked Lock object",
E0015: "Queued task returned an unexpected result",
E0017: "Event namespace is not defined",
E0018: "DevExpress.ui.DevExpressPopup widget is required",
E0020: "Template engine '{0}' is not supported",
E0021: "Unknown theme is set: {0}",
E0022: "LINK[rel=DevExpress-theme] tags must go before DevExpress included scripts",
E0023: "Template name is not specified",
E0024: "DevExtreme bundle already included",
E0025: "Unexpected argument type",
E0100: "Unknown validation type is detected",
E0101: "Misconfigured range validation rule is detected",
E0102: "Misconfigured comparison validation rule is detected",
E0103: "validationCallback of an asynchronous rule should return a jQuery or a native promise",
E0110: "Unknown validation group is detected",
E0120: "Adapter for a DevExpressValidator component cannot be configured",
E0121: "The 'customItem' parameter of the 'onCustomItemCreating' function is empty or contains invalid data. Assign a custom object or a Promise that is resolved after the item is created.",
W0000: "'{0}' is deprecated in {1}. {2}",
W0001: "{0} - '{1}' option is deprecated in {2}. {3}",
W0002: "{0} - '{1}' method is deprecated in {2}. {3}",
W0003: "{0} - '{1}' property is deprecated in {2}. {3}",
W0004: "Timeout for theme loading is over: {0}",
W0005: "'{0}' event is deprecated in {1}. {2}",
W0006: "Invalid recurrence rule: '{0}'",
W0007: "'{0}' Globalize culture is not defined",
W0008: "Invalid view name: '{0}'",
W0009: "Invalid time zone name: '{0}'",
W0010: "{0} is deprecated in {1}. {2}",
W0011: "Number parsing is invoked while the parser is not defined",
W0012: "Date parsing is invoked while the parser is not defined",
W0013: "'{0}' file is deprecated in {1}. {2}",
W0014: "{0} - '{1}' type is deprecated in {2}. {3}",
W0015: "Instead of returning a value from the '{0}' function, write it into the '{1}' field of the function's parameter.",
W0016: 'The "{0}" option does not accept the "{1}" value since v{2}. {3}.',
W0017: 'Setting the "{0}" property with a function is deprecated since v21.2',
W0018: 'Setting the "position" property with a function is deprecated since v21.2'
});
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
80566:
/*!*********************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/events_strategy.js ***!
\*********************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.EventsStrategy = void 0;
var _callbacks = (obj = __webpack_require__( /*! ./utils/callbacks */ 44504), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var _iterator = __webpack_require__( /*! ./utils/iterator */ 95479);
var _type = __webpack_require__( /*! ./utils/type */ 35922);
var EventsStrategy = function() {
function EventsStrategy(owner) {
var options = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {};
this._events = {};
this._owner = owner;
this._options = options
}
EventsStrategy.create = function(owner, strategy) {
if (strategy) {
return (0, _type.isFunction)(strategy) ? strategy(owner) : strategy
} else {
return new EventsStrategy(owner)
}
};
var _proto = EventsStrategy.prototype;
_proto.hasEvent = function(eventName) {
var callbacks = this._events[eventName];
return callbacks ? callbacks.has() : false
};
_proto.fireEvent = function(eventName, eventArgs) {
var callbacks = this._events[eventName];
if (callbacks) {
callbacks.fireWith(this._owner, eventArgs)
}
return this._owner
};
_proto.on = function(eventName, eventHandler) {
var _this = this;
if ((0, _type.isPlainObject)(eventName)) {
(0, _iterator.each)(eventName, (function(e, h) {
_this.on(e, h)
}))
} else {
var callbacks = this._events[eventName];
if (!callbacks) {
callbacks = (0, _callbacks.default)({
syncStrategy: this._options.syncStrategy
});
this._events[eventName] = callbacks
}
var addFn = callbacks.originalAdd || callbacks.add;
addFn.call(callbacks, eventHandler)
}
};
_proto.off = function(eventName, eventHandler) {
var callbacks = this._events[eventName];
if (callbacks) {
if ((0, _type.isFunction)(eventHandler)) {
callbacks.remove(eventHandler)
} else {
callbacks.empty()
}
}
};
_proto.dispose = function() {
(0, _iterator.each)(this._events, (function(eventName, event) {
event.empty()
}))
};
return EventsStrategy
}();
exports.EventsStrategy = EventsStrategy
},
73176:
/*!**********************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/guid.js ***!
\**********************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _class = (obj = __webpack_require__( /*! ./class */ 38377), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var Guid = _class.default.inherit({
ctor: function(value) {
if (value) {
value = String(value)
}
this._value = this._normalize(value || this._generate())
},
_normalize: function(value) {
value = value.replace(/[^a-f0-9]/gi, "").toLowerCase();
while (value.length < 32) {
value += "0"
}
return [value.substr(0, 8), value.substr(8, 4), value.substr(12, 4), value.substr(16, 4), value.substr(20, 12)].join("-")
},
_generate: function() {
var value = "";
for (var i = 0; i < 32; i++) {
value += Math.round(15 * Math.random()).toString(16)
}
return value
},
toString: function() {
return this._value
},
valueOf: function() {
return this._value
},
toJSON: function() {
return this._value
}
});
var _default = Guid;
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
83448:
/*!******************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/http_request.js ***!
\******************************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _window = __webpack_require__( /*! ./utils/window */ 58201);
var _dependency_injector = (obj = __webpack_require__( /*! ./utils/dependency_injector */ 20476), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var window = (0, _window.getWindow)();
var nativeXMLHttpRequest = {
getXhr: function() {
return new window.XMLHttpRequest
}
};
var _default = (0, _dependency_injector.default)(nativeXMLHttpRequest);
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
15334:
/*!**********************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/inferno_renderer.js ***!
\**********************************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _inferno = __webpack_require__( /*! inferno */ 55285);
var _inferno2 = __webpack_require__( /*! @devextreme/runtime/inferno */ 44105);
var _infernoCreateElement = __webpack_require__( /*! inferno-create-element */ 87456);
var _dom_adapter = _interopRequireDefault(__webpack_require__( /*! ./dom_adapter */ 73349));
var _element_data = __webpack_require__( /*! ./element_data */ 97906);
var _dependency_injector = _interopRequireDefault(__webpack_require__( /*! ./utils/dependency_injector */ 20476));
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var remove = function(element) {
var parentNode = element.parentNode;
if (parentNode) {
var nextSibling = element.nextSibling;
(0, _element_data.cleanDataRecursive)(element);
parentNode.$V = element.$V;
(0, _inferno.render)(null, parentNode);
parentNode.insertBefore(element, nextSibling);
element.innerHTML = "";
delete parentNode.$V
}
delete element.$V
};
var _default = (0, _dependency_injector.default)({
createElement: function(component, props) {
return (0, _infernoCreateElement.createElement)(component, props)
},
remove: remove,
onAfterRender: function() {
_inferno2.InfernoEffectHost.callEffects()
},
onPreRender: function() {
_inferno2.InfernoEffectHost.lock()
},
render: function(component, props, container, replace) {
if (!replace) {
var parentNode = container.parentNode;
var nextNode = null === container || void 0 === container ? void 0 : container.nextSibling;
var rootNode = _dom_adapter.default.createElement("div");
rootNode.appendChild(container);
var mountNode = _dom_adapter.default.createDocumentFragment().appendChild(rootNode);
var vNodeAlreadyExists = !!container.$V;
vNodeAlreadyExists && remove(container);
(0, _inferno2.hydrate)((0, _infernoCreateElement.createElement)(component, props), mountNode);
container.$V = mountNode.$V;
if (parentNode) {
parentNode.insertBefore(container, nextNode)
}
} else {
(0, _inferno.render)((0, _infernoCreateElement.createElement)(component, props), container)
}
}
});
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
83358:
/*!*************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/memorized_callbacks.js ***!
\*************************************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _iterator = __webpack_require__( /*! ../core/utils/iterator */ 95479);
var _callbacks = (obj = __webpack_require__( /*! ./utils/callbacks */ 44504), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var MemorizedCallbacks = function() {
function MemorizedCallbacks() {
this.memory = [];
this.callbacks = (0, _callbacks.default)()
}
var _proto = MemorizedCallbacks.prototype;
_proto.add = function(fn) {
(0, _iterator.each)(this.memory, (function(_, item) {
return fn.apply(fn, item)
}));
this.callbacks.add(fn)
};
_proto.remove = function(fn) {
this.callbacks.remove(fn)
};
_proto.fire = function() {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key]
}
this.memory.push(args);
this.callbacks.fire.apply(this.callbacks, args)
};
return MemorizedCallbacks
}();
exports.default = MemorizedCallbacks;
module.exports = exports.default;
module.exports.default = exports.default
},
95683:
/*!*******************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/options/index.js ***!
\*******************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.Options = void 0;
var _type = __webpack_require__( /*! ../utils/type */ 35922);
var _common = __webpack_require__( /*! ../utils/common */ 20576);
var _option_manager = __webpack_require__( /*! ./option_manager */ 9030);
var _data = __webpack_require__( /*! ../utils/data */ 47617);
var _utils = __webpack_require__( /*! ./utils */ 45434);
var _extend = __webpack_require__( /*! ../utils/extend */ 13306);
function _typeof(obj) {
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 _extends() {
_extends = Object.assign ? Object.assign.bind() : 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 _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, (arg = descriptor.key, key = void 0, key = function(input, hint) {
if ("object" !== _typeof(input) || null === input) {
return input
}
var prim = input[Symbol.toPrimitive];
if (void 0 !== prim) {
var res = prim.call(input, hint || "default");
if ("object" !== _typeof(res)) {
return res
}
throw new TypeError("@@toPrimitive must return a primitive value.")
}
return ("string" === hint ? String : Number)(input)
}(arg, "string"), "symbol" === _typeof(key) ? key : String(key)), descriptor)
}
var arg, key
}
var Options = function() {
function Options(options, defaultOptions, optionsByReference, deprecatedOptions) {
var _this = this;
this._deprecatedCallback;
this._startChangeCallback;
this._endChangeCallback;
this._default = defaultOptions;
this._deprecated = deprecatedOptions;
this._deprecatedNames = [];
this._initDeprecatedNames();
this._optionManager = new _option_manager.OptionManager(options, optionsByReference);
this._optionManager.onRelevantNamesPrepared((function(options, name, value, silent) {
return _this._setRelevantNames(options, name, value, silent)
}));
this._cachedOptions = {};
this._rules = []
}
var _proto = Options.prototype;
_proto._initDeprecatedNames = function() {
for (var optionName in this._deprecated) {
this._deprecatedNames.push(optionName)
}
};
_proto._getByRules = function(rules) {
rules = Array.isArray(rules) ? this._rules.concat(rules) : this._rules;
return (0, _utils.convertRulesToOptions)(rules)
};
_proto._notifyDeprecated = function(option) {
var info = this._deprecated[option];
if (info) {
this._deprecatedCallback(option, info)
}
};
_proto._setRelevantNames = function(options, name, value, silent) {
if (name) {
var normalizedName = this._normalizeName(name, silent);
if (normalizedName && normalizedName !== name) {
this._setField(options, normalizedName, value);
this._clearField(options, name)
}
}
};
_proto._setField = function(options, fullName, value) {
var fieldName = "";
var fieldObject = null;
do {
fieldName = fieldName ? ".".concat(fieldName) : "";
fieldName = (0, _utils.getFieldName)(fullName) + fieldName;
fullName = (0, _utils.getParentName)(fullName);
fieldObject = fullName ? this._optionManager.get(options, fullName, false) : options
} while (!fieldObject);
fieldObject[fieldName] = value
};
_proto._clearField = function(options, name) {
delete options[name];
var previousFieldName = (0, _utils.getParentName)(name);
var fieldObject = previousFieldName ? this._optionManager.get(options, previousFieldName, false) : options;
if (fieldObject) {
delete fieldObject[(0, _utils.getFieldName)(name)]
}
};
_proto._normalizeName = function(name, silent) {
if (this._deprecatedNames.length && name) {
for (var i = 0; i < this._deprecatedNames.length; i++) {
if (this._deprecatedNames[i] === name) {
var deprecate = this._deprecated[name];
if (deprecate) {
!silent && this._notifyDeprecated(name);
return deprecate.alias || name
}
}
}
}
return name
};
_proto.addRules = function(rules) {
this._rules = rules.concat(this._rules)
};
_proto.applyRules = function(rules) {
var options = this._getByRules(rules);
this.silent(options)
};
_proto.dispose = function() {
this._deprecatedCallback = _common.noop;
this._startChangeCallback = _common.noop;
this._endChangeCallback = _common.noop;
this._optionManager.dispose()
};
_proto.onChanging = function(callBack) {
this._optionManager.onChanging(callBack)
};
_proto.onChanged = function(callBack) {
this._optionManager.onChanged(callBack)
};
_proto.onDeprecated = function(callBack) {
this._deprecatedCallback = callBack
};
_proto.onStartChange = function(callBack) {
this._startChangeCallback = callBack
};
_proto.onEndChange = function(callBack) {
this._endChangeCallback = callBack
};
_proto.isInitial = function(name) {
var value = this.silent(name);
var initialValue = this.initial(name);
var areFunctions = (0, _type.isFunction)(value) && (0, _type.isFunction)(initialValue);
return areFunctions ? value.toString() === initialValue.toString() : (0, _common.equalByValue)(value, initialValue)
};
_proto.initial = function(name) {
return (0, _utils.getNestedOptionValue)(this._initial, name)
};
_proto.option = function(options, value) {
var isGetter = arguments.length < 2 && "object" !== (0, _type.type)(options);
if (isGetter) {
return this._optionManager.get(void 0, this._normalizeName(options))
} else {
this._startChangeCallback();
try {
this._optionManager.set(options, value)
} finally {
this._endChangeCallback()
}
}
};
_proto.silent = function(options, value) {
var isGetter = arguments.length < 2 && "object" !== (0, _type.type)(options);
if (isGetter) {
return this._optionManager.get(void 0, options, void 0, true)
} else {
this._optionManager.set(options, value, void 0, true)
}
};
_proto.reset = function(name) {
var _this2 = this;
if (name) {
var fullPath = (0, _data.getPathParts)(name);
var value = fullPath.reduce((function(value, field) {
return value ? value[field] : _this2.initial(field)
}), null);
var defaultValue = (0, _type.isObject)(value) ? _extends({}, value) : value;
this._optionManager.set(name, defaultValue, false)
}
};
_proto.getAliasesByName = function(name) {
var _this3 = this;
return Object.keys(this._deprecated).filter((function(aliasName) {
return name === _this3._deprecated[aliasName].alias
}))
};
_proto.isDeprecated = function(name) {
return Object.prototype.hasOwnProperty.call(this._deprecated, name)
};
_proto.cache = function(name, options) {
var isGetter = arguments.length < 2;
if (isGetter) {
return this._cachedOptions[name]
} else {
this._cachedOptions[name] = (0, _extend.extend)(this._cachedOptions[name], options)
}
};
! function(Constructor, protoProps, staticProps) {
if (protoProps) {
_defineProperties(Constructor.prototype, protoProps)
}
if (staticProps) {
_defineProperties(Constructor, staticProps)
}
Object.defineProperty(Constructor, "prototype", {
writable: false
});
return Constructor
}(Options, [{
key: "_initial",
get: function() {
if (!this._initialOptions) {
var rulesOptions = this._getByRules(this.silent("defaultOptionsRules"));
this._initialOptions = this._default;
this._optionManager._setByReference(this._initialOptions, rulesOptions)
}
return this._initialOptions
},
set: function(value) {
this._initialOptions = value
}
}]);
return Options
}();
exports.Options = Options
},
9030:
/*!****************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/options/option_manager.js ***!
\****************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.OptionManager = void 0;
var _data = __webpack_require__( /*! ../utils/data */ 47617);
var _common = __webpack_require__( /*! ../utils/common */ 20576);
var _comparator = __webpack_require__( /*! ../utils/comparator */ 49036);
var _extend = __webpack_require__( /*! ../utils/extend */ 13306);
var _type = __webpack_require__( /*! ../utils/type */ 35922);
var _utils = __webpack_require__( /*! ./utils */ 45434);
var cachedGetters = {};
var cachedSetters = {};
var OptionManager = function() {
function OptionManager(options, optionsByReference) {
this._options = options;
this._optionsByReference = optionsByReference;
this._changingCallback;
this._changedCallback;
this._namePreparedCallbacks
}
var _proto = OptionManager.prototype;
_proto._setByReference = function(options, rulesOptions) {
(0, _extend.extend)(true, options, rulesOptions);
for (var fieldName in this._optionsByReference) {
if (Object.prototype.hasOwnProperty.call(rulesOptions, fieldName)) {
options[fieldName] = rulesOptions[fieldName]
}
}
};
_proto._setPreparedValue = function(name, value, merge, silent) {
var previousValue = this.get(this._options, name, false);
if (!(0, _comparator.equals)(previousValue, value)) {
var path = (0, _data.getPathParts)(name);
!silent && this._changingCallback(name, previousValue, value);
cachedSetters[name] = cachedSetters[name] || (0, _data.compileSetter)(name);
cachedSetters[name](this._options, value, {
functionsAsIs: true,
merge: (0, _type.isDefined)(merge) ? merge : !this._optionsByReference[name],
unwrapObservables: path.length > 1 && !!this._optionsByReference[path[0]]
});
!silent && this._changedCallback(name, value, previousValue)
}
};
_proto._prepareRelevantNames = function(options, name, value, silent) {
if ((0, _type.isPlainObject)(value)) {
for (var valueName in value) {
this._prepareRelevantNames(options, "".concat(name, ".").concat(valueName), value[valueName])
}
}
this._namePreparedCallbacks(options, name, value, silent)
};
_proto.get = function() {
var options = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : this._options;
var name = arguments.length > 1 ? arguments[1] : void 0;
var unwrapObservables = arguments.length > 2 ? arguments[2] : void 0;
cachedGetters[name] = cachedGetters[name] || (0, _data.compileGetter)(name);
return cachedGetters[name](options, {
functionsAsIs: true,
unwrapObservables: unwrapObservables
})
};
_proto.set = function(options, value, merge, silent) {
options = (0, _utils.normalizeOptions)(options, value);
for (var name in options) {
this._prepareRelevantNames(options, name, options[name], silent)
}
for (var _name in options) {
this._setPreparedValue(_name, options[_name], merge, silent)
}
};
_proto.onRelevantNamesPrepared = function(callBack) {
this._namePreparedCallbacks = callBack
};
_proto.onChanging = function(callBack) {
this._changingCallback = callBack
};
_proto.onChanged = function(callBack) {
this._changedCallback = callBack
};
_proto.dispose = function() {
this._changingCallback = _common.noop;
this._changedCallback = _common.noop
};
return OptionManager
}();
exports.OptionManager = OptionManager
},
45434:
/*!*******************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/options/utils.js ***!
\*******************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.normalizeOptions = exports.getParentName = exports.getNestedOptionValue = exports.getFieldName = exports.deviceMatch = exports.createDefaultOptionRules = exports.convertRulesToOptions = void 0;
var _devices = (obj = __webpack_require__( /*! ../devices */ 20530), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var _type = __webpack_require__( /*! ../utils/type */ 35922);
var _common = __webpack_require__( /*! ../utils/common */ 20576);
var _extend = __webpack_require__( /*! ../utils/extend */ 13306);
var _data = __webpack_require__( /*! ../utils/data */ 47617);
function _typeof(obj) {
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 _defineProperty(obj, key, value) {
key = function(arg) {
var key = function(input, hint) {
if ("object" !== _typeof(input) || null === input) {
return input
}
var prim = input[Symbol.toPrimitive];
if (void 0 !== prim) {
var res = prim.call(input, hint || "default");
if ("object" !== _typeof(res)) {
return res
}
throw new TypeError("@@toPrimitive must return a primitive value.")
}
return ("string" === hint ? String : Number)(input)
}(arg, "string");
return "symbol" === _typeof(key) ? key : String(key)
}(key);
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
})
} else {
obj[key] = value
}
return obj
}
var cachedGetters = {};
exports.convertRulesToOptions = function(rules) {
var currentDevice = _devices.default.current();
return rules.reduce((function(options, _ref) {
var device = _ref.device,
ruleOptions = _ref.options;
var deviceFilter = device || {};
var match = (0, _type.isFunction)(deviceFilter) ? deviceFilter(currentDevice) : deviceMatch(currentDevice, deviceFilter);
if (match) {
(0, _extend.extend)(true, options, ruleOptions)
}
return options
}), {})
};
exports.normalizeOptions = function(options, value) {
return "string" !== typeof options ? options : _defineProperty({}, options, value)
};
var deviceMatch = function(device, filter) {
return (0, _type.isEmptyObject)(filter) || (0, _common.findBestMatches)(device, [filter]).length > 0
};
exports.deviceMatch = deviceMatch;
exports.getFieldName = function(fullName) {
return fullName.substr(fullName.lastIndexOf(".") + 1)
};
exports.getParentName = function(fullName) {
return fullName.substr(0, fullName.lastIndexOf("."))
};
exports.getNestedOptionValue = function(optionsObject, name) {
cachedGetters[name] = cachedGetters[name] || (0, _data.compileGetter)(name);
return cachedGetters[name](optionsObject, {
functionsAsIs: true
})
};
exports.createDefaultOptionRules = function() {
var options = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : [];
return options
}
},
90889:
/*!**************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/postponed_operations.js ***!
\**************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.PostponedOperations = void 0;
var _deferred = __webpack_require__( /*! ./utils/deferred */ 62754);
var _type = __webpack_require__( /*! ./utils/type */ 35922);
function _toConsumableArray(arr) {
return function(arr) {
if (Array.isArray(arr)) {
return _arrayLikeToArray(arr)
}
}(arr) || function(iter) {
if ("undefined" !== typeof Symbol && null != iter[Symbol.iterator] || null != iter["@@iterator"]) {
return Array.from(iter)
}
}(arr) || function(o, minLen) {
if (!o) {
return
}
if ("string" === typeof o) {
return _arrayLikeToArray(o, minLen)
}
var n = Object.prototype.toString.call(o).slice(8, -1);
if ("Object" === n && o.constructor) {
n = o.constructor.name
}
if ("Map" === n || "Set" === n) {
return Array.from(o)
}
if ("Arguments" === n || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) {
return _arrayLikeToArray(o, minLen)
}
}(arr) || function() {
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 _arrayLikeToArray(arr, len) {
if (null == len || len > arr.length) {
len = arr.length
}
for (var i = 0, arr2 = new Array(len); i < len; i++) {
arr2[i] = arr[i]
}
return arr2
}
var PostponedOperations = function() {
function PostponedOperations() {
this._postponedOperations = {}
}
var _proto = PostponedOperations.prototype;
_proto.add = function(key, fn, postponedPromise) {
if (key in this._postponedOperations) {
postponedPromise && this._postponedOperations[key].promises.push(postponedPromise)
} else {
var completePromise = new _deferred.Deferred;
this._postponedOperations[key] = {
fn: fn,
completePromise: completePromise,
promises: postponedPromise ? [postponedPromise] : []
}
}
return this._postponedOperations[key].completePromise.promise()
};
_proto.callPostponedOperations = function() {
for (var key in this._postponedOperations) {
var operation = this._postponedOperations[key];
if ((0, _type.isDefined)(operation)) {
if (operation.promises && operation.promises.length) {
_deferred.when.apply(void 0, _toConsumableArray(operation.promises)).done(operation.fn).then(operation.completePromise.resolve)
} else {
operation.fn().done(operation.completePromise.resolve)
}
}
}
this._postponedOperations = {}
};
return PostponedOperations
}();
exports.PostponedOperations = PostponedOperations
},
68374:
/*!**************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/renderer.js ***!
\**************************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _renderer_base = (obj = __webpack_require__( /*! ./renderer_base */ 82981), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var _default = _renderer_base.default.get();
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
82981:
/*!*******************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/renderer_base.js ***!
\*******************************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _element_data = __webpack_require__( /*! ./element_data */ 97906);
var _dom_adapter = (obj = __webpack_require__( /*! ./dom_adapter */ 73349), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var _window = __webpack_require__( /*! ./utils/window */ 58201);
var _type = __webpack_require__( /*! ./utils/type */ 35922);
var _style = __webpack_require__( /*! ./utils/style */ 80968);
var _size = __webpack_require__( /*! ./utils/size */ 58664);
var _html_parser = __webpack_require__( /*! ./utils/html_parser */ 61371);
var window = (0, _window.getWindow)();
var renderer;
var initRender = function(selector, context) {
if (!selector) {
this.length = 0;
return this
}
if ("string" === typeof selector) {
if ("body" === selector) {
this[0] = context ? context.body : _dom_adapter.default.getBody();
this.length = 1;
return this
}
context = context || _dom_adapter.default.getDocument();
if ("<" === selector[0]) {
this[0] = _dom_adapter.default.createElement(selector.slice(1, -1), context);
this.length = 1;
return this
} [].push.apply(this, _dom_adapter.default.querySelectorAll(context, selector));
return this
} else if (_dom_adapter.default.isNode(selector) || (0, _type.isWindow)(selector)) {
this[0] = selector;
this.length = 1;
return this
} else if (Array.isArray(selector)) {
[].push.apply(this, selector);
return this
}
return renderer(selector.toArray ? selector.toArray() : [selector])
};
renderer = function(selector, context) {
return new initRender(selector, context)
};
renderer.fn = {
dxRenderer: true
};
initRender.prototype = renderer.fn;
var repeatMethod = function(methodName, args) {
for (var i = 0; i < this.length; i++) {
var item = renderer(this[i]);
item[methodName].apply(item, args)
}
return this
};
var setAttributeValue = function(element, attrName, value) {
if (void 0 !== value && null !== value && false !== value) {
_dom_adapter.default.setAttribute(element, attrName, value)
} else {
_dom_adapter.default.removeAttribute(element, attrName)
}
};
initRender.prototype.show = function() {
return this.toggle(true)
};
initRender.prototype.hide = function() {
return this.toggle(false)
};
initRender.prototype.toggle = function(value) {
if (this[0]) {
this.toggleClass("dx-state-invisible", !value)
}
return this
};
initRender.prototype.attr = function(attrName, value) {
if (this.length > 1 && arguments.length > 1) {
return repeatMethod.call(this, "attr", arguments)
}
if (!this[0]) {
if ((0, _type.isObject)(attrName) || void 0 !== value) {
return this
} else {
return
}
}
if (!this[0].getAttribute) {
return this.prop(attrName, value)
}
if ("string" === typeof attrName && 1 === arguments.length) {
var result = this[0].getAttribute(attrName);
return null == result ? void 0 : result
} else if ((0, _type.isPlainObject)(attrName)) {
for (var key in attrName) {
this.attr(key, attrName[key])
}
} else {
setAttributeValue(this[0], attrName, value)
}
return this
};
initRender.prototype.removeAttr = function(attrName) {
this[0] && _dom_adapter.default.removeAttribute(this[0], attrName);
return this
};
initRender.prototype.prop = function(propName, value) {
if (!this[0]) {
return this
}
if ("string" === typeof propName && 1 === arguments.length) {
return this[0][propName]
} else if ((0, _type.isPlainObject)(propName)) {
for (var key in propName) {
this.prop(key, propName[key])
}
} else {
_dom_adapter.default.setProperty(this[0], propName, value)
}
return this
};
initRender.prototype.addClass = function(className) {
return this.toggleClass(className, true)
};
initRender.prototype.removeClass = function(className) {
return this.toggleClass(className, false)
};
initRender.prototype.hasClass = function(className) {
if (!this[0] || void 0 === this[0].className) {
return false
}
var classNames = className.split(" ");
for (var i = 0; i < classNames.length; i++) {
if (this[0].classList) {
if (this[0].classList.contains(classNames[i])) {
return true
}
} else {
var _className = (0, _type.isString)(this[0].className) ? this[0].className : _dom_adapter.default.getAttribute(this[0], "class");
if ((_className || "").split(" ").indexOf(classNames[i]) >= 0) {
return true
}
}
}
return false
};
initRender.prototype.toggleClass = function(className, value) {
if (this.length > 1) {
return repeatMethod.call(this, "toggleClass", arguments)
}
if (!this[0] || !className) {
return this
}
value = void 0 === value ? !this.hasClass(className) : value;
var classNames = className.split(" ");
for (var i = 0; i < classNames.length; i++) {
_dom_adapter.default.setClass(this[0], classNames[i], value)
}
return this
};
initRender.prototype.html = function(value) {
if (!arguments.length) {
return this[0].innerHTML
}
this.empty();
if ("string" === typeof value && !(0, _html_parser.isTablePart)(value) || "number" === typeof value) {
this[0].innerHTML = value;
return this
}
return this.append((0, _html_parser.parseHTML)(value))
};
var appendElements = function(element, nextSibling) {
if (!this[0] || !element) {
return
}
if ("string" === typeof element) {
element = (0, _html_parser.parseHTML)(element)
} else if (element.nodeType) {
element = [element]
} else if ((0, _type.isNumeric)(element)) {
element = [_dom_adapter.default.createTextNode(element)]
}
for (var i = 0; i < element.length; i++) {
var item = element[i];
var container = this[0];
var wrapTR = "TABLE" === container.tagName && "TR" === item.tagName;
if (wrapTR && container.tBodies && container.tBodies.length) {
container = container.tBodies[0]
}
_dom_adapter.default.insertElement(container, item.nodeType ? item : item[0], nextSibling)
}
};
var setCss = function(name, value) {
if (!this[0] || !this[0].style) {
return
}
if (null === value || "number" === typeof value && isNaN(value)) {
return
}
name = (0, _style.styleProp)(name);
for (var i = 0; i < this.length; i++) {
this[i].style[name] = (0, _style.normalizeStyleProp)(name, value)
}
};
initRender.prototype.css = function(name, value) {
if ((0, _type.isString)(name)) {
if (2 === arguments.length) {
setCss.call(this, name, value)
} else {
if (!this[0]) {
return
}
name = (0, _style.styleProp)(name);
var result = window.getComputedStyle(this[0])[name] || this[0].style[name];
return (0, _type.isNumeric)(result) ? result.toString() : result
}
} else if ((0, _type.isPlainObject)(name)) {
for (var key in name) {
setCss.call(this, key, name[key])
}
}
return this
};
initRender.prototype.prepend = function(element) {
if (arguments.length > 1) {
for (var i = 0; i < arguments.length; i++) {
this.prepend(arguments[i])
}
return this
}
appendElements.apply(this, [element, this[0].firstChild]);
return this
};
initRender.prototype.append = function(element) {
if (arguments.length > 1) {
for (var i = 0; i < arguments.length; i++) {
this.append(arguments[i])
}
return this
}
appendElements.apply(this, [element]);
return this
};
initRender.prototype.prependTo = function(element) {
if (this.length > 1) {
for (var i = this.length - 1; i >= 0; i--) {
renderer(this[i]).prependTo(element)
}
return this
}
element = renderer(element);
if (element[0]) {
_dom_adapter.default.insertElement(element[0], this[0], element[0].firstChild)
}
return this
};
initRender.prototype.appendTo = function(element) {
if (this.length > 1) {
return repeatMethod.call(this, "appendTo", arguments)
}
_dom_adapter.default.insertElement(renderer(element)[0], this[0]);
return this
};
initRender.prototype.insertBefore = function(element) {
if (element && element[0]) {
_dom_adapter.default.insertElement(element[0].parentNode, this[0], element[0])
}
return this
};
initRender.prototype.insertAfter = function(element) {
if (element && element[0]) {
_dom_adapter.default.insertElement(element[0].parentNode, this[0], element[0].nextSibling)
}
return this
};
initRender.prototype.before = function(element) {
if (this[0]) {
_dom_adapter.default.insertElement(this[0].parentNode, element[0], this[0])
}
return this
};
initRender.prototype.after = function(element) {
if (this[0]) {
_dom_adapter.default.insertElement(this[0].parentNode, element[0], this[0].nextSibling)
}
return this
};
initRender.prototype.wrap = function(wrapper) {
if (this[0]) {
var wrap = renderer(wrapper);
wrap.insertBefore(this);
wrap.append(this)
}
return this
};
initRender.prototype.wrapInner = function(wrapper) {
var contents = this.contents();
if (contents.length) {
contents.wrap(wrapper)
} else {
this.append(wrapper)
}
return this
};
initRender.prototype.replaceWith = function(element) {
if (!(element && element[0])) {
return
}
if (element.is(this)) {
return this
}
element.insertBefore(this);
this.remove();
return element
};
initRender.prototype.remove = function() {
if (this.length > 1) {
return repeatMethod.call(this, "remove", arguments)
}(0, _element_data.cleanDataRecursive)(this[0], true);
_dom_adapter.default.removeElement(this[0]);
return this
};
initRender.prototype.detach = function() {
if (this.length > 1) {
return repeatMethod.call(this, "detach", arguments)
}
_dom_adapter.default.removeElement(this[0]);
return this
};
initRender.prototype.empty = function() {
if (this.length > 1) {
return repeatMethod.call(this, "empty", arguments)
}(0, _element_data.cleanDataRecursive)(this[0]);
_dom_adapter.default.setText(this[0], "");
return this
};
initRender.prototype.clone = function() {
var result = [];
for (var i = 0; i < this.length; i++) {
result.push(this[i].cloneNode(true))
}
return renderer(result)
};
initRender.prototype.text = function(value) {
if (!arguments.length) {
var result = "";
for (var i = 0; i < this.length; i++) {
result += this[i] && this[i].textContent || ""
}
return result
}
var text = (0, _type.isFunction)(value) ? value() : value;
(0, _element_data.cleanDataRecursive)(this[0], false);
_dom_adapter.default.setText(this[0], (0, _type.isDefined)(text) ? text : "");
return this
};
initRender.prototype.val = function(value) {
if (1 === arguments.length) {
return this.prop("value", (0, _type.isDefined)(value) ? value : "")
}
return this.prop("value")
};
initRender.prototype.contents = function() {
if (!this[0]) {
return renderer()
}
var result = [];
result.push.apply(result, this[0].childNodes);
return renderer(result)
};
initRender.prototype.find = function(selector) {
var result = renderer();
if (!selector) {
return result
}
var nodes = [];
var i;
if ("string" === typeof selector) {
selector = selector.trim();
for (i = 0; i < this.length; i++) {
var element = this[i];
if (_dom_adapter.default.isElementNode(element)) {
var elementId = element.getAttribute("id");
var queryId = elementId || "dx-query-children";
if (!elementId) {
setAttributeValue(element, "id", queryId)
}
queryId = "[id='" + queryId + "'] ";
var querySelector = queryId + selector.replace(/([^\\])(,)/g, "$1, " + queryId);
nodes.push.apply(nodes, _dom_adapter.default.querySelectorAll(element, querySelector));
setAttributeValue(element, "id", elementId)
} else if (_dom_adapter.default.isDocument(element) || _dom_adapter.default.isDocumentFragment(element)) {
nodes.push.apply(nodes, _dom_adapter.default.querySelectorAll(element, selector))
}
}
} else {
for (i = 0; i < this.length; i++) {
selector = _dom_adapter.default.isNode(selector) ? selector : selector[0];
if (this[i] !== selector && this[i].contains(selector)) {
nodes.push(selector)
}
}
}
return result.add(nodes)
};
var isVisible = function(_, element) {
var _element$host;
element = null !== (_element$host = element.host) && void 0 !== _element$host ? _element$host : element;
if (!element.nodeType) {
return true
}
return !!(element.offsetWidth || element.offsetHeight || element.getClientRects().length)
};
initRender.prototype.filter = function(selector) {
if (!selector) {
return renderer()
}
if (":visible" === selector) {
return this.filter(isVisible)
} else if (":hidden" === selector) {
return this.filter((function(_, element) {
return !isVisible(0, element)
}))
}
var result = [];
for (var i = 0; i < this.length; i++) {
var item = this[i];
if (_dom_adapter.default.isElementNode(item) && "string" === (0, _type.type)(selector)) {
_dom_adapter.default.elementMatches(item, selector) && result.push(item)
} else if (_dom_adapter.default.isNode(selector) || (0, _type.isWindow)(selector)) {
selector === item && result.push(item)
} else if ((0, _type.isFunction)(selector)) {
selector.call(item, i, item) && result.push(item)
} else {
for (var j = 0; j < selector.length; j++) {
selector[j] === item && result.push(item)
}
}
}
return renderer(result)
};
initRender.prototype.not = function(selector) {
var result = [];
var nodes = this.filter(selector).toArray();
for (var i = 0; i < this.length; i++) {
if (-1 === nodes.indexOf(this[i])) {
result.push(this[i])
}
}
return renderer(result)
};
initRender.prototype.is = function(selector) {
return !!this.filter(selector).length
};
initRender.prototype.children = function(selector) {
var result = [];
for (var i = 0; i < this.length; i++) {
var nodes = this[i] ? this[i].childNodes : [];
for (var j = 0; j < nodes.length; j++) {
if (_dom_adapter.default.isElementNode(nodes[j])) {
result.push(nodes[j])
}
}
}
result = renderer(result);
return selector ? result.filter(selector) : result
};
initRender.prototype.siblings = function() {
var element = this[0];
if (!element || !element.parentNode) {
return renderer()
}
var result = [];
var parentChildNodes = element.parentNode.childNodes || [];
for (var i = 0; i < parentChildNodes.length; i++) {
var node = parentChildNodes[i];
if (_dom_adapter.default.isElementNode(node) && node !== element) {
result.push(node)
}
}
return renderer(result)
};
initRender.prototype.each = function(callback) {
for (var i = 0; i < this.length; i++) {
if (false === callback.call(this[i], i, this[i])) {
break
}
}
};
initRender.prototype.index = function(element) {
if (!element) {
return this.parent().children().index(this)
}
element = renderer(element);
return this.toArray().indexOf(element[0])
};
initRender.prototype.get = function(index) {
return this[index < 0 ? this.length + index : index]
};
initRender.prototype.eq = function(index) {
index = index < 0 ? this.length + index : index;
return renderer(this[index])
};
initRender.prototype.first = function() {
return this.eq(0)
};
initRender.prototype.last = function() {
return this.eq(-1)
};
initRender.prototype.select = function() {
for (var i = 0; i < this.length; i += 1) {
this[i].select && this[i].select()
}
return this
};
initRender.prototype.parent = function(selector) {
if (!this[0]) {
return renderer()
}
var result = renderer(this[0].parentNode);
return !selector || result.is(selector) ? result : renderer()
};
initRender.prototype.parents = function(selector) {
var result = [];
var parent = this.parent();
while (parent && parent[0] && !_dom_adapter.default.isDocument(parent[0])) {
if (_dom_adapter.default.isElementNode(parent[0])) {
if (!selector || parent.is(selector)) {
result.push(parent.get(0))
}
}
parent = parent.parent()
}
return renderer(result)
};
initRender.prototype.closest = function(selector) {
if (this.is(selector)) {
return this
}
var parent = this.parent();
while (parent && parent.length) {
if (parent.is(selector)) {
return parent
}
parent = parent.parent()
}
return renderer()
};
initRender.prototype.next = function(selector) {
if (!this[0]) {
return renderer()
}
var next = renderer(this[0].nextSibling);
if (!arguments.length) {
return next
}
while (next && next.length) {
if (next.is(selector)) {
return next
}
next = next.next()
}
return renderer()
};
initRender.prototype.prev = function() {
if (!this[0]) {
return renderer()
}
return renderer(this[0].previousSibling)
};
initRender.prototype.add = function(selector) {
var targets = renderer(selector);
var result = this.toArray();
for (var i = 0; i < targets.length; i++) {
var target = targets[i];
if (-1 === result.indexOf(target)) {
result.push(target)
}
}
return renderer(result)
};
var emptyArray = [];
initRender.prototype.splice = function() {
return renderer(emptyArray.splice.apply(this, arguments))
};
initRender.prototype.slice = function() {
return renderer(emptyArray.slice.apply(this, arguments))
};
initRender.prototype.toArray = function() {
return emptyArray.slice.call(this)
};
initRender.prototype.offset = function() {
if (!this[0]) {
return
}
return (0, _size.getOffset)(this[0])
};
initRender.prototype.offsetParent = function() {
if (!this[0]) {
return renderer()
}
var offsetParent = renderer(this[0].offsetParent);
while (offsetParent[0] && "static" === offsetParent.css("position")) {
offsetParent = renderer(offsetParent[0].offsetParent)
}
offsetParent = offsetParent[0] ? offsetParent : renderer(_dom_adapter.default.getDocumentElement());
return offsetParent
};
initRender.prototype.position = function() {
if (!this[0]) {
return
}
var offset;
var marginTop = parseFloat(this.css("marginTop"));
var marginLeft = parseFloat(this.css("marginLeft"));
if ("fixed" === this.css("position")) {
offset = this[0].getBoundingClientRect();
return {
top: offset.top - marginTop,
left: offset.left - marginLeft
}
}
offset = this.offset();
var offsetParent = this.offsetParent();
var parentOffset = {
top: 0,
left: 0
};
if ("HTML" !== offsetParent[0].nodeName) {
parentOffset = offsetParent.offset()
}
parentOffset = {
top: parentOffset.top + parseFloat(offsetParent.css("borderTopWidth")),
left: parentOffset.left + parseFloat(offsetParent.css("borderLeftWidth"))
};
return {
top: offset.top - parentOffset.top - marginTop,
left: offset.left - parentOffset.left - marginLeft
}
};
[{
name: "scrollLeft",
offsetProp: "pageXOffset",
scrollWindow: function(win, value) {
win.scrollTo(value, win.pageYOffset)
}
}, {
name: "scrollTop",
offsetProp: "pageYOffset",
scrollWindow: function(win, value) {
win.scrollTo(win.pageXOffset, value)
}
}].forEach((function(directionStrategy) {
var propName = directionStrategy.name;
initRender.prototype[propName] = function(value) {
if (!this[0]) {
return
}
var window = (0, _size.getWindowByElement)(this[0]);
if (void 0 === value) {
return window ? window[directionStrategy.offsetProp] : this[0][propName]
}
if (window) {
directionStrategy.scrollWindow(window, value)
} else {
this[0][propName] = value
}
return this
}
}));
initRender.prototype.data = function(key, value) {
if (!this[0]) {
return
}
if (arguments.length < 2) {
return _element_data.data.call(renderer, this[0], key)
}
_element_data.data.call(renderer, this[0], key, value);
return this
};
initRender.prototype.removeData = function(key) {
this[0] && (0, _element_data.removeData)(this[0], key);
return this
};
var rendererWrapper = function() {
return renderer.apply(this, arguments)
};
Object.defineProperty(rendererWrapper, "fn", {
enumerable: true,
configurable: true,
get: function() {
return renderer.fn
},
set: function(value) {
renderer.fn = value
}
});
var _default = {
set: function(strategy) {
renderer = strategy
},
get: function() {
return rendererWrapper
}
};
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
91784:
/*!*********************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/resize_observer.js ***!
\*********************************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _common = __webpack_require__( /*! ./utils/common */ 20576);
var _window = __webpack_require__( /*! ./utils/window */ 58201);
var window = (0, _window.getWindow)();
var ResizeObserverMock = {
observe: _common.noop,
unobserve: _common.noop,
disconnect: _common.noop
};
var ResizeObserverSingleton = function() {
function ResizeObserverSingleton() {
var _this = this;
if (!(0, _window.hasWindow)() || !window.ResizeObserver) {
return ResizeObserverMock
}
this._callbacksMap = new Map;
this._observer = new window.ResizeObserver((function(entries) {
entries.forEach((function(entry) {
var _this$_callbacksMap$g;
null === (_this$_callbacksMap$g = _this._callbacksMap.get(entry.target)) || void 0 === _this$_callbacksMap$g ? void 0 : _this$_callbacksMap$g(entry)
}))
}))
}
var _proto = ResizeObserverSingleton.prototype;
_proto.observe = function(element, callback) {
this._callbacksMap.set(element, callback);
this._observer.observe(element)
};
_proto.unobserve = function(element) {
this._callbacksMap.delete(element);
this._observer.unobserve(element)
};
_proto.disconnect = function() {
this._callbacksMap.clear();
this._observer.disconnect()
};
return ResizeObserverSingleton
}();
var resizeObserverSingleton = new ResizeObserverSingleton;
var _default = resizeObserverSingleton;
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
14192:
/*!**********************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/template_manager.js ***!
\**********************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.TemplateManager = void 0;
var _renderer = (obj = __webpack_require__( /*! ./renderer */ 68374), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var _type = __webpack_require__( /*! ./utils/type */ 35922);
var _common = __webpack_require__( /*! ./utils/common */ 20576);
var _extend = __webpack_require__( /*! ./utils/extend */ 13306);
var _function_template = __webpack_require__( /*! ./templates/function_template */ 68494);
var _empty_template = __webpack_require__( /*! ./templates/empty_template */ 10688);
var _template_manager = __webpack_require__( /*! ./utils/template_manager */ 69697);
function _typeof(obj) {
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 _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, (arg = descriptor.key, key = void 0, key = function(input, hint) {
if ("object" !== _typeof(input) || null === input) {
return input
}
var prim = input[Symbol.toPrimitive];
if (void 0 !== prim) {
var res = prim.call(input, hint || "default");
if ("object" !== _typeof(res)) {
return res
}
throw new TypeError("@@toPrimitive must return a primitive value.")
}
return ("string" === hint ? String : Number)(input)
}(arg, "string"), "symbol" === _typeof(key) ? key : String(key)), descriptor)
}
var arg, key
}
var DX_POLYMORPH_WIDGET_TEMPLATE = new _function_template.FunctionTemplate((function(_ref) {
var model = _ref.model,
parent = _ref.parent;
var widgetName = model.widget;
if (!widgetName) {
return (0, _renderer.default)()
}
var widgetElement = (0, _renderer.default)(" ");
var widgetOptions = model.options || {};
if (parent) {
parent._createComponent(widgetElement, widgetName, widgetOptions)
} else {
widgetElement[widgetName](widgetOptions)
}
return widgetElement
}));
var TemplateManager = function() {
function TemplateManager(createElement, anonymousTemplateName) {
this._tempTemplates = [];
this._defaultTemplates = {};
this._anonymousTemplateName = anonymousTemplateName || "template";
this._createElement = createElement || _template_manager.defaultCreateElement;
this._createTemplateIfNeeded = this._createTemplateIfNeeded.bind(this)
}
TemplateManager.createDefaultOptions = function() {
return {
integrationOptions: {
watchMethod: function(fn, callback) {
var options = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
if (!options.skipImmediate) {
callback(fn())
}
return _common.noop
},
templates: {
"dx-polymorph-widget": DX_POLYMORPH_WIDGET_TEMPLATE
},
useDeferUpdateForTemplates: true
}
}
};
var _proto = TemplateManager.prototype;
_proto.addDefaultTemplates = function(templates) {
this._defaultTemplates = (0, _extend.extend)({}, this._defaultTemplates, templates)
};
_proto.dispose = function() {
this._tempTemplates.forEach((function(tempTemplate) {
tempTemplate.template.dispose && tempTemplate.template.dispose()
}));
this._tempTemplates = []
};
_proto.extractTemplates = function($el) {
var templates = this._extractTemplates($el);
var anonymousTemplateMeta = this._extractAnonymousTemplate($el);
return {
templates: templates,
anonymousTemplateMeta: anonymousTemplateMeta
}
};
_proto._extractTemplates = function($el) {
var _this = this;
var templates = (0, _template_manager.findTemplates)($el, "dxTemplate");
var suitableTemplates = (0, _template_manager.suitableTemplatesByName)(templates);
templates.forEach((function(_ref2) {
var element = _ref2.element,
name = _ref2.options.name;
if (element === suitableTemplates[name]) {
(0, _renderer.default)(element).addClass("dx-template-wrapper").detach()
} else {
(0, _renderer.default)(element).remove()
}
}));
return Object.keys(suitableTemplates).map((function(name) {
return {
name: name,
template: _this._createTemplate(suitableTemplates[name])
}
}))
};
_proto._extractAnonymousTemplate = function($el) {
var $anonymousTemplate = $el.contents().detach();
var $notJunkTemplateContent = $anonymousTemplate.filter((function(_, element) {
var isTextNode = 3 === element.nodeType;
var isEmptyText = (0, _renderer.default)(element).text().trim().length < 1;
return !(isTextNode && isEmptyText)
}));
return $notJunkTemplateContent.length > 0 ? {
template: this._createTemplate($anonymousTemplate),
name: this._anonymousTemplateName
} : {}
};
_proto._createTemplateIfNeeded = function(templateSource) {
var cachedTemplate = this._tempTemplates.filter((function(tempTemplate) {
return tempTemplate.source === (0, _template_manager.templateKey)(templateSource)
}))[0];
if (cachedTemplate) {
return cachedTemplate.template
}
var template = this._createTemplate(templateSource);
this._tempTemplates.push({
template: template,
source: (0, _template_manager.templateKey)(templateSource)
});
return template
};
_proto._createTemplate = function(templateSource) {
return this._createElement((0, _template_manager.validateTemplateSource)(templateSource))
};
_proto.getTemplate = function(templateSource, templates, _ref3, context) {
var _this2 = this;
var isAsyncTemplate = _ref3.isAsyncTemplate,
skipTemplates = _ref3.skipTemplates;
if (!(0, _type.isFunction)(templateSource)) {
return (0, _template_manager.acquireTemplate)(templateSource, this._createTemplateIfNeeded, templates, isAsyncTemplate, skipTemplates, this._defaultTemplates)
}
return new _function_template.FunctionTemplate((function(options) {
var templateSourceResult = templateSource.apply(context, (0, _template_manager.getNormalizedTemplateArgs)(options));
if (!(0, _type.isDefined)(templateSourceResult)) {
return new _empty_template.EmptyTemplate
}
var dispose = false;
var template = (0, _template_manager.acquireTemplate)(templateSourceResult, (function(templateSource) {
if (templateSource.nodeType || (0, _type.isRenderer)(templateSource) && !(0, _renderer.default)(templateSource).is("script")) {
return new _function_template.FunctionTemplate((function() {
return templateSource
}))
}
dispose = true;
return _this2._createTemplate(templateSource)
}), templates, isAsyncTemplate, skipTemplates, _this2._defaultTemplates);
var result = template.render(options);
dispose && template.dispose && template.dispose();
return result
}))
};
! function(Constructor, protoProps, staticProps) {
if (protoProps) {
_defineProperties(Constructor.prototype, protoProps)
}
if (staticProps) {
_defineProperties(Constructor, staticProps)
}
Object.defineProperty(Constructor, "prototype", {
writable: false
});
return Constructor
}(TemplateManager, [{
key: "anonymousTemplateName",
get: function() {
return this._anonymousTemplateName
}
}]);
return TemplateManager
}();
exports.TemplateManager = TemplateManager
},
93280:
/*!*********************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/templates/bindable_template.js ***!
\*********************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.BindableTemplate = void 0;
var _renderer = _interopRequireDefault(__webpack_require__( /*! ../renderer */ 68374));
var _template_base = __webpack_require__( /*! ./template_base */ 81033);
var _events_engine = _interopRequireDefault(__webpack_require__( /*! ../../events/core/events_engine */ 55994));
var _remove = __webpack_require__( /*! ../../events/remove */ 29007);
var _type = __webpack_require__( /*! ../utils/type */ 35922);
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
function _setPrototypeOf(o, p) {
_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(o, p) {
o.__proto__ = p;
return o
};
return _setPrototypeOf(o, p)
}
var watchChanges = function(rawData, watchMethod, fields, fieldsMap, callback) {
var fieldsDispose;
var globalDispose = function(data, watchMethod, callback) {
return watchMethod((function() {
return data
}), callback)
}(rawData, watchMethod, (function(dataWithRawFields) {
fieldsDispose && fieldsDispose();
if ((0, _type.isPrimitive)(dataWithRawFields)) {
callback(dataWithRawFields);
return
}
fieldsDispose = function(data, watchMethod, fields, fieldsMap, callback) {
var resolvedData = {};
var missedFields = fields.slice();
var watchHandlers = fields.map((function(name) {
var fieldGetter = fieldsMap[name];
return watchMethod(fieldGetter ? function() {
return fieldGetter(data)
} : function() {
return data[name]
}, (function(value) {
resolvedData[name] = value;
if (missedFields.length) {
var index = missedFields.indexOf(name);
if (index >= 0) {
missedFields.splice(index, 1)
}
}
if (!missedFields.length) {
callback(resolvedData)
}
}))
}));
return function() {
watchHandlers.forEach((function(dispose) {
return dispose()
}))
}
}(dataWithRawFields, watchMethod, fields, fieldsMap, callback)
}));
return function() {
fieldsDispose && fieldsDispose();
globalDispose && globalDispose()
}
};
var BindableTemplate = function(_TemplateBase) {
! function(subClass, superClass) {
subClass.prototype = Object.create(superClass.prototype);
subClass.prototype.constructor = subClass;
_setPrototypeOf(subClass, superClass)
}(BindableTemplate, _TemplateBase);
function BindableTemplate(render, fields, watchMethod, fieldsMap) {
var _this;
_this = _TemplateBase.call(this) || this;
_this._render = render;
_this._fields = fields;
_this._fieldsMap = fieldsMap || {};
_this._watchMethod = watchMethod;
return _this
}
var _proto = BindableTemplate.prototype;
_proto._renderCore = function(options) {
var _this2 = this;
var $container = (0, _renderer.default)(options.container);
var dispose = watchChanges(options.model, this._watchMethod, this._fields, this._fieldsMap, (function(data) {
$container.empty();
_this2._render($container, data, options.model)
}));
_events_engine.default.on($container, _remove.removeEvent, dispose);
return $container.contents()
};
return BindableTemplate
}(_template_base.TemplateBase);
exports.BindableTemplate = BindableTemplate
},
91627:
/*!**************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/templates/child_default_template.js ***!
\**************************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.ChildDefaultTemplate = void 0;
var _template_base = __webpack_require__( /*! ./template_base */ 81033);
function _setPrototypeOf(o, p) {
_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(o, p) {
o.__proto__ = p;
return o
};
return _setPrototypeOf(o, p)
}
var ChildDefaultTemplate = function(_TemplateBase) {
! function(subClass, superClass) {
subClass.prototype = Object.create(superClass.prototype);
subClass.prototype.constructor = subClass;
_setPrototypeOf(subClass, superClass)
}(ChildDefaultTemplate, _TemplateBase);
function ChildDefaultTemplate(name) {
var _this;
_this = _TemplateBase.call(this) || this;
_this.name = name;
return _this
}
return ChildDefaultTemplate
}(_template_base.TemplateBase);
exports.ChildDefaultTemplate = ChildDefaultTemplate
},
10688:
/*!******************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/templates/empty_template.js ***!
\******************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.EmptyTemplate = void 0;
var _renderer = (obj = __webpack_require__( /*! ../renderer */ 68374), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var _template_base = __webpack_require__( /*! ./template_base */ 81033);
function _setPrototypeOf(o, p) {
_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(o, p) {
o.__proto__ = p;
return o
};
return _setPrototypeOf(o, p)
}
var EmptyTemplate = function(_TemplateBase) {
! function(subClass, superClass) {
subClass.prototype = Object.create(superClass.prototype);
subClass.prototype.constructor = subClass;
_setPrototypeOf(subClass, superClass)
}(EmptyTemplate, _TemplateBase);
function EmptyTemplate() {
return _TemplateBase.apply(this, arguments) || this
}
var _proto = EmptyTemplate.prototype;
_proto._renderCore = function() {
return (0, _renderer.default)()
};
return EmptyTemplate
}(_template_base.TemplateBase);
exports.EmptyTemplate = EmptyTemplate
},
68494:
/*!*********************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/templates/function_template.js ***!
\*********************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.FunctionTemplate = void 0;
var _template_base = __webpack_require__( /*! ./template_base */ 81033);
var _dom = __webpack_require__( /*! ../utils/dom */ 3532);
function _setPrototypeOf(o, p) {
_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(o, p) {
o.__proto__ = p;
return o
};
return _setPrototypeOf(o, p)
}
var FunctionTemplate = function(_TemplateBase) {
! function(subClass, superClass) {
subClass.prototype = Object.create(superClass.prototype);
subClass.prototype.constructor = subClass;
_setPrototypeOf(subClass, superClass)
}(FunctionTemplate, _TemplateBase);
function FunctionTemplate(render) {
var _this;
_this = _TemplateBase.call(this) || this;
_this._render = render;
return _this
}
var _proto = FunctionTemplate.prototype;
_proto._renderCore = function(options) {
return (0, _dom.normalizeTemplateElement)(this._render(options))
};
return FunctionTemplate
}(_template_base.TemplateBase);
exports.FunctionTemplate = FunctionTemplate
},
9545:
/*!************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/templates/template.js ***!
\************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.Template = void 0;
var _renderer = (obj = __webpack_require__( /*! ../renderer */ 68374), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var _template_base = __webpack_require__( /*! ./template_base */ 81033);
var _dom = __webpack_require__( /*! ../utils/dom */ 3532);
var _template_engine_registry = __webpack_require__( /*! ./template_engine_registry */ 72987);
function _setPrototypeOf(o, p) {
_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(o, p) {
o.__proto__ = p;
return o
};
return _setPrototypeOf(o, p)
}(0, _template_engine_registry.registerTemplateEngine)("default", {
compile: function(element) {
return (0, _dom.normalizeTemplateElement)(element)
},
render: function(template, model, index) {
return template.clone()
}
});
(0, _template_engine_registry.setTemplateEngine)("default");
var Template = function(_TemplateBase) {
! function(subClass, superClass) {
subClass.prototype = Object.create(superClass.prototype);
subClass.prototype.constructor = subClass;
_setPrototypeOf(subClass, superClass)
}(Template, _TemplateBase);
function Template(element) {
var _this;
_this = _TemplateBase.call(this) || this;
_this._element = element;
return _this
}
var _proto = Template.prototype;
_proto._renderCore = function(options) {
var transclude = options.transclude;
if (!transclude && !this._compiledTemplate) {
this._compiledTemplate = (0, _template_engine_registry.getCurrentTemplateEngine)().compile(this._element)
}
return (0, _renderer.default)(" ").append(transclude ? this._element : (0, _template_engine_registry.getCurrentTemplateEngine)().render(this._compiledTemplate, options.model, options.index)).contents()
};
_proto.source = function() {
return (0, _renderer.default)(this._element).clone()
};
return Template
}(_template_base.TemplateBase);
exports.Template = Template
},
81033:
/*!*****************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/templates/template_base.js ***!
\*****************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.renderedCallbacks = exports.TemplateBase = void 0;
var _renderer = _interopRequireDefault(__webpack_require__( /*! ../renderer */ 68374));
var _dom_adapter = _interopRequireDefault(__webpack_require__( /*! ../dom_adapter */ 73349));
var _callbacks = _interopRequireDefault(__webpack_require__( /*! ../utils/callbacks */ 44504));
var _dom = __webpack_require__( /*! ../utils/dom */ 3532);
var _visibility_change = __webpack_require__( /*! ../../events/visibility_change */ 80506);
var _errors = _interopRequireDefault(__webpack_require__( /*! ../errors */ 17381));
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var renderedCallbacks = (0, _callbacks.default)({
syncStrategy: true
});
exports.renderedCallbacks = renderedCallbacks;
var TemplateBase = function() {
function TemplateBase() {}
var _proto = TemplateBase.prototype;
_proto.render = function(options) {
options = options || {};
var onRendered = options.onRendered;
delete options.onRendered;
var $result;
if (options.renovated && options.transclude && this._element) {
$result = (0, _renderer.default)(" ").append(this._element).contents()
} else {
$result = this._renderCore(options)
}
this._ensureResultInContainer($result, options.container);
renderedCallbacks.fire($result, options.container);
onRendered && onRendered();
return $result
};
_proto._ensureResultInContainer = function($result, container) {
if (!container) {
return
}
var $container = (0, _renderer.default)(container);
var resultInContainer = (0, _dom.contains)($container.get(0), $result.get(0));
$container.append($result);
if (resultInContainer) {
return
}
var resultInBody = _dom_adapter.default.getBody().contains($container.get(0));
if (!resultInBody) {
return
}(0, _visibility_change.triggerShownEvent)($result)
};
_proto._renderCore = function() {
throw _errors.default.Error("E0001")
};
return TemplateBase
}();
exports.TemplateBase = TemplateBase
},
72987:
/*!****************************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/templates/template_engine_registry.js ***!
\****************************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.getCurrentTemplateEngine = function() {
return currentTemplateEngine
};
exports.registerTemplateEngine = function(name, templateEngine) {
templateEngines[name] = templateEngine
};
exports.setTemplateEngine = function(templateEngine) {
if ((0, _type.isString)(templateEngine)) {
currentTemplateEngine = templateEngines[templateEngine];
if (!currentTemplateEngine) {
throw _errors.default.Error("E0020", templateEngine)
}
} else {
currentTemplateEngine = templateEngine
}
};
var _type = __webpack_require__( /*! ../utils/type */ 35922);
var _errors = (obj = __webpack_require__( /*! ../errors */ 17381), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var templateEngines = {};
var currentTemplateEngine
},
37208:
/*!****************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/utils/ajax.js ***!
\****************************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _deferred = __webpack_require__( /*! ./deferred */ 62754);
var _dom_adapter = _interopRequireDefault(__webpack_require__( /*! ../../core/dom_adapter */ 73349));
var _http_request = _interopRequireDefault(__webpack_require__( /*! ../../core/http_request */ 83448));
var _window = __webpack_require__( /*! ../../core/utils/window */ 58201);
var _extend = __webpack_require__( /*! ./extend */ 13306);
var _type = __webpack_require__( /*! ./type */ 35922);
var _dependency_injector = _interopRequireDefault(__webpack_require__( /*! ./dependency_injector */ 20476));
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var window = (0, _window.getWindow)();
var createScript = function(options) {
var script = _dom_adapter.default.createElement("script");
for (var name in options) {
script[name] = options[name]
}
return script
};
var removeScript = function(scriptNode) {
scriptNode.parentNode.removeChild(scriptNode)
};
var appendToHead = function(element) {
return _dom_adapter.default.getHead().appendChild(element)
};
var evalScript = function(code) {
var script = createScript({
text: code
});
appendToHead(script);
removeScript(script)
};
var getRequestOptions = function(options, headers) {
var params = options.data;
var paramsAlreadyString = "string" === typeof params;
var url = options.url || window.location.href;
if (!paramsAlreadyString && !options.cache) {
params = params || {};
params._ = Date.now()
}
if (params && !options.upload) {
if (!paramsAlreadyString) {
params = function(params) {
var result = [];
for (var name in params) {
var value = params[name];
if (void 0 === value) {
continue
}
if (null === value) {
value = ""
}
if ("function" === typeof value) {
value = value()
}
result.push(encodeURIComponent(name) + "=" + encodeURIComponent(value))
}
return result.join("&")
}(params)
}
if ("GET" === getMethod(options)) {
if ("" !== params) {
url += (url.indexOf("?") > -1 ? "&" : "?") + params
}
params = null
} else if (headers["Content-Type"] && headers["Content-Type"].indexOf("application/x-www-form-urlencoded") > -1) {
params = params.replace(/%20/g, "+")
}
}
return {
url: url,
parameters: params
}
};
function getMethod(options) {
return (options.method || "GET").toUpperCase()
}
var getRequestHeaders = function(options) {
var headers = options.headers || {};
headers["Content-Type"] = headers["Content-Type"] || function(options) {
var defaultContentType;
if (options.data && !options.upload && "GET" !== getMethod(options)) {
defaultContentType = "application/x-www-form-urlencoded;charset=utf-8"
}
return options.contentType || defaultContentType
}(options);
headers.Accept = headers.Accept || function(options) {
var dataType = options.dataType || "*";
var scriptAccept = "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript";
var accepts = {
"*": "*/*",
text: "text/plain",
html: "text/html",
xml: "application/xml, text/xml",
json: "application/json, text/javascript",
jsonp: scriptAccept,
script: scriptAccept
};
(0, _extend.extendFromObject)(accepts, options.accepts, true);
return accepts[dataType] ? accepts[dataType] + ("*" !== dataType ? ", */*; q=0.01" : "") : accepts["*"]
}(options);
if (!options.crossDomain && !headers["X-Requested-With"]) {
headers["X-Requested-With"] = "XMLHttpRequest"
}
return headers
};
var _default = (0, _dependency_injector.default)({
sendRequest: function(options) {
var xhr = _http_request.default.getXhr();
var d = new _deferred.Deferred;
var result = d.promise();
var async = (0, _type.isDefined)(options.async) ? options.async : true;
var dataType = options.dataType;
var timeout = options.timeout || 0;
var timeoutId;
options.crossDomain = function(url) {
if (!(0, _window.hasWindow)()) {
return true
}
var crossDomain = false;
var originAnchor = _dom_adapter.default.createElement("a");
var urlAnchor = _dom_adapter.default.createElement("a");
originAnchor.href = window.location.href;
try {
urlAnchor.href = url;
urlAnchor.href = urlAnchor.href;
crossDomain = originAnchor.protocol + "//" + originAnchor.host !== urlAnchor.protocol + "//" + urlAnchor.host
} catch (e) {
crossDomain = true
}
return crossDomain
}(options.url);
var needScriptEvaluation = "jsonp" === dataType || "script" === dataType;
if (void 0 === options.cache) {
options.cache = !needScriptEvaluation
}
var callbackName = function(options) {
if ("jsonp" === options.dataType) {
var random = Math.random().toString().replace(/\D/g, "");
var callbackName = options.jsonpCallback || "dxCallback" + Date.now() + "_" + random;
var callbackParameter = options.jsonp || "callback";
options.data = options.data || {};
options.data[callbackParameter] = callbackName;
return callbackName
}
}(options);
var headers = getRequestHeaders(options);
var requestOptions = getRequestOptions(options, headers);
var url = requestOptions.url;
var parameters = requestOptions.parameters;
if (callbackName) {
window[callbackName] = function(data) {
d.resolve(data, "success", xhr)
}
}
if (options.crossDomain && needScriptEvaluation) {
(function(url) {
var script = createScript({
src: url
});
return new Promise((function(resolve, reject) {
var events = {
load: resolve,
error: reject
};
var loadHandler = function(e) {
events[e.type]();
removeScript(script)
};
for (var event in events) {
_dom_adapter.default.listen(script, event, loadHandler)
}
appendToHead(script)
}))
})(url).then((function() {
if ("jsonp" === dataType) {
return
}
d.resolve(null, "success", xhr)
}), (function() {
d.reject(xhr, "error")
}));
return result
}
if (options.crossDomain && !("withCredentials" in xhr)) {
d.reject(xhr, "error");
return result
}
xhr.open(getMethod(options), url, async, options.username, options.password);
if (async) {
xhr.timeout = timeout;
timeoutId = function(timeout, xhr) {
return timeout && setTimeout((function() {
xhr.customStatus = "timeout";
xhr.abort()
}), timeout)
}(timeout, xhr)
}
xhr.onreadystatechange = function(e) {
if (4 === xhr.readyState) {
clearTimeout(timeoutId);
if (status = xhr.status, 200 <= status && status < 300) {
if (function(status) {
return 204 !== status
}(xhr.status)) {
! function(deferred, xhr, dataType) {
var data = function(xhr) {
return xhr.responseType && "text" !== xhr.responseType || "string" !== typeof xhr.responseText ? xhr.response : xhr.responseText
}(xhr);
switch (dataType) {
case "jsonp":
evalScript(data);
break;
case "script":
evalScript(data);
deferred.resolve(data, "success", xhr);
break;
case "json":
try {
deferred.resolve(JSON.parse(data), "success", xhr)
} catch (e) {
deferred.reject(xhr, "parsererror", e)
}
break;
default:
deferred.resolve(data, "success", xhr)
}
}(d, xhr, dataType)
} else {
d.resolve(null, "nocontent", xhr)
}
} else {
d.reject(xhr, xhr.customStatus || "error")
}
}
var status
};
if (options.upload) {
xhr.upload.onprogress = options.upload.onprogress;
xhr.upload.onloadstart = options.upload.onloadstart;
xhr.upload.onabort = options.upload.onabort
}
if (options.xhrFields) {
for (var field in options.xhrFields) {
xhr[field] = options.xhrFields[field]
}
}
if ("arraybuffer" === options.responseType) {
xhr.responseType = options.responseType
}
for (var name in headers) {
if (Object.prototype.hasOwnProperty.call(headers, name) && (0, _type.isDefined)(headers[name])) {
xhr.setRequestHeader(name, headers[name])
}
}
if (options.beforeSend) {
options.beforeSend(xhr)
}
xhr.send(parameters);
result.abort = function() {
xhr.abort()
};
return result
}
});
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
89386:
/*!*****************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/utils/array.js ***!
\*****************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.wrapToArray = exports.removeDuplicates = exports.normalizeIndexes = exports.groupBy = exports.getUniqueValues = exports.getIntersection = void 0;
var _type = __webpack_require__( /*! ./type */ 35922);
var _object = __webpack_require__( /*! ./object */ 48013);
var _config2 = (obj = __webpack_require__( /*! ../config */ 80209), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
function _toConsumableArray(arr) {
return function(arr) {
if (Array.isArray(arr)) {
return _arrayLikeToArray(arr)
}
}(arr) || function(iter) {
if ("undefined" !== typeof Symbol && null != iter[Symbol.iterator] || null != iter["@@iterator"]) {
return Array.from(iter)
}
}(arr) || function(o, minLen) {
if (!o) {
return
}
if ("string" === typeof o) {
return _arrayLikeToArray(o, minLen)
}
var n = Object.prototype.toString.call(o).slice(8, -1);
if ("Object" === n && o.constructor) {
n = o.constructor.name
}
if ("Map" === n || "Set" === n) {
return Array.from(o)
}
if ("Arguments" === n || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) {
return _arrayLikeToArray(o, minLen)
}
}(arr) || function() {
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 _arrayLikeToArray(arr, len) {
if (null == len || len > arr.length) {
len = arr.length
}
for (var i = 0, arr2 = new Array(len); i < len; i++) {
arr2[i] = arr[i]
}
return arr2
}
function createOccurrenceMap(array) {
return array.reduce((function(map, value) {
var _map$get;
var count = (null !== (_map$get = map.get(value)) && void 0 !== _map$get ? _map$get : 0) + 1;
map.set(value, count);
return map
}), new Map)
}
exports.wrapToArray = function(item) {
return Array.isArray(item) ? item : [item]
};
exports.getUniqueValues = function(values) {
return _toConsumableArray(new Set(values))
};
exports.getIntersection = function(firstArray, secondArray) {
var toRemoveMap = createOccurrenceMap(secondArray);
return firstArray.filter((function(value) {
var occurrencesCount = toRemoveMap.get(value);
occurrencesCount && toRemoveMap.set(value, occurrencesCount - 1);
return occurrencesCount
}))
};
exports.removeDuplicates = function() {
var from = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : [];
var toRemove = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : [];
var toRemoveMap = createOccurrenceMap(toRemove);
return from.filter((function(value) {
var occurrencesCount = toRemoveMap.get(value);
occurrencesCount && toRemoveMap.set(value, occurrencesCount - 1);
return !occurrencesCount
}))
};
exports.normalizeIndexes = function(items, indexPropName, currentItem, needIndexCallback) {
var indexedItems = {};
var _config = (0, _config2.default)(),
useLegacyVisibleIndex = _config.useLegacyVisibleIndex;
var currentIndex = 0;
var shouldUpdateIndex = function(item) {
return !(0, _type.isDefined)(item[indexPropName]) && (!needIndexCallback || needIndexCallback(item))
};
items.forEach((function(item) {
var index = item[indexPropName];
if (index >= 0) {
indexedItems[index] = indexedItems[index] || [];
if (item === currentItem) {
indexedItems[index].unshift(item)
} else {
indexedItems[index].push(item)
}
} else {
item[indexPropName] = void 0
}
}));
if (!useLegacyVisibleIndex) {
items.forEach((function(item) {
if (shouldUpdateIndex(item)) {
while (indexedItems[currentIndex]) {
currentIndex++
}
indexedItems[currentIndex] = [item];
currentIndex++
}
}))
}
currentIndex = 0;
(0, _object.orderEach)(indexedItems, (function(index, items) {
items.forEach((function(item) {
if (index >= 0) {
item[indexPropName] = currentIndex++
}
}))
}));
if (useLegacyVisibleIndex) {
items.forEach((function(item) {
if (shouldUpdateIndex(item)) {
item[indexPropName] = currentIndex++
}
}))
}
};
exports.groupBy = function(array, getGroupName) {
return array.reduce((function(groupedResult, item) {
var _groupedResult$groupN;
var groupName = getGroupName(item);
groupedResult[groupName] = null !== (_groupedResult$groupN = groupedResult[groupName]) && void 0 !== _groupedResult$groupN ? _groupedResult$groupN : [];
groupedResult[groupName].push(item);
return groupedResult
}), {})
}
},
34671:
/*!*************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/utils/array_compare.js ***!
\*************************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.isKeysEqual = exports.findChanges = void 0;
var _type = __webpack_require__( /*! ./type */ 35922);
var getKeyWrapper = function(item, getKey) {
var key = getKey(item);
if ((0, _type.isObject)(key)) {
try {
return JSON.stringify(key)
} catch (e) {
return key
}
}
return key
};
var getSameNewByOld = function(oldItem, newItems, newIndexByKey, getKey) {
var key = getKeyWrapper(oldItem, getKey);
return newItems[newIndexByKey[key]]
};
exports.isKeysEqual = function(oldKeys, newKeys) {
if (oldKeys.length !== newKeys.length) {
return false
}
for (var i = 0; i < newKeys.length; i++) {
if (oldKeys[i] !== newKeys[i]) {
return false
}
}
return true
};
exports.findChanges = function(oldItems, newItems, getKey, isItemEquals) {
var oldIndexByKey = {};
var newIndexByKey = {};
var addedCount = 0;
var removeCount = 0;
var result = [];
oldItems.forEach((function(item, index) {
var key = getKeyWrapper(item, getKey);
oldIndexByKey[key] = index
}));
newItems.forEach((function(item, index) {
var key = getKeyWrapper(item, getKey);
newIndexByKey[key] = index
}));
var itemCount = Math.max(oldItems.length, newItems.length);
for (var index = 0; index < itemCount + addedCount; index++) {
var newItem = newItems[index];
var oldNextIndex = index - addedCount + removeCount;
var nextOldItem = oldItems[oldNextIndex];
var isRemoved = !newItem || nextOldItem && !getSameNewByOld(nextOldItem, newItems, newIndexByKey, getKey);
if (isRemoved) {
if (nextOldItem) {
result.push({
type: "remove",
key: getKey(nextOldItem),
index: index,
oldItem: nextOldItem
});
removeCount++;
index--
}
} else {
var key = getKeyWrapper(newItem, getKey);
var oldIndex = oldIndexByKey[key];
var oldItem = oldItems[oldIndex];
if (!oldItem) {
addedCount++;
result.push({
type: "insert",
data: newItem,
index: index
})
} else if (oldIndex === oldNextIndex) {
if (!isItemEquals(oldItem, newItem)) {
result.push({
type: "update",
data: newItem,
key: getKey(newItem),
index: index,
oldItem: oldItem
})
}
} else {
return
}
}
}
return result
}
},
47810:
/*!*******************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/utils/browser.js ***!
\*******************************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _extend = __webpack_require__( /*! ./extend */ 13306);
var _window = __webpack_require__( /*! ./window */ 58201);
var navigator = (0, _window.getNavigator)();
var webkitRegExp = /(webkit)[ /]([\w.]+)/;
var mozillaRegExp = /(mozilla)(?:.*? rv:([\w.]+))/;
var browserFromUA = function(ua) {
ua = ua.toLowerCase();
var result = {};
var matches = webkitRegExp.exec(ua) || ua.indexOf("compatible") < 0 && mozillaRegExp.exec(ua) || [];
var browserName = matches[1];
var browserVersion = matches[2];
if ("webkit" === browserName) {
result.webkit = true;
if (ua.indexOf("chrome") >= 0 || ua.indexOf("crios") >= 0) {
browserName = "chrome";
browserVersion = /(?:chrome|crios)\/(\d+\.\d+)/.exec(ua);
browserVersion = browserVersion && browserVersion[1]
} else if (ua.indexOf("fxios") >= 0) {
browserName = "mozilla";
browserVersion = /fxios\/(\d+\.\d+)/.exec(ua);
browserVersion = browserVersion && browserVersion[1]
} else if (ua.indexOf("safari") >= 0 && /version|phantomjs/.test(ua)) {
browserName = "safari";
browserVersion = /(?:version|phantomjs)\/([0-9.]+)/.exec(ua);
browserVersion = browserVersion && browserVersion[1]
} else {
browserName = "unknown";
browserVersion = /applewebkit\/([0-9.]+)/.exec(ua);
browserVersion = browserVersion && browserVersion[1]
}
}
if (browserName) {
result[browserName] = true;
result.version = browserVersion
}
return result
};
var _default = (0, _extend.extend)({
_fromUA: browserFromUA
}, browserFromUA(navigator.userAgent));
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
39618:
/*!*********************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/utils/call_once.js ***!
\*********************************************************************/
function(module, exports) {
exports.default = void 0;
var _default = function(handler) {
var result;
var _wrappedHandler = function() {
result = handler.apply(this, arguments);
_wrappedHandler = function() {
return result
};
return result
};
return function() {
return _wrappedHandler.apply(this, arguments)
}
};
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
44504:
/*!*********************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/utils/callbacks.js ***!
\*********************************************************************/
function(module, exports) {
exports.default = void 0;
var Callback = function(options) {
this._options = options || {};
this._list = [];
this._queue = [];
this._firing = false;
this._fired = false;
this._firingIndexes = []
};
Callback.prototype._fireCore = function(context, args) {
var firingIndexes = this._firingIndexes;
var list = this._list;
var stopOnFalse = this._options.stopOnFalse;
var step = firingIndexes.length;
for (firingIndexes[step] = 0; firingIndexes[step] < list.length; firingIndexes[step]++) {
var result = list[firingIndexes[step]].apply(context, args);
if (false === result && stopOnFalse) {
break
}
}
firingIndexes.pop()
};
Callback.prototype.add = function(fn) {
if ("function" === typeof fn && (!this._options.unique || !this.has(fn))) {
this._list.push(fn)
}
return this
};
Callback.prototype.remove = function(fn) {
var list = this._list;
var firingIndexes = this._firingIndexes;
var index = list.indexOf(fn);
if (index > -1) {
list.splice(index, 1);
if (this._firing && firingIndexes.length) {
for (var step = 0; step < firingIndexes.length; step++) {
if (index <= firingIndexes[step]) {
firingIndexes[step]--
}
}
}
}
return this
};
Callback.prototype.has = function(fn) {
var list = this._list;
return fn ? list.indexOf(fn) > -1 : !!list.length
};
Callback.prototype.empty = function(fn) {
this._list = [];
return this
};
Callback.prototype.fireWith = function(context, args) {
var queue = this._queue;
args = args || [];
args = args.slice ? args.slice() : args;
if (this._options.syncStrategy) {
this._firing = true;
this._fireCore(context, args)
} else {
queue.push([context, args]);
if (this._firing) {
return
}
this._firing = true;
while (queue.length) {
var memory = queue.shift();
this._fireCore(memory[0], memory[1])
}
}
this._firing = false;
this._fired = true;
return this
};
Callback.prototype.fire = function() {
this.fireWith(this, arguments)
};
Callback.prototype.fired = function() {
return this._fired
};
var _default = function(options) {
return new Callback(options)
};
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
20576:
/*!******************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/utils/common.js ***!
\******************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.splitPair = exports.pairToObject = exports.normalizeKey = exports.noop = exports.grep = exports.getKeyHash = exports.findBestMatches = exports.executeAsync = exports.escapeRegExp = exports.equalByValue = exports.ensureDefined = exports.denormalizeKey = exports.deferUpdater = exports.deferUpdate = exports.deferRenderer = exports.deferRender = exports.asyncNoop = exports.applyServerDecimalSeparator = void 0;
var _config = _interopRequireDefault(__webpack_require__( /*! ../config */ 80209));
var _guid = _interopRequireDefault(__webpack_require__( /*! ../guid */ 73176));
var _deferred = __webpack_require__( /*! ../utils/deferred */ 62754);
var _data = __webpack_require__( /*! ./data */ 47617);
var _iterator = __webpack_require__( /*! ./iterator */ 95479);
var _type = __webpack_require__( /*! ./type */ 35922);
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
function _extends() {
_extends = Object.assign ? Object.assign.bind() : 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)
}
exports.ensureDefined = function(value, defaultValue) {
return (0, _type.isDefined)(value) ? value : defaultValue
};
exports.executeAsync = function(action, context) {
var deferred = new _deferred.Deferred;
var normalizedContext = context || this;
var task = {
promise: deferred.promise(),
abort: function() {
clearTimeout(timerId);
deferred.rejectWith(normalizedContext)
}
};
var callback = function() {
var result = action.call(normalizedContext);
if (result && result.done && (0, _type.isFunction)(result.done)) {
result.done((function() {
deferred.resolveWith(normalizedContext)
}))
} else {
deferred.resolveWith(normalizedContext)
}
};
var timerId = (arguments[2] || setTimeout)(callback, "number" === typeof context ? context : 0);
return task
};
var delayedFuncs = [];
var delayedNames = [];
var delayedDeferreds = [];
var executingName;
var deferExecute = function(name, func, deferred) {
if (executingName && executingName !== name) {
delayedFuncs.push(func);
delayedNames.push(name);
deferred = deferred || new _deferred.Deferred;
delayedDeferreds.push(deferred);
return deferred
} else {
var oldExecutingName = executingName;
var currentDelayedCount = delayedDeferreds.length;
executingName = name;
var result = func();
if (!result) {
if (delayedDeferreds.length > currentDelayedCount) {
result = _deferred.when.apply(this, delayedDeferreds.slice(currentDelayedCount))
} else if (deferred) {
deferred.resolve()
}
}
executingName = oldExecutingName;
if (deferred && result && result.done) {
result.done(deferred.resolve).fail(deferred.reject)
}
if (!executingName && delayedFuncs.length) {
("render" === delayedNames.shift() ? deferRender : deferUpdate)(delayedFuncs.shift(), delayedDeferreds.shift())
}
return result || (0, _deferred.when)()
}
};
var deferRender = function(func, deferred) {
return deferExecute("render", func, deferred)
};
exports.deferRender = deferRender;
var deferUpdate = function(func, deferred) {
return deferExecute("update", func, deferred)
};
exports.deferUpdate = deferUpdate;
exports.deferRenderer = function(func) {
return function() {
var that = this;
return deferExecute("render", (function() {
return func.call(that)
}))
}
};
exports.deferUpdater = function(func) {
return function() {
var that = this;
return deferExecute("update", (function() {
return func.call(that)
}))
}
};
exports.findBestMatches = function(targetFilter, items, mapFn) {
var bestMatches = [];
var maxMatchCount = 0;
(0, _iterator.each)(items, (function(index, itemSrc) {
var matchCount = 0;
var item = mapFn ? mapFn(itemSrc) : itemSrc;
(0, _iterator.each)(targetFilter, (function(paramName, targetValue) {
var value = item[paramName];
if (void 0 === value) {
return
}
if (match(value, targetValue)) {
matchCount++;
return
}
matchCount = -1;
return false
}));
if (matchCount < maxMatchCount) {
return
}
if (matchCount > maxMatchCount) {
bestMatches.length = 0;
maxMatchCount = matchCount
}
bestMatches.push(itemSrc)
}));
return bestMatches
};
var match = function(value, targetValue) {
if (Array.isArray(value) && Array.isArray(targetValue)) {
var mismatch = false;
(0, _iterator.each)(value, (function(index, valueItem) {
if (valueItem !== targetValue[index]) {
mismatch = true;
return false
}
}));
if (mismatch) {
return false
}
return true
}
if (value === targetValue) {
return true
}
return false
};
var splitPair = function(raw) {
var _raw$x, _raw$y;
switch ((0, _type.type)(raw)) {
case "string":
return raw.split(/\s+/, 2);
case "object":
return [null !== (_raw$x = raw.x) && void 0 !== _raw$x ? _raw$x : raw.h, null !== (_raw$y = raw.y) && void 0 !== _raw$y ? _raw$y : raw.v];
case "number":
return [raw];
case "array":
return raw;
default:
return null
}
};
exports.splitPair = splitPair;
exports.normalizeKey = function(id) {
var key = (0, _type.isString)(id) ? id : id.toString();
var arr = key.match(/[^a-zA-Z0-9_]/g);
arr && (0, _iterator.each)(arr, (function(_, sign) {
key = key.replace(sign, "__" + sign.charCodeAt() + "__")
}));
return key
};
exports.denormalizeKey = function(key) {
var arr = key.match(/__\d+__/g);
arr && arr.forEach((function(char) {
var charCode = parseInt(char.replace("__", ""));
key = key.replace(char, String.fromCharCode(charCode))
}));
return key
};
exports.pairToObject = function(raw, preventRound) {
var pair = splitPair(raw);
var h = preventRound ? parseFloat(pair && pair[0]) : parseInt(pair && pair[0], 10);
var v = preventRound ? parseFloat(pair && pair[1]) : parseInt(pair && pair[1], 10);
if (!isFinite(h)) {
h = 0
}
if (!isFinite(v)) {
v = h
}
return {
h: h,
v: v
}
};
exports.getKeyHash = function(key) {
if (key instanceof _guid.default) {
return key.toString()
} else if ((0, _type.isObject)(key) || Array.isArray(key)) {
try {
var keyHash = JSON.stringify(key);
return "{}" === keyHash ? key : keyHash
} catch (e) {
return key
}
}
return key
};
exports.escapeRegExp = function(string) {
return string.replace(/[[\]{}\-()*+?.\\^$|\s]/g, "\\$&")
};
exports.applyServerDecimalSeparator = function(value) {
var separator = (0, _config.default)().serverDecimalSeparator;
if ((0, _type.isDefined)(value)) {
value = value.toString().replace(".", separator)
}
return value
};
exports.noop = function() {};
exports.asyncNoop = function() {
return (new _deferred.Deferred).resolve().promise()
};
exports.grep = function(elements, checkFunction, invert) {
var result = [];
var check;
var expectedCheck = !invert;
for (var i = 0; i < elements.length; i++) {
check = !!checkFunction(elements[i], i);
if (check === expectedCheck) {
result.push(elements[i])
}
}
return result
};
var compareArrays = function(array1, array2, depth, options) {
if (array1.length !== array2.length) {
return false
}
return !array1.some((function(item, idx) {
return !compareByValue(item, array2[idx], depth + 1, _extends({}, options, {
strict: true
}))
}))
};
var compareObjects = function(object1, object2, depth, options) {
var keys1 = Object.keys(object1);
var keys2 = Object.keys(object2);
if (keys1.length !== keys2.length) {
return false
}
var keys2Set = new Set(keys2);
return !keys1.some((function(key) {
return !keys2Set.has(key) || !compareByValue(object1[key], object2[key], depth + 1, options)
}))
};
var DEFAULT_EQUAL_BY_VALUE_OPTS = {
maxDepth: 3,
strict: true
};
var compareByValue = function(value1, value2, depth, options) {
var strict = options.strict,
maxDepth = options.maxDepth;
var comparable1 = (0, _data.toComparable)(value1, true);
var comparable2 = (0, _data.toComparable)(value2, true);
var comparisonResult = strict ? comparable1 === comparable2 : comparable1 == comparable2;
switch (true) {
case comparisonResult:
case depth >= maxDepth:
return true;
case (0, _type.isObject)(comparable1) && (0, _type.isObject)(comparable2):
return compareObjects(comparable1, comparable2, depth, options);
case Array.isArray(comparable1) && Array.isArray(comparable2):
return compareArrays(comparable1, comparable2, depth, options);
default:
return false
}
};
exports.equalByValue = function(value1, value2) {
var options = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : DEFAULT_EQUAL_BY_VALUE_OPTS;
var compareOptions = _extends({}, DEFAULT_EQUAL_BY_VALUE_OPTS, options);
return compareByValue(value1, value2, 0, compareOptions)
}
},
49036:
/*!**********************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/utils/comparator.js ***!
\**********************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.equals = void 0;
var _dom_adapter = (obj = __webpack_require__( /*! ../dom_adapter */ 73349), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var _data = __webpack_require__( /*! ./data */ 47617);
var _type = __webpack_require__( /*! ./type */ 35922);
function _typeof(obj) {
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)
}
exports.equals = function(oldValue, newValue) {
oldValue = (0, _data.toComparable)(oldValue, true);
newValue = (0, _data.toComparable)(newValue, true);
if (oldValue && newValue && (0, _type.isRenderer)(oldValue) && (0, _type.isRenderer)(newValue)) {
return newValue.is(oldValue)
}
var oldValueIsNaN = oldValue !== oldValue;
var newValueIsNaN = newValue !== newValue;
if (oldValueIsNaN && newValueIsNaN) {
return true
}
if (0 === oldValue && 0 === newValue) {
return function(oldValue, newValue) {
return 1 / oldValue === 1 / newValue
}(oldValue, newValue)
}
if (null === oldValue || "object" !== _typeof(oldValue) || _dom_adapter.default.isElementNode(oldValue)) {
return oldValue === newValue
}
return false
}
},
30869:
/*!*******************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/utils/console.js ***!
\*******************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.logger = exports.debug = void 0;
var _type = __webpack_require__( /*! ./type */ 35922);
var noop = function() {};
var getConsoleMethod = function(method) {
if ("undefined" === typeof console || !(0, _type.isFunction)(console[method])) {
return noop
}
return console[method].bind(console)
};
var logger = {
log: getConsoleMethod("log"),
info: getConsoleMethod("info"),
warn: getConsoleMethod("warn"),
error: getConsoleMethod("error")
};
exports.logger = logger;
var debug = function() {
function assert(condition, message) {
if (!condition) {
throw new Error(message)
}
}
return {
assert: assert,
assertParam: function(parameter, message) {
assert(null !== parameter && void 0 !== parameter, message)
}
}
}();
exports.debug = debug
},
47617:
/*!****************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/utils/data.js ***!
\****************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.toComparable = exports.getPathParts = exports.compileSetter = exports.compileGetter = void 0;
var _errors = _interopRequireDefault(__webpack_require__( /*! ../errors */ 17381));
var _class = _interopRequireDefault(__webpack_require__( /*! ../class */ 38377));
var _object = __webpack_require__( /*! ./object */ 48013);
var _type = __webpack_require__( /*! ./type */ 35922);
var _iterator = __webpack_require__( /*! ./iterator */ 95479);
var _variable_wrapper = _interopRequireDefault(__webpack_require__( /*! ./variable_wrapper */ 26974));
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var unwrapVariable = _variable_wrapper.default.unwrap;
var isWrapped = _variable_wrapper.default.isWrapped;
var assign = _variable_wrapper.default.assign;
var getPathParts = function(name) {
return (expr = name, expr.replace(/\[/g, ".").replace(/\]/g, "")).split(".");
var expr
};
exports.getPathParts = getPathParts;
var assignPropValue = function(obj, propName, value, options) {
if ("this" === propName) {
throw new _errors.default.Error("E4016")
}
var propValue = obj[propName];
if (options.unwrapObservables && isWrapped(propValue)) {
assign(propValue, value)
} else {
obj[propName] = value
}
};
var prepareOptions = function(options) {
options = options || {};
options.unwrapObservables = void 0 !== options.unwrapObservables ? options.unwrapObservables : true;
return options
};
function unwrap(value, options) {
return options.unwrapObservables ? unwrapVariable(value) : value
}
var compileGetter = function(expr) {
if (arguments.length > 1) {
expr = [].slice.call(arguments)
}
if (!expr || "this" === expr) {
return function(obj) {
return obj
}
}
if ("string" === typeof expr) {
var path = getPathParts(expr);
return function(obj, options) {
options = prepareOptions(options);
var functionAsIs = options.functionsAsIs;
var hasDefaultValue = "defaultValue" in options;
var current = unwrap(obj, options);
for (var i = 0; i < path.length; i++) {
if (!current) {
if (null == current && hasDefaultValue) {
return options.defaultValue
}
break
}
var pathPart = path[i];
if (hasDefaultValue && (0, _type.isObject)(current) && !(pathPart in current)) {
return options.defaultValue
}
var next = unwrap(current[pathPart], options);
if (!functionAsIs && (0, _type.isFunction)(next)) {
next = next.call(current)
}
current = next
}
return current
}
}
if (Array.isArray(expr)) {
return combineGetters(expr)
}
if ((0, _type.isFunction)(expr)) {
return expr
}
};
exports.compileGetter = compileGetter;
function combineGetters(getters) {
var compiledGetters = {};
for (var i = 0, l = getters.length; i < l; i++) {
var getter = getters[i];
compiledGetters[getter] = compileGetter(getter)
}
return function(obj, options) {
var result;
(0, _iterator.each)(compiledGetters, (function(name) {
var value = this(obj, options);
if (void 0 === value) {
return
}
var current = result || (result = {});
var path = name.split(".");
var last = path.length - 1;
for (var _i = 0; _i < last; _i++) {
var pathItem = path[_i];
if (!(pathItem in current)) {
current[pathItem] = {}
}
current = current[pathItem]
}
current[path[last]] = value
}));
return result
}
}
var ensurePropValueDefined = function(obj, propName, value, options) {
if ((0, _type.isDefined)(value)) {
return value
}
var newValue = {};
assignPropValue(obj, propName, newValue, options);
return newValue
};
exports.compileSetter = function(expr) {
expr = getPathParts(expr || "this");
var lastLevelIndex = expr.length - 1;
return function(obj, value, options) {
options = prepareOptions(options);
var currentValue = unwrap(obj, options);
expr.forEach((function(propertyName, levelIndex) {
var propertyValue = function(obj, propName, options) {
options = options || {};
if ("this" === propName) {
return unwrap(obj, options)
}
return unwrap(obj[propName], options)
}(currentValue, propertyName, options);
var isPropertyFunc = !options.functionsAsIs && (0, _type.isFunction)(propertyValue) && !isWrapped(propertyValue);
if (levelIndex === lastLevelIndex) {
if (options.merge && (0, _type.isPlainObject)(value) && (!(0, _type.isDefined)(propertyValue) || (0, _type.isPlainObject)(propertyValue))) {
propertyValue = ensurePropValueDefined(currentValue, propertyName, propertyValue, options);
(0, _object.deepExtendArraySafe)(propertyValue, value, false, true)
} else if (isPropertyFunc) {
currentValue[propertyName](value)
} else {
assignPropValue(currentValue, propertyName, value, options)
}
} else {
propertyValue = ensurePropValueDefined(currentValue, propertyName, propertyValue, options);
if (isPropertyFunc) {
propertyValue = propertyValue.call(currentValue)
}
currentValue = propertyValue
}
}))
}
};
exports.toComparable = function(value, caseSensitive) {
var options = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
if (value instanceof Date) {
return value.getTime()
}
if (value && value instanceof _class.default && value.valueOf) {
return value.valueOf()
}
if (!caseSensitive && "string" === typeof value) {
var _options$collatorOpti;
if ("base" === (null === options || void 0 === options ? void 0 : null === (_options$collatorOpti = options.collatorOptions) || void 0 === _options$collatorOpti ? void 0 : _options$collatorOpti.sensitivity)) {
var REMOVE_DIACRITICAL_MARKS_REGEXP = /[\u0300-\u036f]/g;
value = value.normalize("NFD").replace(REMOVE_DIACRITICAL_MARKS_REGEXP, "")
}
return null !== options && void 0 !== options && options.locale ? value.toLocaleLowerCase(options.locale) : value.toLowerCase()
}
return value
}
},
91198:
/*!****************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/utils/date.js ***!
\****************************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _type = __webpack_require__( /*! ./type */ 35922);
var _math = __webpack_require__( /*! ./math */ 60810);
var _iterator = __webpack_require__( /*! ./iterator */ 95479);
var _inflector = __webpack_require__( /*! ./inflector */ 78008);
var _index = __webpack_require__( /*! ../../renovation/ui/common/utils/date/index */ 25050);
function _construct(Parent, args, Class) {
if (_isNativeReflectConstruct()) {
_construct = Reflect.construct.bind()
} else {
_construct = function(Parent, args, Class) {
var a = [null];
a.push.apply(a, args);
var Constructor = Function.bind.apply(Parent, a);
var instance = new Constructor;
if (Class) {
_setPrototypeOf(instance, Class.prototype)
}
return instance
}
}
return _construct.apply(null, arguments)
}
function _isNativeReflectConstruct() {
if ("undefined" === typeof Reflect || !Reflect.construct) {
return false
}
if (Reflect.construct.sham) {
return false
}
if ("function" === typeof Proxy) {
return true
}
try {
Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {})));
return true
} catch (e) {
return false
}
}
function _setPrototypeOf(o, p) {
_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(o, p) {
o.__proto__ = p;
return o
};
return _setPrototypeOf(o, p)
}
var dateUnitIntervals = ["millisecond", "second", "minute", "hour", "day", "week", "month", "quarter", "year"];
var convertMillisecondsToDateUnits = function(value) {
var i;
var dateUnitCount;
var dateUnitInterval;
var dateUnitIntervals = ["millisecond", "second", "minute", "hour", "day", "month", "year"];
var result = {};
for (i = dateUnitIntervals.length - 1; i >= 0; i--) {
dateUnitInterval = dateUnitIntervals[i];
dateUnitCount = Math.floor(value / (0, _index.toMilliseconds)(dateUnitInterval));
if (dateUnitCount > 0) {
result[dateUnitInterval + "s"] = dateUnitCount;
value -= convertDateUnitToMilliseconds(dateUnitInterval, dateUnitCount)
}
}
return result
};
function convertDateUnitToMilliseconds(dateUnit, count) {
return (0, _index.toMilliseconds)(dateUnit) * count
}
function getDateUnitInterval(tickInterval) {
var maxInterval = -1;
var i;
if ((0, _type.isString)(tickInterval)) {
return tickInterval
}
if ((0, _type.isObject)(tickInterval)) {
(0, _iterator.each)(tickInterval, (function(key, value) {
for (i = 0; i < dateUnitIntervals.length; i++) {
if (value && (key === dateUnitIntervals[i] + "s" || key === dateUnitIntervals[i]) && maxInterval < i) {
maxInterval = i
}
}
}));
return dateUnitIntervals[maxInterval]
}
return ""
}
var tickIntervalToFormatMap = {
millisecond: "millisecond",
second: "longtime",
minute: "shorttime",
hour: "shorttime",
day: "day",
week: "day",
month: "month",
quarter: "quarter",
year: "year"
};
var getQuarter = function(month) {
return Math.floor(month / 3)
};
var getFirstQuarterMonth = function(month) {
return 3 * getQuarter(month)
};
function correctDateWithUnitBeginning(date, dateInterval, withCorrection, firstDayOfWeek) {
date = new Date(date.getTime());
var oldDate = new Date(date.getTime());
var firstQuarterMonth;
var month;
var dateUnitInterval = getDateUnitInterval(dateInterval);
switch (dateUnitInterval) {
case "second":
date = new Date(1e3 * Math.floor(oldDate.getTime() / 1e3));
break;
case "minute":
date = new Date(6e4 * Math.floor(oldDate.getTime() / 6e4));
break;
case "hour":
date = new Date(36e5 * Math.floor(oldDate.getTime() / 36e5));
break;
case "year":
date.setMonth(0);
case "month":
date.setDate(1);
case "day":
date.setHours(0, 0, 0, 0);
break;
case "week":
date = getFirstWeekDate(date, firstDayOfWeek || 0);
date.setHours(0, 0, 0, 0);
break;
case "quarter":
firstQuarterMonth = getFirstQuarterMonth(date.getMonth());
month = date.getMonth();
date.setDate(1);
date.setHours(0, 0, 0, 0);
if (month !== firstQuarterMonth) {
date.setMonth(firstQuarterMonth)
}
}
if (withCorrection && "hour" !== dateUnitInterval && "minute" !== dateUnitInterval && "second" !== dateUnitInterval) {
fixTimezoneGap(oldDate, date)
}
return date
}
function trimTime(date) {
return correctDateWithUnitBeginning(date, "day")
}
function addDateInterval(value, interval, dir) {
var result = new Date(value.getTime());
var intervalObject = (0, _type.isString)(interval) ? getDateIntervalByString(interval.toLowerCase()) : (0, _type.isNumeric)(interval) ? convertMillisecondsToDateUnits(interval) : interval;
if (intervalObject.years) {
result.setFullYear(result.getFullYear() + intervalObject.years * dir)
}
if (intervalObject.quarters) {
result.setMonth(result.getMonth() + 3 * intervalObject.quarters * dir)
}
if (intervalObject.months) {
result.setMonth(result.getMonth() + intervalObject.months * dir)
}
if (intervalObject.weeks) {
result.setDate(result.getDate() + 7 * intervalObject.weeks * dir)
}
if (intervalObject.days) {
result.setDate(result.getDate() + intervalObject.days * dir)
}
if (intervalObject.hours) {
result.setTime(result.getTime() + 36e5 * intervalObject.hours * dir)
}
if (intervalObject.minutes) {
result.setTime(result.getTime() + 6e4 * intervalObject.minutes * dir)
}
if (intervalObject.seconds) {
result.setTime(result.getTime() + 1e3 * intervalObject.seconds * dir)
}
if (intervalObject.milliseconds) {
result.setTime(result.getTime() + intervalObject.milliseconds * dir)
}
return result
}
var addInterval = function(value, interval, isNegative) {
var dir = isNegative ? -1 : 1;
return (0, _type.isDate)(value) ? addDateInterval(value, interval, dir) : (0, _math.adjust)(value + interval * dir, interval)
};
function getLastMonthDay(date) {
var resultDate = createDateWithFullYear(date.getFullYear(), date.getMonth() + 1, 0);
return resultDate.getDate()
}
function getDateIntervalByString(intervalString) {
var result = {};
switch (intervalString) {
case "year":
result.years = 1;
break;
case "month":
result.months = 1;
break;
case "quarter":
result.months = 3;
break;
case "week":
result.weeks = 1;
break;
case "day":
result.days = 1;
break;
case "hour":
result.hours = 1;
break;
case "minute":
result.minutes = 1;
break;
case "second":
result.seconds = 1;
break;
case "millisecond":
result.milliseconds = 1
}
return result
}
function sameMonthAndYear(date1, date2) {
return sameYear(date1, date2) && date1.getMonth() === date2.getMonth()
}
function sameYear(date1, date2) {
return date1 && date2 && date1.getFullYear() === date2.getFullYear()
}
function getFirstDecadeInCentury(date) {
return date && date.getFullYear() - date.getFullYear() % 100
}
function getFirstYearInDecade(date) {
return date && date.getFullYear() - date.getFullYear() % 10
}
function getFirstWeekDate(date, firstDayOfWeek) {
var delta = (date.getDay() - firstDayOfWeek + 7) % 7;
var result = new Date(date);
result.setDate(date.getDate() - delta);
return result
}
function getUTCTime(date) {
return Date.UTC(date.getFullYear(), date.getMonth(), date.getDate())
}
function getFirstDateInYear(year) {
return new Date(year, 0, 1)
}
function getLastDateInYear(year) {
return new Date(year, 11, 31)
}
function getDayWeekNumber(date, firstDayOfWeek) {
var day = date.getDay() - firstDayOfWeek + 1;
if (day <= 0) {
day += 7
}
return day
}
function normalizeDate(date, min, max) {
var normalizedDate = date;
if (!(0, _type.isDefined)(date)) {
return date
}
if ((0, _type.isDefined)(min) && date < min) {
normalizedDate = min
}
if ((0, _type.isDefined)(max) && date > max) {
normalizedDate = max
}
return normalizedDate
}
function fixTimezoneGap(oldDate, newDate) {
if (!(0, _type.isDefined)(oldDate)) {
return
}
var diff = newDate.getHours() - oldDate.getHours();
if (0 === diff) {
return
}
var sign = 1 === diff || -23 === diff ? -1 : 1;
var trial = new Date(newDate.getTime() + 36e5 * sign);
if (sign > 0 || trial.getDate() === newDate.getDate()) {
newDate.setTime(trial.getTime())
}
}
function getTimezonesDifference(min, max) {
return 60 * (max.getTimezoneOffset() - min.getTimezoneOffset()) * 1e3
}
var createDateWithFullYear = function(year) {
var result = _construct(Date, Array.prototype.slice.call(arguments));
result.setFullYear(year);
return result
};
var dateUtils = {
dateUnitIntervals: dateUnitIntervals,
convertMillisecondsToDateUnits: convertMillisecondsToDateUnits,
dateToMilliseconds: function(tickInterval) {
var milliseconds = 0;
if ((0, _type.isObject)(tickInterval)) {
(0, _iterator.each)(tickInterval, (function(key, value) {
milliseconds += convertDateUnitToMilliseconds(key.substr(0, key.length - 1), value)
}))
}
if ((0, _type.isString)(tickInterval)) {
milliseconds = convertDateUnitToMilliseconds(tickInterval, 1)
}
return milliseconds
},
getNextDateUnit: function(unit, withWeeks) {
var interval = getDateUnitInterval(unit);
switch (interval) {
case "millisecond":
return "second";
case "second":
return "minute";
case "minute":
return "hour";
case "hour":
return "day";
case "day":
return withWeeks ? "week" : "month";
case "week":
return "month";
case "month":
return "quarter";
case "quarter":
case "year":
return "year";
default:
return 0
}
},
convertDateUnitToMilliseconds: convertDateUnitToMilliseconds,
getDateUnitInterval: getDateUnitInterval,
getDateFormatByTickInterval: function(tickInterval) {
return tickIntervalToFormatMap[getDateUnitInterval(tickInterval)] || ""
},
getDatesDifferences: function(date1, date2) {
var counter = 0;
var differences = {
year: date1.getFullYear() !== date2.getFullYear(),
month: date1.getMonth() !== date2.getMonth(),
day: date1.getDate() !== date2.getDate(),
hour: date1.getHours() !== date2.getHours(),
minute: date1.getMinutes() !== date2.getMinutes(),
second: date1.getSeconds() !== date2.getSeconds(),
millisecond: date1.getMilliseconds() !== date2.getMilliseconds()
};
(0, _iterator.each)(differences, (function(key, value) {
if (value) {
counter++
}
}));
if (0 === counter && 0 !== getTimezonesDifference(date1, date2)) {
differences.hour = true;
counter++
}
differences.count = counter;
return differences
},
correctDateWithUnitBeginning: correctDateWithUnitBeginning,
trimTime: trimTime,
setToDayEnd: function(date) {
var result = trimTime(date);
result.setDate(result.getDate() + 1);
return new Date(result.getTime() - 1)
},
roundDateByStartDayHour: function(date, startDayHour) {
var startTime = this.dateTimeFromDecimal(startDayHour);
var result = new Date(date);
if (date.getHours() === startTime.hours && date.getMinutes() < startTime.minutes || date.getHours() < startTime.hours) {
result.setHours(startTime.hours, startTime.minutes, 0, 0)
}
return result
},
dateTimeFromDecimal: function(number) {
var hours = Math.floor(number);
var minutes = number % 1 * 60;
return {
hours: hours,
minutes: minutes
}
},
addDateInterval: addDateInterval,
addInterval: addInterval,
getSequenceByInterval: function(min, max, interval) {
var intervals = [];
var cur;
intervals.push((0, _type.isDate)(min) ? new Date(min.getTime()) : min);
cur = min;
while (cur < max) {
cur = addInterval(cur, interval);
intervals.push(cur)
}
return intervals
},
getDateIntervalByString: getDateIntervalByString,
sameHoursAndMinutes: function(date1, date2) {
return date1 && date2 && date1.getHours() === date2.getHours() && date1.getMinutes() === date2.getMinutes()
},
sameDate: function(date1, date2) {
return sameMonthAndYear(date1, date2) && date1.getDate() === date2.getDate()
},
sameMonthAndYear: sameMonthAndYear,
sameMonth: sameMonthAndYear,
sameYear: sameYear,
sameDecade: function(date1, date2) {
if (!(0, _type.isDefined)(date1) || !(0, _type.isDefined)(date2)) {
return
}
var startDecadeDate1 = date1.getFullYear() - date1.getFullYear() % 10;
var startDecadeDate2 = date2.getFullYear() - date2.getFullYear() % 10;
return date1 && date2 && startDecadeDate1 === startDecadeDate2
},
sameCentury: function(date1, date2) {
if (!(0, _type.isDefined)(date1) || !(0, _type.isDefined)(date2)) {
return
}
var startCenturyDate1 = date1.getFullYear() - date1.getFullYear() % 100;
var startCenturyDate2 = date2.getFullYear() - date2.getFullYear() % 100;
return date1 && date2 && startCenturyDate1 === startCenturyDate2
},
getDifferenceInMonth: function(typeView) {
var difference = 1;
if ("year" === typeView) {
difference = 12
}
if ("decade" === typeView) {
difference = 120
}
if ("century" === typeView) {
difference = 1200
}
return difference
},
getDifferenceInMonthForCells: function(typeView) {
var difference = 1;
if ("decade" === typeView) {
difference = 12
}
if ("century" === typeView) {
difference = 120
}
return difference
},
getFirstYearInDecade: getFirstYearInDecade,
getFirstDecadeInCentury: getFirstDecadeInCentury,
getShortDateFormat: function() {
return "yyyy/MM/dd"
},
getViewFirstCellDate: function(viewType, date) {
if ("month" === viewType) {
return createDateWithFullYear(date.getFullYear(), date.getMonth(), 1)
}
if ("year" === viewType) {
return createDateWithFullYear(date.getFullYear(), 0, date.getDate())
}
if ("decade" === viewType) {
return createDateWithFullYear(getFirstYearInDecade(date), date.getMonth(), date.getDate())
}
if ("century" === viewType) {
return createDateWithFullYear(getFirstDecadeInCentury(date), date.getMonth(), date.getDate())
}
},
getViewLastCellDate: function(viewType, date) {
if ("month" === viewType) {
return createDateWithFullYear(date.getFullYear(), date.getMonth(), getLastMonthDay(date))
}
if ("year" === viewType) {
return createDateWithFullYear(date.getFullYear(), 11, date.getDate())
}
if ("decade" === viewType) {
return createDateWithFullYear(getFirstYearInDecade(date) + 9, date.getMonth(), date.getDate())
}
if ("century" === viewType) {
return createDateWithFullYear(getFirstDecadeInCentury(date) + 90, date.getMonth(), date.getDate())
}
},
getViewDown: function(typeView) {
switch (typeView) {
case "century":
return "decade";
case "decade":
return "year";
case "year":
return "month"
}
},
getViewUp: function(typeView) {
switch (typeView) {
case "month":
return "year";
case "year":
return "decade";
case "decade":
return "century"
}
},
getLastMonthDay: getLastMonthDay,
getLastMonthDate: function(date) {
if (!(0, _type.isDefined)(date)) {
return
}
return createDateWithFullYear(date.getFullYear(), date.getMonth() + 1, 0)
},
getFirstMonthDate: function(date) {
if (!(0, _type.isDefined)(date)) {
return
}
return createDateWithFullYear(date.getFullYear(), date.getMonth(), 1)
},
getFirstWeekDate: getFirstWeekDate,
getWeekNumber: function getWeekNumber(date, firstDayOfWeek, rule) {
var firstWeekDayInYear = getDayWeekNumber(getFirstDateInYear(date.getFullYear()), firstDayOfWeek);
var lastWeekDayInYear = getDayWeekNumber(getLastDateInYear(date.getFullYear()), firstDayOfWeek);
var daysInFirstWeek = 7 - firstWeekDayInYear + 1;
var weekNumber = Math.ceil((function(date) {
var ms = getUTCTime(date) - getUTCTime(getFirstDateInYear(date.getFullYear()));
return 1 + Math.floor(ms / (0, _index.toMilliseconds)("day"))
}(date) - daysInFirstWeek) / 7);
switch (rule) {
case "fullWeek":
if (7 === daysInFirstWeek) {
weekNumber++
}
if (0 === weekNumber) {
var lastDateInPreviousYear = getLastDateInYear(date.getFullYear() - 1);
return getWeekNumber(lastDateInPreviousYear, firstDayOfWeek, rule)
}
return weekNumber;
case "firstDay":
if (daysInFirstWeek > 0) {
weekNumber++
}
var isSunday = 7 === firstWeekDayInYear || 7 === lastWeekDayInYear;
if (weekNumber > 52 && !isSunday || 54 === weekNumber) {
weekNumber = 1
}
return weekNumber;
case "firstFourDays":
if (daysInFirstWeek > 3) {
weekNumber++
}
var isThursday = 4 === firstWeekDayInYear || 4 === lastWeekDayInYear;
if (weekNumber > 52 && !isThursday) {
weekNumber = 1
}
if (0 === weekNumber) {
var _lastDateInPreviousYear = getLastDateInYear(date.getFullYear() - 1);
return getWeekNumber(_lastDateInPreviousYear, firstDayOfWeek, rule)
}
return weekNumber
}
},
normalizeDateByWeek: function(date, currentDate) {
var differenceInDays = dateUtils.getDatesInterval(date, currentDate, "day");
var resultDate = new Date(date);
if (differenceInDays >= 6) {
resultDate = new Date(resultDate.setDate(resultDate.getDate() + 7))
}
return resultDate
},
getQuarter: getQuarter,
getFirstQuarterMonth: getFirstQuarterMonth,
dateInRange: function(date, min, max, format) {
if ("date" === format) {
min = min && dateUtils.correctDateWithUnitBeginning(min, "day");
max = max && dateUtils.correctDateWithUnitBeginning(max, "day");
date = date && dateUtils.correctDateWithUnitBeginning(date, "day")
}
return normalizeDate(date, min, max) === date
},
intervalsOverlap: function(options) {
var firstMin = options.firstMin,
firstMax = options.firstMax,
secondMin = options.secondMin,
secondMax = options.secondMax;
return firstMin <= secondMin && secondMin <= firstMax || firstMin > secondMin && firstMin < secondMax || firstMin < secondMax && firstMax > secondMax
},
roundToHour: function(date) {
var result = new Date(date.getTime());
result.setHours(result.getHours() + 1);
result.setMinutes(0);
return result
},
normalizeDate: normalizeDate,
getViewMinBoundaryDate: function(viewType, date) {
var resultDate = createDateWithFullYear(date.getFullYear(), date.getMonth(), 1);
if ("month" === viewType) {
return resultDate
}
resultDate.setMonth(0);
if ("year" === viewType) {
return resultDate
}
if ("decade" === viewType) {
resultDate.setFullYear(getFirstYearInDecade(date))
}
if ("century" === viewType) {
resultDate.setFullYear(getFirstDecadeInCentury(date))
}
return resultDate
},
getViewMaxBoundaryDate: function(viewType, date) {
var resultDate = new Date(date);
resultDate.setDate(getLastMonthDay(date));
if ("month" === viewType) {
return resultDate
}
resultDate.setMonth(11);
resultDate.setDate(getLastMonthDay(resultDate));
if ("year" === viewType) {
return resultDate
}
if ("decade" === viewType) {
resultDate.setFullYear(getFirstYearInDecade(date) + 9)
}
if ("century" === viewType) {
resultDate.setFullYear(getFirstDecadeInCentury(date) + 99)
}
return resultDate
},
fixTimezoneGap: fixTimezoneGap,
getTimezonesDifference: getTimezonesDifference,
makeDate: function(date) {
return new Date(date)
},
getDatesInterval: function(startDate, endDate, intervalUnit) {
var delta = endDate.getTime() - startDate.getTime();
var millisecondCount = (0, _index.toMilliseconds)(intervalUnit) || 1;
return Math.floor(delta / millisecondCount)
},
getDatesOfInterval: function(startDate, endDate, step) {
var result = [];
var currentDate = new Date(startDate.getTime());
while (currentDate < endDate) {
result.push(new Date(currentDate.getTime()));
currentDate = this.addInterval(currentDate, step)
}
return result
},
createDateWithFullYear: createDateWithFullYear
};
dateUtils.sameView = function(view, date1, date2) {
return dateUtils[(0, _inflector.camelize)("same " + view)](date1, date2)
};
var _default = dateUtils;
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
69434:
/*!******************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/utils/date_serialization.js ***!
\******************************************************************************/
function(module, exports, __webpack_require__) {
exports.default = void 0;
var _config = _interopRequireDefault(__webpack_require__( /*! ../config */ 80209));
var _date = __webpack_require__( /*! ../../localization/ldml/date.formatter */ 40594);
var _default_date_names = _interopRequireDefault(__webpack_require__( /*! ../../localization/default_date_names */ 15564));
var _type = __webpack_require__( /*! ./type */ 35922);
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var ISO8601_PATTERN = /^(\d{4,})(-)?(\d{2})(-)?(\d{2})(?:T(\d{2})(:)?(\d{2})?(:)?(\d{2}(?:\.(\d{1,3})\d*)?)?)?(Z|([+-])(\d{2})(:)?(\d{2})?)?$/;
var ISO8601_TIME_PATTERN = /^(\d{2}):(\d{2})(:(\d{2}))?$/;
var ISO8601_PATTERN_PARTS = ["", "yyyy", "", "MM", "", "dd", "THH", "", "mm", "", "ss", ".SSS"];
var DATE_SERIALIZATION_PATTERN = /^(\d{4})\/(\d{2})\/(\d{2})$/;
var dateParser = function(text, skipISO8601Parsing) {
var result;
if ((0, _type.isString)(text) && !skipISO8601Parsing) {
result = function(text) {
var parts = text.match(ISO8601_PATTERN);
if (!parts) {
parts = text.match(ISO8601_TIME_PATTERN);
if (parts) {
return new Date(0, 0, 0, getTimePart(parts[1]), getTimePart(parts[2]), getTimePart(parts[4]))
}
return
}
var year = getTimePart(parts[1]);
var month = --parts[3];
var day = parts[5];
var timeZoneHour = 0;
var timeZoneMinute = 0;
var correctYear = function(d) {
year < 100 && d.setFullYear(year);
return d
};
timeZoneHour = getTimePart(parts[14]);
timeZoneMinute = getTimePart(parts[16]);
if ("-" === parts[13]) {
timeZoneHour = -timeZoneHour;
timeZoneMinute = -timeZoneMinute
}
var hour = getTimePart(parts[6]) - timeZoneHour;
var minute = getTimePart(parts[8]) - timeZoneMinute;
var second = getTimePart(parts[10]);
var millisecond = function(part) {
part = part || "";
return getTimePart(part) * Math.pow(10, 3 - part.length)
}(parts[11]);
if (parts[12]) {
return correctYear(new Date(Date.UTC(year, month, day, hour, minute, second, millisecond)))
}
return correctYear(new Date(year, month, day, hour, minute, second, millisecond))
}(text)
}
return result || function(text) {
var isDefaultSerializationFormat = "yyyy/MM/dd" === getDateSerializationFormat(text);
var parsedValue = !(0, _type.isDate)(text) && Date.parse(text);
if (!parsedValue && isDefaultSerializationFormat) {
var parts = text.match(DATE_SERIALIZATION_PATTERN);
if (parts) {
var newDate = new Date(getTimePart(parts[1]), getTimePart(parts[2]), getTimePart(parts[3]));
newDate.setFullYear(getTimePart(parts[1]));
newDate.setMonth(getTimePart(parts[2]) - 1);
newDate.setDate(getTimePart(parts[3]));
return newDate
}
}
return (0, _type.isNumeric)(parsedValue) ? new Date(parsedValue) : text
}(text)
};
function getTimePart(part) {
return +part || 0
}
var getDateSerializationFormat = function(value) {
if ("number" === typeof value) {
return "number"
} else if ((0, _type.isString)(value)) {
var format;
if ((0, _config.default)().forceIsoDateParsing) {
format = function(text, useUtc) {
var parts = text.match(ISO8601_PATTERN);
var result = "";
if (!parts) {
parts = text.match(ISO8601_TIME_PATTERN);
if (parts) {
return parts[3] ? "HH:mm:ss" : "HH:mm"
}
return
}
for (var i = 1; i < ISO8601_PATTERN_PARTS.length; i++) {
if (parts[i]) {
result += ISO8601_PATTERN_PARTS[i] || parts[i]
}
}
if ("Z" === parts[12]) {
result += "'Z'"
}
if (parts[14]) {
if (parts[15]) {
result += "xxx"
} else if (parts[16]) {
result += "xx"
} else {
result += "x"
}
}
return result
}(value)
}
if (format) {
return format
} else if (value.indexOf(":") >= 0) {
return "yyyy/MM/dd HH:mm:ss"
} else {
return "yyyy/MM/dd"
}
} else if (value) {
return null
}
};
var _default = {
dateParser: dateParser,
deserializeDate: function(value) {
if ("number" === typeof value) {
return new Date(value)
}
return dateParser(value, !(0, _config.default)().forceIsoDateParsing)
},
serializeDate: function(value, serializationFormat) {
if (!serializationFormat) {
return value
}
if (!(0, _type.isDate)(value)) {
return null
}
if ("number" === serializationFormat) {
return value && value.valueOf ? value.valueOf() : null
}
return (0, _date.getFormatter)(serializationFormat, _default_date_names.default)(value)
},
getDateSerializationFormat: getDateSerializationFormat
};
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default
},
62754:
/*!********************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/utils/deferred.js ***!
\********************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.Deferred = function() {
return new _DeferredObj
};
exports.fromPromise = fromPromise;
exports.setStrategy = function(value) {
_DeferredObj = value.Deferred;
whenFunc = value.when
};
exports.when = function() {
return whenFunc.apply(this, arguments)
};
var _type = __webpack_require__( /*! ../utils/type */ 35922);
var _extend = __webpack_require__( /*! ../utils/extend */ 13306);
var _callbacks = (obj = __webpack_require__( /*! ../utils/callbacks */ 44504), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var deferredConfig = [{
method: "resolve",
handler: "done",
state: "resolved"
}, {
method: "reject",
handler: "fail",
state: "rejected"
}, {
method: "notify",
handler: "progress"
}];
var _DeferredObj = function() {
var that = this;
this._state = "pending";
this._promise = {};
deferredConfig.forEach(function(config) {
var methodName = config.method;
this[methodName + "Callbacks"] = (0, _callbacks.default)();
this[methodName] = function() {
return this[methodName + "With"](this._promise, arguments)
}.bind(this);
this._promise[config.handler] = function(handler) {
if (!handler) {
return this
}
var callbacks = that[methodName + "Callbacks"];
if (callbacks.fired()) {
handler.apply(that[methodName + "Context"], that[methodName + "Args"])
} else {
callbacks.add(function(context, args) {
handler.apply(context, args)
}.bind(this))
}
return this
}
}.bind(this));
this._promise.always = function(handler) {
return this.done(handler).fail(handler)
};
this._promise.catch = function(handler) {
return this.then(null, handler)
};
this._promise.then = function(resolve, reject) {
var result = new _DeferredObj;
["done", "fail"].forEach(function(method) {
var callback = "done" === method ? resolve : reject;
this[method]((function() {
if (!callback) {
result["done" === method ? "resolve" : "reject"].apply(this, arguments);
return
}
var callbackResult = callback && callback.apply(this, arguments);
if ((0, _type.isDeferred)(callbackResult)) {
callbackResult.done(result.resolve).fail(result.reject)
} else if ((0, _type.isPromise)(callbackResult)) {
callbackResult.then(result.resolve, result.reject)
} else {
result.resolve.apply(this, (0, _type.isDefined)(callbackResult) ? [callbackResult] : arguments)
}
}))
}.bind(this));
return result.promise()
};
this._promise.state = function() {
return that._state
};
this._promise.promise = function(args) {
return args ? (0, _extend.extend)(args, that._promise) : that._promise
};
this._promise.promise(this)
};
deferredConfig.forEach((function(config) {
var methodName = config.method;
var state = config.state;
_DeferredObj.prototype[methodName + "With"] = function(context, args) {
var callbacks = this[methodName + "Callbacks"];
if ("pending" === this.state()) {
this[methodName + "Args"] = args;
this[methodName + "Context"] = context;
if (state) {
this._state = state
}
callbacks.fire(context, args)
}
return this
}
}));
function fromPromise(promise, context) {
if ((0, _type.isDeferred)(promise)) {
return promise
} else if ((0, _type.isPromise)(promise)) {
var d = new _DeferredObj;
promise.then((function() {
d.resolveWith.apply(d, [context].concat([
[].slice.call(arguments)
]))
}), (function() {
d.rejectWith.apply(d, [context].concat([
[].slice.call(arguments)
]))
}));
return d
}
return (new _DeferredObj).resolveWith(context, [promise])
}
var whenFunc = function() {
if (1 === arguments.length) {
return fromPromise(arguments[0])
}
var values = [].slice.call(arguments);
var contexts = [];
var resolvedCount = 0;
var deferred = new _DeferredObj;
var updateState = function(i) {
return function(value) {
contexts[i] = this;
values[i] = arguments.length > 1 ? [].slice.call(arguments) : value;
resolvedCount++;
if (resolvedCount === values.length) {
deferred.resolveWith(contexts, values)
}
}
};
for (var i = 0; i < values.length; i++) {
if ((0, _type.isDeferred)(values[i])) {
values[i].promise().done(updateState(i)).fail(deferred.reject)
} else {
resolvedCount++
}
}
if (resolvedCount === values.length) {
deferred.resolveWith(contexts, values)
}
return deferred.promise()
}
},
20476:
/*!*******************************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/utils/dependency_injector.js ***!
\*******************************************************************************/
function(module, exports, __webpack_require__) {
exports.default = function(object) {
var BaseClass = _class.default.inherit(object);
var InjectedClass = BaseClass;
var instance = new InjectedClass(object);
var initialFields = {};
var injectFields = function(injectionObject, initial) {
(0, _iterator.each)(injectionObject, (function(key) {
if ((0, _type.isFunction)(instance[key])) {
if (initial || !object[key]) {
object[key] = function() {
return instance[key].apply(object, arguments)
}
}
} else {
if (initial) {
initialFields[key] = object[key]
}
object[key] = instance[key]
}
}))
};
injectFields(object, true);
object.inject = function(injectionObject) {
InjectedClass = InjectedClass.inherit(injectionObject);
instance = new InjectedClass;
injectFields(injectionObject)
};
object.resetInjection = function() {
(0, _extend.extend)(object, initialFields);
InjectedClass = BaseClass;
instance = new BaseClass
};
return object
};
var _extend = __webpack_require__( /*! ./extend */ 13306);
var _type = __webpack_require__( /*! ./type */ 35922);
var _iterator = __webpack_require__( /*! ./iterator */ 95479);
var _class = (obj = __webpack_require__( /*! ../class */ 38377), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
module.exports = exports.default;
module.exports.default = exports.default
},
3532:
/*!***************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/utils/dom.js ***!
\***************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.resetActiveElement = exports.replaceWith = exports.normalizeTemplateElement = exports.isElementInDom = exports.insertBefore = exports.extractTemplateMarkup = exports.createTextElementHiddenCopy = exports.contains = exports.closestCommonParent = exports.clipboardText = exports.clearSelection = void 0;
var _dom_adapter = _interopRequireDefault(__webpack_require__( /*! ../../core/dom_adapter */ 73349));
var _renderer = _interopRequireDefault(__webpack_require__( /*! ../../core/renderer */ 68374));
var _iterator = __webpack_require__( /*! ./iterator */ 95479);
var _type = __webpack_require__( /*! ./type */ 35922);
var _window = __webpack_require__( /*! ./window */ 58201);
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
default: obj
}
}
var window = (0, _window.getWindow)();
exports.resetActiveElement = function() {
var activeElement = _dom_adapter.default.getActiveElement();
if (activeElement && activeElement !== _dom_adapter.default.getBody()) {
var _activeElement$blur;
null === (_activeElement$blur = activeElement.blur) || void 0 === _activeElement$blur ? void 0 : _activeElement$blur.call(activeElement)
}
};
exports.clearSelection = function() {
var selection = window.getSelection();
if (!selection) {
return
}
if ("Caret" === selection.type) {
return
}
if (selection.empty) {
selection.empty()
} else if (selection.removeAllRanges) {
try {
selection.removeAllRanges()
} catch (e) {}
}
};
exports.closestCommonParent = function(startTarget, endTarget) {
var $startTarget = (0, _renderer.default)(startTarget);
var $endTarget = (0, _renderer.default)(endTarget);
if ($startTarget[0] === $endTarget[0]) {
return $startTarget[0]
}
var $startParents = $startTarget.parents();
var $endParents = $endTarget.parents();
var startingParent = Math.min($startParents.length, $endParents.length);
for (var i = -startingParent; i < 0; i++) {
if ($startParents.get(i) === $endParents.get(i)) {
return $startParents.get(i)
}
}
};
exports.extractTemplateMarkup = function(element) {
element = (0, _renderer.default)(element);
var templateTag = element.length && element.filter((function() {
var $node = (0, _renderer.default)(this);
return $node.is("script[type]") && $node.attr("type").indexOf("script") < 0
}));
if (templateTag.length) {
return templateTag.eq(0).html()
} else {
element = (0, _renderer.default)(" ").append(element);
return element.html()
}
};
exports.normalizeTemplateElement = function normalizeTemplateElement(element) {
var $element = (0, _type.isDefined)(element) && (element.nodeType || (0, _type.isRenderer)(element)) ? (0, _renderer.default)(element) : (0, _renderer.default)(" ").html(element).contents();
if (1 === $element.length) {
if ($element.is("script")) {
$element = normalizeTemplateElement($element.html().trim())
} else if ($element.is("table")) {
$element = $element.children("tbody").contents()
}
}
return $element
};
exports.clipboardText = function(event, text) {
var clipboard = event.originalEvent && event.originalEvent.clipboardData || window.clipboardData;
if (!text) {
return clipboard && clipboard.getData("Text")
}
clipboard && clipboard.setData("Text", text)
};
exports.contains = function contains(container, element) {
if (!element) {
return false
}
if ((0, _type.isWindow)(container)) {
return contains(container.document, element)
}
return container.contains(element) || contains(container, function(element) {
if (!element.getRootNode) {
return
}
var host = element.getRootNode().host;
if ((0, _type.isString)(host)) {
return
}
return host
}(element))
};
exports.createTextElementHiddenCopy = function(element, text, options) {
var elementStyles = window.getComputedStyle((0, _renderer.default)(element).get(0));
var includePaddings = options && options.includePaddings;
return (0, _renderer.default)(" ").text(text).css({
fontStyle: elementStyles.fontStyle,
fontVariant: elementStyles.fontVariant,
fontWeight: elementStyles.fontWeight,
fontSize: elementStyles.fontSize,
fontFamily: elementStyles.fontFamily,
letterSpacing: elementStyles.letterSpacing,
border: elementStyles.border,
paddingTop: includePaddings ? elementStyles.paddingTop : "",
paddingRight: includePaddings ? elementStyles.paddingRight : "",
paddingBottom: includePaddings ? elementStyles.paddingBottom : "",
paddingLeft: includePaddings ? elementStyles.paddingLeft : "",
visibility: "hidden",
whiteSpace: "pre",
position: "absolute",
float: "left"
})
};
var insertBefore = function(element, newElement) {
if (newElement) {
_dom_adapter.default.insertElement(element.parentNode, newElement, element)
}
return element
};
exports.insertBefore = insertBefore;
exports.replaceWith = function(element, newElement) {
if (!(newElement && newElement[0])) {
return
}
if (newElement.is(element)) {
return element
}(0, _iterator.each)(newElement, (function(_, currentElement) {
insertBefore(element[0], currentElement)
}));
element.remove();
return newElement
};
exports.isElementInDom = function($element) {
var element = null === $element || void 0 === $element ? void 0 : $element.get(0);
var shadowHost = null === element || void 0 === element ? void 0 : element.getRootNode().host;
return !!(0, _renderer.default)(shadowHost || element).closest((0, _window.getWindow)().document).length
}
},
95640:
/*!*****************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/utils/error.js ***!
\*****************************************************************/
function(module, exports, __webpack_require__) {
exports.default = function(baseErrors, errors) {
var exports = {
ERROR_MESSAGES: (0, _extend.extend)(errors, baseErrors),
Error: function() {
return makeError([].slice.call(arguments))
},
log: function(id) {
var method = "log";
if (/^E\d+$/.test(id)) {
method = "error"
} else if (/^W\d+$/.test(id)) {
method = "warn"
}
_console.logger[method]("log" === method ? id : combineMessage([].slice.call(arguments)))
}
};
function combineMessage(args) {
var id = args[0];
args = args.slice(1);
return formatMessage(id, formatDetails(id, args))
}
function formatDetails(id, args) {
args = [exports.ERROR_MESSAGES[id]].concat(args);
return _string.format.apply(this, args).replace(/\.*\s*?$/, "")
}
function formatMessage(id, details) {
return _string.format.apply(this, ["{0} - {1}. See:\n{2}", id, details, getErrorUrl(id)])
}
function makeError(args) {
var id = args[0];
args = args.slice(1);
var details = formatDetails(id, args);
var url = getErrorUrl(id);
var message = formatMessage(id, details);
return (0, _extend.extend)(new Error(message), {
__id: id,
__details: details,
url: url
})
}
function getErrorUrl(id) {
return ERROR_URL + id
}
return exports
};
var _extend = __webpack_require__( /*! ./extend */ 13306);
var _console = __webpack_require__( /*! ./console */ 30869);
var _string = __webpack_require__( /*! ./string */ 68752);
var _version = __webpack_require__( /*! ../version */ 36739);
var ERROR_URL = "http://js.devexpress.com/error/" + _version.version.split(".").slice(0, 2).join("_") + "/";
module.exports = exports.default;
module.exports.default = exports.default
},
13306:
/*!******************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/utils/extend.js ***!
\******************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.extendFromObject = exports.extend = void 0;
var _type = __webpack_require__( /*! ./type */ 35922);
exports.extendFromObject = function(target, source, overrideExistingValues) {
target = target || {};
for (var prop in source) {
if (Object.prototype.hasOwnProperty.call(source, prop)) {
var value = source[prop];
if (!(prop in target) || overrideExistingValues) {
target[prop] = value
}
}
}
return target
};
exports.extend = function extend(target) {
target = target || {};
var i = 1;
var deep = false;
if ("boolean" === typeof target) {
deep = target;
target = arguments[1] || {};
i++
}
for (; i < arguments.length; i++) {
var source = arguments[i];
if (null == source) {
continue
}
for (var key in source) {
var targetValue = target[key];
var sourceValue = source[key];
var sourceValueIsArray = false;
var clone = void 0;
if ("__proto__" === key || "constructor" === key || target === sourceValue) {
continue
}
if (deep && sourceValue && ((0, _type.isPlainObject)(sourceValue) || (sourceValueIsArray = Array.isArray(sourceValue)))) {
if (sourceValueIsArray) {
clone = targetValue && Array.isArray(targetValue) ? targetValue : []
} else {
clone = targetValue && (0, _type.isPlainObject)(targetValue) ? targetValue : {}
}
target[key] = extend(deep, clone, sourceValue)
} else if (void 0 !== sourceValue) {
target[key] = sourceValue
}
}
}
return target
}
},
61371:
/*!***********************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/utils/html_parser.js ***!
\***********************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.parseHTML = exports.isTablePart = void 0;
var _dom_adapter = (obj = __webpack_require__( /*! ../dom_adapter */ 73349), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
function _toConsumableArray(arr) {
return function(arr) {
if (Array.isArray(arr)) {
return _arrayLikeToArray(arr)
}
}(arr) || function(iter) {
if ("undefined" !== typeof Symbol && null != iter[Symbol.iterator] || null != iter["@@iterator"]) {
return Array.from(iter)
}
}(arr) || function(o, minLen) {
if (!o) {
return
}
if ("string" === typeof o) {
return _arrayLikeToArray(o, minLen)
}
var n = Object.prototype.toString.call(o).slice(8, -1);
if ("Object" === n && o.constructor) {
n = o.constructor.name
}
if ("Map" === n || "Set" === n) {
return Array.from(o)
}
if ("Arguments" === n || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) {
return _arrayLikeToArray(o, minLen)
}
}(arr) || function() {
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 _arrayLikeToArray(arr, len) {
if (null == len || len > arr.length) {
len = arr.length
}
for (var i = 0, arr2 = new Array(len); i < len; i++) {
arr2[i] = arr[i]
}
return arr2
}
var isTagName = /<([a-z][^/\0>\x20\t\r\n\f]+)/i;
var tagWrappers = {
default: {
tagsCount: 0,
startTags: "",
endTags: ""
},
thead: {
tagsCount: 1,
startTags: " "
},
td: {
tagsCount: 3,
startTags: " "
},
col: {
tagsCount: 2,
startTags: " "
},
tr: {
tagsCount: 2,
startTags: " "
}
};
tagWrappers.tbody = tagWrappers.colgroup = tagWrappers.caption = tagWrappers.tfoot = tagWrappers.thead;
tagWrappers.th = tagWrappers.td;
exports.parseHTML = function(html) {
if ("string" !== typeof html) {
return null
}
var fragment = _dom_adapter.default.createDocumentFragment();
var container = fragment.appendChild(_dom_adapter.default.createElement("div"));
var tags = isTagName.exec(html);
var firstRootTag = tags && tags[1].toLowerCase();
var tagWrapper = tagWrappers[firstRootTag] || tagWrappers.default;
container.innerHTML = tagWrapper.startTags + html + tagWrapper.endTags;
for (var i = 0; i < tagWrapper.tagsCount; i++) {
container = container.lastChild
}
return _toConsumableArray(container.childNodes)
};
exports.isTablePart = function(html) {
var tags = isTagName.exec(html);
return tags && tags[1] in tagWrappers
}
},
44899:
/*!****************************************************************!*\
!*** ./artifacts/transpiled-renovation-npm/core/utils/icon.js ***!
\****************************************************************/
function(__unused_webpack_module, exports, __webpack_require__) {
exports.getImageSourceType = exports.getImageContainer = void 0;
var _renderer = (obj = __webpack_require__( /*! ../../core/renderer */ 68374), obj && obj.__esModule ? obj : {
default: obj
});
var obj;
var getImageSourceType = function(source) {
if (!source || "string" !== typeof source) {
return false
}
if (/^\s* | |