devextreme
Version:
HTML5 JavaScript Component Suite for Responsive Web Development
965 lines (962 loc) • 119 kB
JavaScript
/**
* DevExtreme (ui/grid_core/ui.grid_core.columns_controller.js)
* Version: 18.2.18
* Build date: Tue Oct 18 2022
*
* Copyright (c) 2012 - 2022 Developer Express Inc. ALL RIGHTS RESERVED
* Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
*/
"use strict";
var _renderer = require("../../core/renderer");
var _renderer2 = _interopRequireDefault(_renderer);
var _callbacks = require("../../core/utils/callbacks");
var _callbacks2 = _interopRequireDefault(_callbacks);
var _variable_wrapper = require("../../core/utils/variable_wrapper");
var _data = require("../../core/utils/data");
var _data2 = _interopRequireDefault(_data);
var _common = require("../../core/utils/common");
var _type = require("../../core/utils/type");
var _iterator = require("../../core/utils/iterator");
var _iterator2 = _interopRequireDefault(_iterator);
var _position = require("../../core/utils/position");
var _extend = require("../../core/utils/extend");
var _array = require("../../core/utils/array");
var _config = require("../../core/config");
var _config2 = _interopRequireDefault(_config);
var _object = require("../../core/utils/object");
var _ui = require("../widget/ui.errors");
var _ui2 = _interopRequireDefault(_ui);
var _uiGrid_core = require("./ui.grid_core.modules");
var _uiGrid_core2 = _interopRequireDefault(_uiGrid_core);
var _uiGrid_core3 = require("./ui.grid_core.utils");
var _inflector = require("../../core/utils/inflector");
var _inflector2 = _interopRequireDefault(_inflector);
var _date_serialization = require("../../core/utils/date_serialization");
var _date_serialization2 = _interopRequireDefault(_date_serialization);
var _number = require("../../localization/number");
var _number2 = _interopRequireDefault(_number);
var _date = require("../../localization/date");
var _date2 = _interopRequireDefault(_date);
var _message = require("../../localization/message");
var _message2 = _interopRequireDefault(_message);
var _deferred = require("../../core/utils/deferred");
var _abstract_store = require("../../data/abstract_store");
var _abstract_store2 = _interopRequireDefault(_abstract_store);
var _data_source = require("../../data/data_source/data_source");
var _filtering = require("../shared/filtering");
var _filtering2 = _interopRequireDefault(_filtering);
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
"default": obj
}
}
var USER_STATE_FIELD_NAMES_15_1 = ["filterValues", "filterType", "fixed", "fixedPosition"],
USER_STATE_FIELD_NAMES = ["visibleIndex", "dataField", "name", "dataType", "width", "visible", "sortOrder", "lastSortOrder", "sortIndex", "groupIndex", "filterValue", "selectedFilterOperation", "added"].concat(USER_STATE_FIELD_NAMES_15_1),
IGNORE_COLUMN_OPTION_NAMES = {
visibleWidth: true,
bestFitWidth: true,
bufferedFilterValue: true
},
COMMAND_EXPAND_CLASS = "dx-command-expand",
MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991,
GROUP_COMMAND_COLUMN_NAME = "groupExpand";
var regExp = /columns\[(\d+)\]\.?/gi;
var globalColumnId = 1;
module.exports = {
defaultOptions: function() {
return {
commonColumnSettings: {
allowFiltering: true,
allowHiding: true,
allowSorting: true,
allowEditing: true,
encodeHtml: true,
trueText: _message2.default.format("dxDataGrid-trueText"),
falseText: _message2.default.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: _uiGrid_core2.default.Controller.inherit(function() {
var DEFAULT_COLUMN_OPTIONS = {
visible: true,
showInColumnChooser: true
},
DATATYPE_OPERATIONS = {
number: ["=", "<>", "<", ">", "<=", ">=", "between"],
string: ["contains", "notcontains", "startswith", "endswith", "=", "<>"],
date: ["=", "<>", "<", ">", "<=", ">=", "between"],
datetime: ["=", "<>", "<", ">", "<=", ">=", "between"]
},
COLUMN_INDEX_OPTIONS = {
visibleIndex: true,
groupIndex: true,
grouped: true,
sortIndex: true,
sortOrder: true
},
GROUP_LOCATION = "group",
COLUMN_CHOOSER_LOCATION = "columnChooser";
var setFilterOperationsAsDefaultValues = function(column) {
column.filterOperations = column.defaultFilterOperations
};
var createColumn = function(that, columnOptions, userStateColumnOptions, bandColumn) {
var calculatedColumnOptions, commonColumnOptions = {};
if (columnOptions) {
if ((0, _type.isString)(columnOptions)) {
columnOptions = {
dataField: columnOptions
}
}
var result = void 0;
if (columnOptions.command) {
result = (0, _object.deepExtendArraySafe)(commonColumnOptions, columnOptions)
} else {
commonColumnOptions = that.getCommonSettings(columnOptions);
if (userStateColumnOptions && userStateColumnOptions.name && userStateColumnOptions.dataField) {
columnOptions = (0, _extend.extend)({}, columnOptions, {
dataField: userStateColumnOptions.dataField
})
}
calculatedColumnOptions = that._createCalculatedColumnOptions(columnOptions, bandColumn);
result = (0, _object.deepExtendArraySafe)({
headerId: "dx-col-" + globalColumnId++
}, DEFAULT_COLUMN_OPTIONS);
(0, _object.deepExtendArraySafe)(result, commonColumnOptions);
(0, _object.deepExtendArraySafe)(result, calculatedColumnOptions);
(0, _object.deepExtendArraySafe)(result, columnOptions);
(0, _object.deepExtendArraySafe)(result, {
selector: null
})
}
if (columnOptions.filterOperations === columnOptions.defaultFilterOperations) {
setFilterOperationsAsDefaultValues(result)
}
return result
}
};
var createColumnsFromOptions = function createColumnsFromOptions(that, columnsOptions, bandColumn) {
var result = [];
if (columnsOptions) {
_iterator2.default.each(columnsOptions, function(index, columnOptions) {
var userStateColumnOptions = that._columnsUserState && checkUserStateColumn(columnOptions, that._columnsUserState[index]) && that._columnsUserState[index],
column = createColumn(that, columnOptions, userStateColumnOptions, bandColumn);
if (column) {
if (bandColumn) {
column.ownerBand = bandColumn
}
result.push(column);
if (column.isBand) {
result = result.concat(createColumnsFromOptions(that, column.columns, column));
delete column.columns
}
}
})
}
return result
};
var getParentBandColumns = function(columnIndex, columnParentByIndex) {
var result = [],
parent = columnParentByIndex[columnIndex];
while (parent) {
result.unshift(parent);
columnIndex = parent.index;
parent = columnParentByIndex[columnIndex]
}
return result
};
var _getChildrenByBandColumn = function _getChildrenByBandColumn(columnIndex, columnChildrenByIndex, recursive) {
var column, result = [],
children = columnChildrenByIndex[columnIndex];
if (children) {
for (var i = 0; i < children.length; i++) {
column = children[i];
if (!(0, _type.isDefined)(column.groupIndex) || column.showWhenGrouped) {
result.push(column);
if (recursive && column.isBand) {
result = result.concat(_getChildrenByBandColumn(column.index, columnChildrenByIndex, recursive))
}
}
}
}
return result
};
var getColumnByIndexes = function(that, columnIndexes) {
var result, callbackFilter = function(column) {
var ownerBand = result ? result.index : void 0;
return column.ownerBand === ownerBand
},
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
};
var getColumnFullPath = function(that, column) {
var result = [],
bandColumnsCache = that.getBandColumnsCache(),
callbackFilter = function(item) {
return item.ownerBand === column.ownerBand
},
columns = that._columns.filter(callbackFilter);
while (columns.length && columns.indexOf(column) !== -1) {
result.unshift("columns[" + 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,
columns = that.getChildrenByBandColumn(columnID, true);
_iterator2.default.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 processBandColumns = function(that, columns, bandColumnsCache) {
var i, column, rowspan, rowCount = that.getRowCount();
for (i = 0; i < columns.length; i++) {
column = columns[i];
if (column.visible || column.command) {
if (column.isBand) {
column.colspan = column.colspan || calculateColspan(that, column.index)
}
if (!column.isBand || !column.colspan) {
rowspan = rowCount - (!column.command && !(0, _type.isDefined)(column.groupIndex) ? getParentBandColumns(column.index, bandColumnsCache.columnParentByIndex).length : 0);
if (rowspan > 1) {
column.rowspan = rowspan
}
}
}
}
};
var getValueDataType = function(value) {
var dataType = (0, _type.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 _date_serialization2.default.getDateSerializationFormat(value);
case "number":
if ((0, _type.isString)(value)) {
return "string"
}
if ((0, _type.isNumeric)(value)) {
return null
}
}
};
var updateSerializers = function(options, dataType) {
if (!options.deserializeValue) {
if ((0, _uiGrid_core3.isDateType)(dataType)) {
options.deserializeValue = function(value) {
return _date_serialization2.default.deserializeDate(value)
};
options.serializeValue = function(value) {
return (0, _type.isString)(value) ? value : _date_serialization2.default.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 (0, _type.isDefined)(value) && "string" === this.serializationFormat ? value.toString() : value
}
}
}
};
var getAlignmentByDataType = function(dataType, isRTL) {
switch (dataType) {
case "number":
return "right";
case "boolean":
return "center";
default:
return (0, _position.getDefaultAlignment)(isRTL)
}
};
var getCustomizeTextByDataType = function(dataType) {
if ("boolean" === dataType) {
return function(e) {
if (true === e.value) {
return this.trueText || "true"
} else {
if (false === e.value) {
return this.falseText || "false"
} else {
return e.valueText || ""
}
}
}
}
};
var createColumnsFromDataSource = function(that, dataSource) {
var fieldName, i, firstItems = that._getFirstItems(dataSource),
processedFields = {},
result = [];
for (i = 0; i < firstItems.length; i++) {
if (firstItems[i]) {
for (fieldName in firstItems[i]) {
if (!(0, _type.isFunction)(firstItems[i][fieldName]) || (0, _variable_wrapper.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
};
var updateColumnIndexes = function(that) {
_iterator2.default.each(that._columns, function(index, column) {
column.index = index
});
_iterator2.default.each(that._columns, function(index, column) {
if ((0, _type.isObject)(column.ownerBand)) {
column.ownerBand = column.ownerBand.index
}
});
_iterator2.default.each(that._commandColumns, function(index, column) {
column.index = -(index + 1)
})
};
var updateColumnGroupIndexes = function(that, currentColumn) {
(0, _array.normalizeIndexes)(that._columns, "groupIndex", currentColumn, function(column) {
var grouped = column.grouped;
delete column.grouped;
return grouped
})
};
var updateColumnSortIndexes = function(that, currentColumn) {
_iterator2.default.each(that._columns, function(index, column) {
if ((0, _type.isDefined)(column.sortIndex) && !isSortOrderValid(column.sortOrder)) {
delete column.sortIndex
}
});
(0, _array.normalizeIndexes)(that._columns, "sortIndex", currentColumn, function(column) {
return !(0, _type.isDefined)(column.groupIndex) && isSortOrderValid(column.sortOrder)
})
};
var updateColumnVisibleIndexes = function(that, currentColumn) {
var i, key, column, bandColumnIndex, parentBandColumns, bandColumns = {},
result = [],
bandColumnsCache = that.getBandColumnsCache(),
columns = that._columns.filter(function(column) {
return !column.command
});
for (i = 0; i < columns.length; i++) {
column = columns[i];
parentBandColumns = getParentBandColumns(i, bandColumnsCache.columnParentByIndex);
if (parentBandColumns.length) {
bandColumnIndex = parentBandColumns[parentBandColumns.length - 1].index;
bandColumns[bandColumnIndex] = bandColumns[bandColumnIndex] || [];
bandColumns[bandColumnIndex].push(column)
} else {
result.push(column)
}
}
for (key in bandColumns) {
(0, _array.normalizeIndexes)(bandColumns[key], "visibleIndex", currentColumn)
}(0, _array.normalizeIndexes)(result, "visibleIndex", currentColumn)
};
var getColumnIndexByVisibleIndex = function(that, visibleIndex, location) {
var column, rowIndex = (0, _type.isObject)(visibleIndex) ? visibleIndex.rowIndex : null,
columns = location === GROUP_LOCATION ? that.getGroupColumns() : location === COLUMN_CHOOSER_LOCATION ? that.getChooserColumns() : that.getVisibleColumns(rowIndex);
visibleIndex = (0, _type.isObject)(visibleIndex) ? visibleIndex.columnIndex : visibleIndex;
column = columns[visibleIndex];
if (column && column.type === GROUP_COMMAND_COLUMN_NAME) {
column = that._columns.filter(function(col) {
return column.type === col.type
})[0] || column
}
return column && (0, _type.isDefined)(column.index) ? column.index : -1
};
var moveColumnToGroup = function(that, column, groupIndex) {
var i, groupColumns = that.getGroupColumns();
if (groupIndex >= 0) {
for (i = 0; i < groupColumns.length; i++) {
if (groupColumns[i].groupIndex >= groupIndex) {
groupColumns[i].groupIndex++
}
}
} else {
groupIndex = 0;
for (i = 0; i < groupColumns.length; i++) {
groupIndex = Math.max(groupIndex, groupColumns[i].groupIndex + 1)
}
}
return groupIndex
};
var checkUserStateColumn = function(column, userStateColumn) {
return column && userStateColumn && userStateColumn.name === column.name && (userStateColumn.dataField === column.dataField || column.name)
};
var applyUserState = function(that) {
var column, columnUserState, userStateColumnIndex, i, columnsUserState = that._columnsUserState,
ignoreColumnOptionNames = that._ignoreColumnOptionNames || [],
columns = that._columns,
columnCountById = {},
resultColumns = [],
allColumnsHaveState = true,
userStateColumnIndexes = [];
function applyFieldsState(column, userStateColumn) {
var fieldName;
if (!userStateColumn) {
return
}
for (var index = 0; index < USER_STATE_FIELD_NAMES.length; index++) {
fieldName = USER_STATE_FIELD_NAMES[index];
if ((0, _array.inArray)(fieldName, ignoreColumnOptionNames) >= 0) {
continue
}
if ("dataType" === fieldName) {
column[fieldName] = column[fieldName] || userStateColumn[fieldName]
} else {
if ((0, _array.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,
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 && (0, _type.isDefined)(columnsUserState[userStateColumnIndex].initialIndex)) {
resultColumns[userStateColumnIndex] = column
} else {
resultColumns.push(column)
}
}
var hasAddedBands = false;
for (i = 0; i < columnsUserState.length; i++) {
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);
updateColumnSortIndexes(that, column);
updateColumnVisibleIndexes(that, column)
};
var resetColumnsCache = function(that) {
that.resetColumnsCache()
};
var assignColumns = function(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"),
columnChanges = that._columnChanges,
reinitOptionNames = ["dataField", "lookup", "dataType", "columns"],
needReinit = function(options) {
return options && reinitOptionNames.some(function(name) {
return options[name]
})
};
if (that.isInitialized() && !that._updateLockCount && columnChanges) {
if (onColumnsChanging) {
that._updateLockCount++;
onColumnsChanging((0, _extend.extend)({
component: that.component
}, columnChanges));
that._updateLockCount--
}
that._columnChanges = void 0;
if (needReinit(columnChanges.optionNames)) {
that.reinit()
} else {
that.columnsChanged.fire(columnChanges)
}
}
};
var updateSortOrderWhenGrouping = function(column, groupIndex, prevGroupIndex) {
var columnWasGrouped = prevGroupIndex >= 0;
if (groupIndex >= 0) {
if (!columnWasGrouped) {
column.lastSortOrder = column.sortOrder
}
} else {
column.sortOrder = column.lastSortOrder
}
};
var fireOptionChanged = function(that, options) {
var value = options.value,
optionName = options.optionName,
prevValue = options.prevValue,
fullOptionName = options.fullOptionName;
if (!IGNORE_COLUMN_OPTION_NAMES[optionName]) {
that._skipProcessingColumnsChange = true;
that.component._notifyOptionChanged(fullOptionName + "." + optionName, value, prevValue);
that._skipProcessingColumnsChange = false
}
};
var columnOptionCore = function(that, column, optionName, value, notFireEvent) {
var prevValue, optionSetter, columns, changeType, fullOptionName, initialColumn, optionGetter = _data2.default.compileGetter(optionName),
columnIndex = column.index;
if (3 === arguments.length) {
return optionGetter(column, {
functionsAsIs: true
})
}
prevValue = optionGetter(column, {
functionsAsIs: true
});
if (prevValue !== value) {
if ("groupIndex" === optionName || "calculateGroupValue" === optionName) {
changeType = "grouping";
updateSortOrderWhenGrouping(column, value, prevValue)
} else {
if ("sortIndex" === optionName || "sortOrder" === optionName || "calculateSortValue" === optionName) {
changeType = "sorting"
} else {
changeType = "columns"
}
}
optionSetter = _data2.default.compileSetter(optionName);
optionSetter(column, value, {
functionsAsIs: true
});
fullOptionName = getColumnFullPath(that, column);
fullOptionName && fireOptionChanged(that, {
fullOptionName: fullOptionName,
optionName: optionName,
value: value,
prevValue: prevValue
});
if (!(0, _type.isDefined)(prevValue) && !(0, _type.isDefined)(value) && 0 !== optionName.indexOf("buffer")) {
notFireEvent = true
}
if (!notFireEvent) {
if ((0, _array.inArray)(optionName, USER_STATE_FIELD_NAMES) < 0 && "visibleWidth" !== optionName) {
columns = that.option("columns");
initialColumn = that.getColumnByPath(fullOptionName, columns);
if ((0, _type.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)
}
}
};
var isSortOrderValid = function(sortOrder) {
return "asc" === sortOrder || "desc" === sortOrder
};
var addExpandColumn = function(that) {
var options = that._getExpandColumnOptions();
that.addCommandColumn(options)
};
var defaultSetCellValue = function(data, value) {
var name, i, path = this.dataField.split("."),
dotCount = path.length - 1;
if (this.serializeValue) {
value = this.serializeValue(value)
}
for (i = 0; i < dotCount; i++) {
name = path[i];
data = data[name] = data[name] || {}
}
data[path[dotCount]] = value
};
var getDataColumns = function getDataColumns(columns, rowIndex, bandColumnID) {
var result = [];
rowIndex = rowIndex || 0;
columns[rowIndex] && _iterator2.default.each(columns[rowIndex], function(_, column) {
if (column.ownerBand === bandColumnID || (0, _type.isDefined)(column.groupIndex)) {
if (!column.isBand || !column.colspan) {
if (!column.command || rowIndex < 1) {
result.push(column)
}
} else {
result.push.apply(result, getDataColumns(columns, rowIndex + 1, column.index))
}
}
});
return result
};
var _getRowCount = function(that, level, bandColumnIndex) {
var rowCount = 1,
bandColumnsCache = that.getBandColumnsCache(),
columnParentByIndex = bandColumnsCache.columnParentByIndex;
that._columns.forEach(function(column) {
var parents = getParentBandColumns(column.index, columnParentByIndex),
invisibleParents = parents.filter(function(column) {
return !column.visible
});
if (column.visible && !invisibleParents.length) {
rowCount = Math.max(rowCount, parents.length + 1)
}
});
return rowCount
};
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, rowCount = this.getRowCount(),
rowspan = columns[columnIndex] && columns[columnIndex].rowspan,
expandColumnsByType = expandColumns.filter(function(column) {
return column.type === type
});
columns.forEach(function(column, index) {
if (column.type === type) {
customColumnIndex = index;
rowspan = columns[index + 1] ? columns[index + 1].rowspan : rowCount
}
});
if (rowspan > 1) {
expandColumnsByType = _iterator2.default.map(expandColumnsByType, function(expandColumn) {
return (0, _extend.extend)({}, expandColumn, {
rowspan: rowspan
})
})
}
expandColumnsByType.unshift.apply(expandColumnsByType, (0, _type.isDefined)(customColumnIndex) ? [customColumnIndex, 1] : [columnIndex, 0]);
columns.splice.apply(columns, expandColumnsByType);
return rowspan || 1
};
var digitsCount = function(number) {
var i;
for (i = 0; number > 1; i++) {
number /= 10
}
return i
};
var numberToString = function(number, digitsCount) {
var str = number ? number.toString() : "0";
while (str.length < digitsCount) {
str = "0" + str
}
return str
};
var mergeColumns = function(that, columns, commandColumns, needToExtend) {
var i, column, columnOptions, commandColumnIndex, result = columns.slice().map(function(column) {
return (0, _extend.extend)({}, column)
}),
isColumnFixing = that._isColumnFixing(),
defaultCommandColumns = commandColumns.slice().map(function(column) {
return (0, _extend.extend)({
fixed: isColumnFixing
}, column)
}),
getCommandColumnIndex = function(column) {
return commandColumns.reduce(function(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)
},
callbackFilter = function(commandColumn) {
return commandColumn.command !== commandColumns[commandColumnIndex].command
};
for (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] = (0, _extend.extend)({
fixed: isColumnFixing
}, commandColumns[commandColumnIndex], column);
if (column.type !== GROUP_COMMAND_COLUMN_NAME) {
defaultCommandColumns = defaultCommandColumns.filter(callbackFilter)
}
} else {
columnOptions = {
visibleIndex: column.visibleIndex,
index: column.index,
headerId: column.headerId,
allowFixing: 0 === column.groupIndex,
allowReordering: 0 === column.groupIndex,
groupIndex: column.groupIndex
};
result[i] = (0, _extend.extend)({}, column, commandColumns[commandColumnIndex], column.type === GROUP_COMMAND_COLUMN_NAME && columnOptions)
}
}
}
if (columns.length && needToExtend && defaultCommandColumns.length) {
result = result.concat(defaultCommandColumns)
}
return result
};
var isCustomCommandColumn = function(that, commandColumn) {
return !!that._columns.filter(function(column) {
return column.type === commandColumn.type
}).length
};
var isColumnFixed = function(that, column) {
return (0, _type.isDefined)(column.fixed) || !column.type ? column.fixed : that._isColumnFixing()
};
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, items = [];
var getFirstItemsCore = function getFirstItemsCore(items, groupsCount) {
var i, childItems;
if (!items || !groupsCount) {
return items
}
for (i = 0; i < items.length; i++) {
childItems = getFirstItemsCore(items[i].items || items[i].collapsedItems, groupsCount - 1);
if (childItems && childItems.length) {
return childItems
}
}
};
if (dataSource && dataSource.items().length > 0) {
groupsCount = (0, _uiGrid_core3.normalizeSortingInfo)(dataSource.group()).length;
items = getFirstItemsCore(dataSource.items(), groupsCount) || []
}
return items
},
_endUpdateCore: function() {
!this._skipProcessingColumnsChange && fireColumnsChanged(this)
},
init: function() {
var that = this,
columns = that.option("columns");
that._commandColumns = that._commandColumns || [];
that._columns = that._columns || [];
that._isColumnsFromOptions = !!columns;
if (that._isColumnsFromOptions) {
assignColumns(that, columns ? createColumnsFromOptions(that, columns) : []);
applyUserState(that)
} else {
assignColumns(that, that._columnsUserState ? createColumnsFromOptions(that, that._columnsUserState) : that._columns)
}
addExpandColumn(that);
if (that._dataSourceApplied) {
that.applyDataSource(that._dataSource, true)
} else {
updateIndexes(that)
}
},
callbackNames: function() {
return ["columnsChanged"]
},
getColumnByPath: function(path, columns) {
var column, that = this,
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 = getColumnByIndexes(that, columnIndexes)
}
}
return column
},
optionChanged: function(args) {
switch (args.name) {
case "adaptColumnWidthByRatio":
args.handled = true;
break;
case "columns":
args.handled = true;
if (!this._skipProcessingColumnsChange) {
if (args.name === args.fullName) {
this._columnsUserState = null;
this._ignoreColumnOptionNames = null;
this.init()
} else {
this._columnOptionChanged(args)
}
} else {
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":
args.handled = true;
if (!(args.fullName && 0 === args.fullName.indexOf("editing.popup"))) {
this.reinit()
}
break;
case "rtlEnabled":
this.reinit();
break;
default:
this.callBase(args)
}
},
_columnOptionChanged: function(args) {
var columnOptionValue = {},
column = this.getColumnByPath(args.fullName),
columnOptionName = args.fullName.replace(regExp, "");
if (column) {
if (columnOptionName) {
columnOptionValue[columnOptionName] = args.value
} else {
columnOptionValue = args.value
}
this.columnOption(column.index, columnOptionValue)
}
},
_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"]
},
applyDataSource: function(dataSource, forceApplying) {
var that = this,
isDataSourceLoaded = dataSource && dataSource.isLoaded();
that._dataSource = dataSource;
if (!that._dataSourceApplied || 0 === that._dataSourceColumnsCount || forceApplying || that.option("regenerateColumnsByVisibleItems")) {
if (isDataSourceLoaded) {
if (!that._isCo