devextreme
Version:
HTML5 JavaScript Component Suite for Responsive Web Development
968 lines (962 loc) • 122 kB
JavaScript
/**
* DevExtreme (esm/ui/grid_core/ui.grid_core.columns_controller.js)
* Version: 21.1.4
* Build date: Mon Jun 21 2021
*
* Copyright (c) 2012 - 2021 Developer Express Inc. ALL RIGHTS RESERVED
* Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
*/
import _extends from "@babel/runtime/helpers/esm/extends";
import $ from "../../core/renderer";
import Callbacks from "../../core/utils/callbacks";
import variableWrapper from "../../core/utils/variable_wrapper";
import {
compileGetter,
compileSetter
} from "../../core/utils/data";
import {
grep
} from "../../core/utils/common";
import {
isDefined,
isString,
isNumeric,
isFunction,
isObject,
isPlainObject,
type
} from "../../core/utils/type";
import {
each,
map
} from "../../core/utils/iterator";
import {
getDefaultAlignment
} from "../../core/utils/position";
import {
extend
} from "../../core/utils/extend";
import {
inArray,
normalizeIndexes
} from "../../core/utils/array";
import config from "../../core/config";
import {
orderEach,
deepExtendArraySafe
} from "../../core/utils/object";
import errors from "../widget/ui.errors";
import modules from "./ui.grid_core.modules";
import gridCoreUtils from "./ui.grid_core.utils";
import {
captionize
} from "../../core/utils/inflector";
import dateSerialization from "../../core/utils/date_serialization";
import numberLocalization from "../../localization/number";
import dateLocalization from "../../localization/date";
import messageLocalization from "../../localization/message";
import {
when,
Deferred
} from "../../core/utils/deferred";
import Store from "../../data/abstract_store";
import {
DataSource
} from "../../data/data_source/data_source";
import {
normalizeDataSourceOptions
} from "../../data/data_source/utils";
import filterUtils from "../shared/filtering";
var USER_STATE_FIELD_NAMES_15_1 = ["filterValues", "filterType", "fixed", "fixedPosition"];
var USER_STATE_FIELD_NAMES = ["visibleIndex", "dataField", "name", "dataType", "width", "visible", "sortOrder", "lastSortOrder", "sortIndex", "groupIndex", "filterValue", "selectedFilterOperation", "added"].concat(USER_STATE_FIELD_NAMES_15_1);
var IGNORE_COLUMN_OPTION_NAMES = {
visibleWidth: true,
bestFitWidth: true,
bufferedFilterValue: true
};
var COMMAND_EXPAND_CLASS = "dx-command-expand";
var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
var GROUP_COMMAND_COLUMN_NAME = "groupExpand";
var regExp = /columns\[(\d+)\]\.?/gi;
var globalColumnId = 1;
export var columnsControllerModule = {
defaultOptions: function() {
return {
commonColumnSettings: {
allowFiltering: true,
allowHiding: true,
allowSorting: true,
allowEditing: true,
encodeHtml: true,
trueText: messageLocalization.format("dxDataGrid-trueText"),
falseText: messageLocalization.format("dxDataGrid-falseText")
},
allowColumnReordering: false,
allowColumnResizing: false,
columnResizingMode: "nextColumn",
columnMinWidth: void 0,
columnWidth: void 0,
adaptColumnWidthByRatio: true,
columns: void 0,
regenerateColumnsByVisibleItems: false,
customizeColumns: null,
dateSerializationFormat: void 0
}
},
controllers: {
columns: modules.Controller.inherit(function() {
var DEFAULT_COLUMN_OPTIONS = {
visible: true,
showInColumnChooser: true
};
var DATATYPE_OPERATIONS = {
number: ["=", "<>", "<", ">", "<=", ">=", "between"],
string: ["contains", "notcontains", "startswith", "endswith", "=", "<>"],
date: ["=", "<>", "<", ">", "<=", ">=", "between"],
datetime: ["=", "<>", "<", ">", "<=", ">=", "between"]
};
var COLUMN_INDEX_OPTIONS = {
visibleIndex: true,
groupIndex: true,
grouped: true,
sortIndex: true,
sortOrder: true
};
var setFilterOperationsAsDefaultValues = function(column) {
column.filterOperations = column.defaultFilterOperations
};
var createColumn = function(that, columnOptions, userStateColumnOptions, bandColumn) {
var commonColumnOptions = {};
if (columnOptions) {
if (isString(columnOptions)) {
columnOptions = {
dataField: columnOptions
}
}
that.setName(columnOptions);
var result = {};
if (columnOptions.command) {
result = deepExtendArraySafe(commonColumnOptions, columnOptions)
} else {
commonColumnOptions = that.getCommonSettings(columnOptions);
if (userStateColumnOptions && userStateColumnOptions.name && userStateColumnOptions.dataField) {
columnOptions = extend({}, columnOptions, {
dataField: userStateColumnOptions.dataField
})
}
var calculatedColumnOptions = that._createCalculatedColumnOptions(columnOptions, bandColumn);
if (!columnOptions.type) {
result = {
headerId: "dx-col-".concat(globalColumnId++)
}
}
result = deepExtendArraySafe(result, DEFAULT_COLUMN_OPTIONS);
deepExtendArraySafe(result, commonColumnOptions);
deepExtendArraySafe(result, calculatedColumnOptions);
deepExtendArraySafe(result, columnOptions);
deepExtendArraySafe(result, {
selector: null
})
}
if (columnOptions.filterOperations === columnOptions.defaultFilterOperations) {
setFilterOperationsAsDefaultValues(result)
}
return result
}
};
var createColumnsFromOptions = function createColumnsFromOptions(that, columnsOptions, bandColumn) {
var result = [];
if (columnsOptions) {
each(columnsOptions, (function(index, columnOptions) {
var userStateColumnOptions = that._columnsUserState && checkUserStateColumn(columnOptions, that._columnsUserState[index]) && that._columnsUserState[index];
var column = createColumn(that, columnOptions, userStateColumnOptions, bandColumn);
if (column) {
if (bandColumn) {
column.ownerBand = bandColumn
}
result.push(column);
if (column.columns) {
result = result.concat(createColumnsFromOptions(that, column.columns, column));
delete column.columns;
column.hasColumns = true
}
}
}))
}
return result
};
var getParentBandColumns = function(columnIndex, columnParentByIndex) {
var result = [];
var parent = columnParentByIndex[columnIndex];
while (parent) {
result.unshift(parent);
columnIndex = parent.index;
parent = columnParentByIndex[columnIndex]
}
return result
};
var _getChildrenByBandColumn = function(columnIndex, columnChildrenByIndex, recursive) {
var result = [];
var children = columnChildrenByIndex[columnIndex];
if (children) {
for (var i = 0; i < children.length; i++) {
var column = children[i];
if (!isDefined(column.groupIndex) || column.showWhenGrouped) {
result.push(column);
if (recursive && column.isBand) {
result = result.concat(_getChildrenByBandColumn(column.index, columnChildrenByIndex, recursive))
}
}
}
}
return result
};
var getColumnFullPath = function(that, column) {
var result = [];
var columns;
var bandColumnsCache = that.getBandColumnsCache();
var callbackFilter = function(item) {
return item.ownerBand === column.ownerBand
};
if (bandColumnsCache.isPlain) {
var columnIndex = that._columns.indexOf(column);
if (columnIndex >= 0) {
result = ["columns[".concat(columnIndex, "]")]
}
} else {
columns = that._columns.filter(callbackFilter);
while (columns.length && -1 !== columns.indexOf(column)) {
result.unshift("columns[".concat(columns.indexOf(column), "]"));
column = bandColumnsCache.columnParentByIndex[column.index];
columns = column ? that._columns.filter(callbackFilter) : []
}
}
return result.join(".")
};
var calculateColspan = function calculateColspan(that, columnID) {
var colspan = 0;
var columns = that.getChildrenByBandColumn(columnID, true);
each(columns, (function(_, column) {
if (column.isBand) {
column.colspan = column.colspan || calculateColspan(that, column.index);
colspan += column.colspan || 1
} else {
colspan += 1
}
}));
return colspan
};
var getValueDataType = function(value) {
var dataType = type(value);
if ("string" !== dataType && "boolean" !== dataType && "number" !== dataType && "date" !== dataType && "object" !== dataType) {
dataType = void 0
}
return dataType
};
var getSerializationFormat = function(dataType, value) {
switch (dataType) {
case "date":
case "datetime":
return dateSerialization.getDateSerializationFormat(value);
case "number":
if (isString(value)) {
return "string"
}
if (isNumeric(value)) {
return null
}
}
};
var updateSerializers = function(options, dataType) {
if (!options.deserializeValue) {
if (gridCoreUtils.isDateType(dataType)) {
options.deserializeValue = function(value) {
return dateSerialization.deserializeDate(value)
};
options.serializeValue = function(value) {
return isString(value) ? value : dateSerialization.serializeDate(value, this.serializationFormat)
}
}
if ("number" === dataType) {
options.deserializeValue = function(value) {
var parsedValue = parseFloat(value);
return isNaN(parsedValue) ? value : parsedValue
};
options.serializeValue = function(value, target) {
if ("filter" === target) {
return value
}
return isDefined(value) && "string" === this.serializationFormat ? value.toString() : value
}
}
}
};
var customizeTextForBooleanDataType = function(e) {
if (true === e.value) {
return this.trueText || "true"
} else if (false === e.value) {
return this.falseText || "false"
} else {
return e.valueText || ""
}
};
var getCustomizeTextByDataType = function(dataType) {
if ("boolean" === dataType) {
return customizeTextForBooleanDataType
}
};
var updateColumnIndexes = function(that) {
each(that._columns, (function(index, column) {
column.index = index
}));
each(that._columns, (function(index, column) {
if (isObject(column.ownerBand)) {
column.ownerBand = column.ownerBand.index
}
}));
each(that._commandColumns, (function(index, column) {
column.index = -(index + 1)
}))
};
var updateColumnGroupIndexes = function(that, currentColumn) {
normalizeIndexes(that._columns, "groupIndex", currentColumn, (function(column) {
var grouped = column.grouped;
delete column.grouped;
return grouped
}))
};
var getColumnIndexByVisibleIndex = function(that, visibleIndex, location) {
var rowIndex = isObject(visibleIndex) ? visibleIndex.rowIndex : null;
var columns = "group" === location ? that.getGroupColumns() : "columnChooser" === location ? that.getChooserColumns() : that.getVisibleColumns(rowIndex);
var column;
visibleIndex = isObject(visibleIndex) ? visibleIndex.columnIndex : visibleIndex;
column = columns[visibleIndex];
if (column && column.type === GROUP_COMMAND_COLUMN_NAME) {
column = that._columns.filter(col => column.type === col.type)[0] || column
}
return column && isDefined(column.index) ? column.index : -1
};
function checkUserStateColumn(column, userStateColumn) {
return column && userStateColumn && (userStateColumn.name === column.name || !column.name) && (userStateColumn.dataField === column.dataField || column.name)
}
var applyUserState = function(that) {
var columnsUserState = that._columnsUserState;
var ignoreColumnOptionNames = that._ignoreColumnOptionNames || [];
var columns = that._columns;
var columnCountById = {};
var resultColumns = [];
var allColumnsHaveState = true;
var userStateColumnIndexes = [];
var column;
var userStateColumnIndex;
var i;
function applyFieldsState(column, userStateColumn) {
if (!userStateColumn) {
return
}
for (var index = 0; index < USER_STATE_FIELD_NAMES.length; index++) {
var fieldName = USER_STATE_FIELD_NAMES[index];
if (inArray(fieldName, ignoreColumnOptionNames) >= 0) {
continue
}
if ("dataType" === fieldName) {
column[fieldName] = column[fieldName] || userStateColumn[fieldName]
} else if (inArray(fieldName, USER_STATE_FIELD_NAMES_15_1) >= 0) {
if (fieldName in userStateColumn) {
column[fieldName] = userStateColumn[fieldName]
}
} else {
if ("selectedFilterOperation" === fieldName && userStateColumn[fieldName]) {
column.defaultSelectedFilterOperation = column[fieldName] || null
}
column[fieldName] = userStateColumn[fieldName]
}
}
}
function findUserStateColumn(columnsUserState, column) {
var id = column.name || column.dataField;
var count = columnCountById[id] || 0;
for (var j = 0; j < columnsUserState.length; j++) {
if (checkUserStateColumn(column, columnsUserState[j])) {
if (count) {
count--
} else {
columnCountById[id] = columnCountById[id] || 0;
columnCountById[id]++;
return j
}
}
}
return -1
}
if (columnsUserState) {
for (i = 0; i < columns.length; i++) {
userStateColumnIndex = findUserStateColumn(columnsUserState, columns[i]);
allColumnsHaveState = allColumnsHaveState && userStateColumnIndex >= 0;
userStateColumnIndexes.push(userStateColumnIndex)
}
for (i = 0; i < columns.length; i++) {
column = columns[i];
userStateColumnIndex = userStateColumnIndexes[i];
if (that._hasUserState || allColumnsHaveState) {
applyFieldsState(column, columnsUserState[userStateColumnIndex])
}
if (userStateColumnIndex >= 0 && isDefined(columnsUserState[userStateColumnIndex].initialIndex)) {
resultColumns[userStateColumnIndex] = column
} else {
resultColumns.push(column)
}
}
var hasAddedBands = false;
for (i = 0; i < columnsUserState.length; i++) {
var columnUserState = columnsUserState[i];
if (columnUserState.added && findUserStateColumn(columns, columnUserState) < 0) {
column = createColumn(that, columnUserState.added);
applyFieldsState(column, columnUserState);
resultColumns.push(column);
if (columnUserState.added.columns) {
hasAddedBands = true
}
}
}
if (hasAddedBands) {
updateColumnIndexes(that);
resultColumns = createColumnsFromOptions(that, resultColumns)
}
assignColumns(that, resultColumns)
}
};
var updateIndexes = function(that, column) {
updateColumnIndexes(that);
updateColumnGroupIndexes(that, column);
! function(that, currentColumn) {
each(that._columns, (function(index, column) {
if (isDefined(column.sortIndex) && !isSortOrderValid(column.sortOrder)) {
delete column.sortIndex
}
}));
normalizeIndexes(that._columns, "sortIndex", currentColumn, (function(column) {
return !isDefined(column.groupIndex) && isSortOrderValid(column.sortOrder)
}))
}(that, column);
resetBandColumnsCache(that);
! function(that, currentColumn) {
var key;
var column;
var bandColumns = {};
var result = [];
var bandColumnsCache = that.getBandColumnsCache();
var columns = that._columns.filter(column => !column.command);
for (var i = 0; i < columns.length; i++) {
column = columns[i];
var parentBandColumns = getParentBandColumns(i, bandColumnsCache.columnParentByIndex);
if (parentBandColumns.length) {
var bandColumnIndex = parentBandColumns[parentBandColumns.length - 1].index;
bandColumns[bandColumnIndex] = bandColumns[bandColumnIndex] || [];
bandColumns[bandColumnIndex].push(column)
} else {
result.push(column)
}
}
for (key in bandColumns) {
normalizeIndexes(bandColumns[key], "visibleIndex", currentColumn)
}
normalizeIndexes(result, "visibleIndex", currentColumn)
}(that, column)
};
var resetColumnsCache = function(that) {
that.resetColumnsCache()
};
function assignColumns(that, columns) {
that._columns = columns;
resetColumnsCache(that);
that.updateColumnDataTypes()
}
var updateColumnChanges = function(that, changeType, optionName, columnIndex) {
var columnChanges = that._columnChanges || {
optionNames: {
length: 0
},
changeTypes: {
length: 0
},
columnIndex: columnIndex
};
optionName = optionName || "all";
optionName = optionName.split(".")[0];
var changeTypes = columnChanges.changeTypes;
if (changeType && !changeTypes[changeType]) {
changeTypes[changeType] = true;
changeTypes.length++
}
var optionNames = columnChanges.optionNames;
if (optionName && !optionNames[optionName]) {
optionNames[optionName] = true;
optionNames.length++
}
if (void 0 === columnIndex || columnIndex !== columnChanges.columnIndex) {
delete columnChanges.columnIndex
}
that._columnChanges = columnChanges;
resetColumnsCache(that)
};
var fireColumnsChanged = function(that) {
var onColumnsChanging = that.option("onColumnsChanging");
var columnChanges = that._columnChanges;
var reinitOptionNames = ["dataField", "lookup", "dataType", "columns"];
if (that.isInitialized() && !that._updateLockCount && columnChanges) {
if (onColumnsChanging) {
that._updateLockCount++;
onColumnsChanging(extend({
component: that.component
}, columnChanges));
that._updateLockCount--
}
that._columnChanges = void 0;
if (options = columnChanges.optionNames, options && reinitOptionNames.some(name => options[name])) {
that.reinit()
} else {
that.columnsChanged.fire(columnChanges)
}
}
var options
};
var updateSortOrderWhenGrouping = function(that, column, groupIndex, prevGroupIndex) {
var columnWasGrouped = prevGroupIndex >= 0;
if (groupIndex >= 0) {
if (!columnWasGrouped) {
column.lastSortOrder = column.sortOrder
}
} else {
var sortMode = that.option("sorting.mode");
var sortOrder = column.lastSortOrder;
if ("single" === sortMode) {
var sortedByAnotherColumn = that._columns.some(col => col !== column && isDefined(col.sortIndex));
if (sortedByAnotherColumn) {
sortOrder = void 0
}
}
column.sortOrder = sortOrder
}
};
var fireOptionChanged = function(that, options) {
var value = options.value;
var optionName = options.optionName;
var prevValue = options.prevValue;
var fullOptionName = options.fullOptionName;
var fullOptionPath = "".concat(fullOptionName, ".").concat(optionName);
if (!IGNORE_COLUMN_OPTION_NAMES[optionName] && that._skipProcessingColumnsChange !== fullOptionPath) {
that._skipProcessingColumnsChange = fullOptionPath;
that.component._notifyOptionChanged(fullOptionPath, value, prevValue);
that._skipProcessingColumnsChange = false
}
};
var columnOptionCore = function(that, column, optionName, value, notFireEvent) {
var optionGetter = compileGetter(optionName);
var columnIndex = column.index;
var columns;
var changeType;
var initialColumn;
if (3 === arguments.length) {
return optionGetter(column, {
functionsAsIs: true
})
}
var prevValue = optionGetter(column, {
functionsAsIs: true
});
if (prevValue !== value) {
if ("groupIndex" === optionName || "calculateGroupValue" === optionName) {
changeType = "grouping";
updateSortOrderWhenGrouping(that, column, value, prevValue)
} else if ("sortIndex" === optionName || "sortOrder" === optionName || "calculateSortValue" === optionName) {
changeType = "sorting"
} else {
changeType = "columns"
}
var optionSetter = compileSetter(optionName);
optionSetter(column, value, {
functionsAsIs: true
});
var fullOptionName = getColumnFullPath(that, column);
if (COLUMN_INDEX_OPTIONS[optionName]) {
updateIndexes(that, column);
value = optionGetter(column)
}
if ("name" === optionName || "allowEditing" === optionName) {
that._checkColumns()
}
fullOptionName && fireOptionChanged(that, {
fullOptionName: fullOptionName,
optionName: optionName,
value: value,
prevValue: prevValue
});
if (!isDefined(prevValue) && !isDefined(value) && 0 !== optionName.indexOf("buffer")) {
notFireEvent = true
}
if (!notFireEvent) {
if (inArray(optionName, USER_STATE_FIELD_NAMES) < 0 && "visibleWidth" !== optionName) {
columns = that.option("columns");
initialColumn = that.getColumnByPath(fullOptionName, columns);
if (isString(initialColumn)) {
initialColumn = columns[columnIndex] = {
dataField: initialColumn
}
}
if (initialColumn && checkUserStateColumn(initialColumn, column)) {
optionSetter(initialColumn, value, {
functionsAsIs: true
})
}
}
updateColumnChanges(that, changeType, optionName, columnIndex)
} else {
resetColumnsCache(that)
}
}
};
function isSortOrderValid(sortOrder) {
return "asc" === sortOrder || "desc" === sortOrder
}
var defaultSetCellValue = function(data, value) {
var path = this.dataField.split(".");
var dotCount = path.length - 1;
if (this.serializeValue) {
value = this.serializeValue(value)
}
for (var i = 0; i < dotCount; i++) {
var name = path[i];
data = data[name] = data[name] || {}
}
data[path[dotCount]] = value
};
var isCustomCommandColumn = (that, commandColumn) => !!that._columns.filter(column => column.type === commandColumn.type).length;
var getFixedPosition = function(that, column) {
var rtlEnabled = that.option("rtlEnabled");
if (column.command && !isCustomCommandColumn(that, column) || !column.fixedPosition) {
return rtlEnabled ? "right" : "left"
}
return column.fixedPosition
};
var processExpandColumns = function(columns, expandColumns, type, columnIndex) {
var customColumnIndex;
var rowCount = this.getRowCount();
var rowspan = columns[columnIndex] && columns[columnIndex].rowspan;
var expandColumnsByType = expandColumns.filter(column => column.type === type);
columns.forEach((column, index) => {
if (column.type === type) {
customColumnIndex = index;
rowspan = columns[index + 1] ? columns[index + 1].rowspan : rowCount
}
});
if (rowspan > 1) {
expandColumnsByType = map(expandColumnsByType, (function(expandColumn) {
return extend({}, expandColumn, {
rowspan: rowspan
})
}))
}
expandColumnsByType.unshift.apply(expandColumnsByType, isDefined(customColumnIndex) ? [customColumnIndex, 1] : [columnIndex, 0]);
columns.splice.apply(columns, expandColumnsByType);
return rowspan || 1
};
var numberToString = function(number, digitsCount) {
var str = number ? number.toString() : "0";
while (str.length < digitsCount) {
str = "0" + str
}
return str
};
var mergeColumns = (that, columns, commandColumns, needToExtend) => {
var column;
var commandColumnIndex;
var result = columns.slice().map(column => extend({}, column));
var isColumnFixing = that._isColumnFixing();
var defaultCommandColumns = commandColumns.slice().map(column => extend({
fixed: isColumnFixing
}, column));
var getCommandColumnIndex = column => commandColumns.reduce((result, commandColumn, index) => {
var columnType = needToExtend && column.type === GROUP_COMMAND_COLUMN_NAME ? "expand" : column.type;
return commandColumn.type === columnType || commandColumn.command === column.command ? index : result
}, -1);
var callbackFilter = commandColumn => commandColumn.command !== commandColumns[commandColumnIndex].command;
for (var i = 0; i < columns.length; i++) {
column = columns[i];
commandColumnIndex = column && (column.type || column.command) ? getCommandColumnIndex(column) : -1;
if (commandColumnIndex >= 0) {
if (needToExtend) {
result[i] = extend({
fixed: isColumnFixing
}, commandColumns[commandColumnIndex], column);
if (column.type !== GROUP_COMMAND_COLUMN_NAME) {
defaultCommandColumns = defaultCommandColumns.filter(callbackFilter)
}
} else {
var columnOptions = {
visibleIndex: column.visibleIndex,
index: column.index,
headerId: column.headerId,
allowFixing: 0 === column.groupIndex,
allowReordering: 0 === column.groupIndex,
groupIndex: column.groupIndex
};
result[i] = extend({}, column, commandColumns[commandColumnIndex], column.type === GROUP_COMMAND_COLUMN_NAME && columnOptions)
}
}
}
if (columns.length && needToExtend && defaultCommandColumns.length) {
result = result.concat(defaultCommandColumns)
}
return result
};
var isColumnFixed = (that, column) => isDefined(column.fixed) || !column.type ? column.fixed : that._isColumnFixing();
var resetBandColumnsCache = that => {
that._bandColumnsCache = void 0
};
var findColumn = (columns, identifier) => {
var identifierOptionName = isString(identifier) && identifier.substr(0, identifier.indexOf(":"));
var column;
if (void 0 === identifier) {
return
}
if (identifierOptionName) {
identifier = identifier.substr(identifierOptionName.length + 1)
}
if (identifierOptionName) {
column = columns.filter(column => "" + column[identifierOptionName] === identifier)[0]
} else {
["index", "name", "dataField", "caption"].some(optionName => {
column = columns.filter(column => column[optionName] === identifier)[0];
return !!column
})
}
return column
};
return {
_getExpandColumnOptions: function() {
return {
type: "expand",
command: "expand",
width: "auto",
cssClass: COMMAND_EXPAND_CLASS,
allowEditing: false,
allowGrouping: false,
allowSorting: false,
allowResizing: false,
allowReordering: false,
allowHiding: false
}
},
_getFirstItems: function(dataSource) {
var groupsCount;
var items = [];
if (dataSource && dataSource.items().length > 0) {
groupsCount = gridCoreUtils.normalizeSortingInfo(dataSource.group()).length;
items = function getFirstItemsCore(items, groupsCount) {
if (!items || !groupsCount) {
return items
}
for (var i = 0; i < items.length; i++) {
var childItems = getFirstItemsCore(items[i].items || items[i].collapsedItems, groupsCount - 1);
if (childItems && childItems.length) {
return childItems
}
}
}(dataSource.items(), groupsCount) || []
}
return items
},
_endUpdateCore: function() {
!this._skipProcessingColumnsChange && fireColumnsChanged(this)
},
init: function() {
var columns = this.option("columns");
this._commandColumns = this._commandColumns || [];
this._columns = this._columns || [];
this._isColumnsFromOptions = !!columns;
if (this._isColumnsFromOptions) {
assignColumns(this, columns ? createColumnsFromOptions(this, columns) : []);
applyUserState(this)
} else {
assignColumns(this, this._columnsUserState ? createColumnsFromOptions(this, this._columnsUserState) : this._columns)
}! function(that) {
var options = that._getExpandColumnOptions();
that.addCommandColumn(options)
}(this);
if (this._dataSourceApplied) {
this.applyDataSource(this._dataSource, true)
} else {
updateIndexes(this)
}
this._checkColumns()
},
callbackNames: function() {
return ["columnsChanged"]
},
getColumnByPath: function(path, columns) {
var column;
var columnIndexes = [];
path.replace(regExp, (function(_, columnIndex) {
columnIndexes.push(parseInt(columnIndex));
return ""
}));
if (columnIndexes.length) {
if (columns) {
column = columnIndexes.reduce((function(column, index) {
return column && column.columns && column.columns[index]
}), {
columns: columns
})
} else {
column = function(that, columnIndexes) {
var result;
var columns;
var bandColumnsCache = that.getBandColumnsCache();
var callbackFilter = function(column) {
var ownerBand = result ? result.index : void 0;
return column.ownerBand === ownerBand
};
if (bandColumnsCache.isPlain) {
result = that._columns[columnIndexes[0]]
} else {
columns = that._columns.filter(callbackFilter);
for (var i = 0; i < columnIndexes.length; i++) {
result = columns[columnIndexes[i]];
if (result) {
columns = that._columns.filter(callbackFilter)
}
}
}
return result
}(this, columnIndexes)
}
}
return column
},
optionChanged: function(args) {
var needUpdateRequireResize;
switch (args.name) {
case "adaptColumnWidthByRatio":
args.handled = true;
break;
case "dataSource":
if (args.value !== args.previousValue && !this.option("columns") && (!Array.isArray(args.value) || !Array.isArray(args.previousValue))) {
this._columns = []
}
break;
case "columns":
needUpdateRequireResize = this._skipProcessingColumnsChange;
args.handled = true;
if (!this._skipProcessingColumnsChange) {
if (args.name === args.fullName) {
this._columnsUserState = null;
this._ignoreColumnOptionNames = null;
this.init()
} else {
this._columnOptionChanged(args);
needUpdateRequireResize = true
}
}
if (needUpdateRequireResize) {
this._updateRequireResize(args)
}
break;
case "commonColumnSettings":
case "columnAutoWidth":
case "allowColumnResizing":
case "allowColumnReordering":
case "columnFixing":
case "grouping":
case "groupPanel":
case "regenerateColumnsByVisibleItems":
case "customizeColumns":
case "editing":
case "columnHidingEnabled":
case "dateSerializationFormat":
case "columnResizingMode":
case "columnMinWidth":
case "columnWidth":
var _args$fullName, _args$fullName2, _args$fullName3, _args$fullName4, _args$fullName5;
args.handled = true;
var ignoreColumnOptionNames = "columnWidth" === args.fullName && ["width"];
var isEditingPopup = 0 === (null === (_args$fullName = args.fullName) || void 0 === _args$fullName ? void 0 : _args$fullName.indexOf("editing.popup"));
var isEditingForm = 0 === (null === (_args$fullName2 = args.fullName) || void 0 === _args$fullName2 ? void 0 : _args$fullName2.indexOf("editing.form"));
var isEditRowKey = 0 === (null === (_args$fullName3 = args.fullName) || void 0 === _args$fullName3 ? void 0 : _args$fullName3.indexOf("editing.editRowKey"));
var isEditColumnName = 0 === (null === (_args$fullName4 = args.fullName) || void 0 === _args$fullName4 ? void 0 : _args$fullName4.indexOf("editing.editColumnName"));
var isChanges = 0 === (null === (_args$fullName5 = args.fullName) || void 0 === _args$fullName5 ? void 0 : _args$fullName5.indexOf("editing.changes"));
var needReinit = !isEditingPopup && !isEditingForm && !isEditRowKey && !isChanges && !isEditColumnName;
if (needReinit) {
this.reinit(ignoreColumnOptionNames)
}
break;
case "rtlEnabled":
this.reinit();
break;
default:
this.callBase(args)
}
},
_columnOptionChanged: function(args) {
var columnOptionValue = {};
var column = this.getColumnByPath(args.fullName);
var columnOptionName = args.fullName.replace(regExp, "");
if (column) {
if (columnOptionName) {
columnOptionValue[columnOptionName] = args.value
} else {
columnOptionValue = args.value
}
this._skipProcessingColumnsChange = args.fullName;
this.columnOption(column.index, columnOptionValue);
this._skipProcessingColumnsChange = false
}
},
_updateRequireResize: function(args) {
var component = this.component;
if ("width" === args.fullName.replace(regExp, "") && component._updateLockCount) {
component._requireResize = true
}
},
publicMethods: function() {
return ["addColumn", "deleteColumn", "columnOption", "columnCount", "clearSorting", "clearGrouping", "getVisibleColumns", "getVisibleColumnIndex"]
},
applyDataSource: function(dataSource, forceApplying) {
var isDataSourceLoaded = dataSource && dataSource.isLoaded();
this._dataSource = dataSource;
if (!this._dataSourceApplied || 0 === this._dataSourceColumnsCount || forceApplying || this.option("regenerateColumnsByVisibleItems")) {
if (isDataSourceLoaded) {
if (!this._isColumnsFromOptions) {
var columnsFromDataSource = function(that, dataSource) {
var firstItems = that._getFirstItems(dataSource);
var fieldName;
var processedFields = {};
var result = [];
for (var i = 0; i < firstItems.length; i++) {
if (firstItems[i]) {
for (fieldName in firstItems[i]) {
if (!isFunction(firstItems[i][fieldName]) || variableWrapper.isWrapped(firstItems[i][fieldName])) {
processedFields[fieldName] = true
}
}
}
}
for (fieldName in processedFields) {
if (0 !== fieldName.indexOf("__")) {
var column = createColumn(that, fieldName);
result.push(column)
}
}
return result
}(this, dataSource);
if (columnsFromDataSource.length) {
assignColumns(this, columnsFromDataSource);
this._dataSourceColumnsCount = this._columns.length;
applyUserState(this)
}
}
return this.updateColumns(dataSource, forceApplying)
} else {
this._dataSourceApplied = false
}
} else if (isDataSourceLoaded && !this.isAllDataTypesDefined(true) && this.updateColumnDataTypes(dataSource)) {