ag-grid
Version:
Advanced Javascript Datagrid. Supports raw Javascript, AngularJS 1.x, AngularJS 2.0 and Web Components
1,017 lines • 521 kB
JavaScript
/**
* ag-grid - Advanced Javascript Datagrid. Supports raw Javascript, AngularJS 1.x, AngularJS 2.0 and Web Components
* @version v2.1.1
* @link http://www.ag-grid.com/
* @license MIT
*/
/// <references path='events.ts'/>
var ag;
(function (ag) {
var grid;
(function (grid) {
var ColumnChangeEvent = (function () {
function ColumnChangeEvent(type) {
this.type = type;
}
ColumnChangeEvent.prototype.toString = function () {
var result = 'ColumnChangeEvent {type: ' + this.type;
if (this.column) {
result += ', column: ' + this.column.colId;
}
if (this.columnGroup) {
result += ', columnGroup: ' + this.columnGroup.name;
}
if (this.fromIndex) {
result += ', fromIndex: ' + this.fromIndex;
}
if (this.toIndex) {
result += ', toIndex: ' + this.toIndex;
}
if (this.pinnedColumnCount) {
result += ', pinnedColumnCount: ' + this.pinnedColumnCount;
}
result += '}';
return result;
};
ColumnChangeEvent.prototype.withColumn = function (column) {
this.column = column;
return this;
};
ColumnChangeEvent.prototype.withColumnGroup = function (columnGroup) {
this.columnGroup = columnGroup;
return this;
};
ColumnChangeEvent.prototype.withFromIndex = function (fromIndex) {
this.fromIndex = fromIndex;
return this;
};
ColumnChangeEvent.prototype.withPinnedColumnCount = function (pinnedColumnCount) {
this.pinnedColumnCount = pinnedColumnCount;
return this;
};
ColumnChangeEvent.prototype.withToIndex = function (toIndex) {
this.toIndex = toIndex;
return this;
};
ColumnChangeEvent.prototype.getFromIndex = function () {
return this.fromIndex;
};
ColumnChangeEvent.prototype.getToIndex = function () {
return this.toIndex;
};
ColumnChangeEvent.prototype.getPinnedColumnCount = function () {
return this.pinnedColumnCount;
};
ColumnChangeEvent.prototype.getType = function () {
return this.type;
};
ColumnChangeEvent.prototype.getColumn = function () {
return this.column;
};
ColumnChangeEvent.prototype.getColumnGroup = function () {
return this.columnGroup;
};
ColumnChangeEvent.prototype.isPivotChanged = function () {
return this.type === grid.Events.EVENT_COLUMN_PIVOT_CHANGE || this.type === grid.Events.EVENT_COLUMN_EVERYTHING_CHANGED;
};
ColumnChangeEvent.prototype.isValueChanged = function () {
return this.type === grid.Events.EVENT_COLUMN_VALUE_CHANGE || this.type === grid.Events.EVENT_COLUMN_EVERYTHING_CHANGED;
};
ColumnChangeEvent.prototype.isIndividualColumnResized = function () {
return this.type === grid.Events.EVENT_COLUMN_RESIZED && this.column !== undefined && this.column !== null;
};
return ColumnChangeEvent;
})();
grid.ColumnChangeEvent = ColumnChangeEvent;
})(grid = ag.grid || (ag.grid = {}));
})(ag || (ag = {}));
var ag;
(function (ag) {
var grid;
(function (grid) {
var FUNCTION_STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
var FUNCTION_ARGUMENT_NAMES = /([^\s,]+)/g;
var Utils = (function () {
function Utils() {
}
Utils.iterateObject = function (object, callback) {
var keys = Object.keys(object);
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
var value = object[key];
callback(key, value);
}
};
Utils.cloneObject = function (object) {
var copy = {};
var keys = Object.keys(object);
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
var value = object[key];
copy[key] = value;
}
return copy;
};
Utils.map = function (array, callback) {
var result = [];
for (var i = 0; i < array.length; i++) {
var item = array[i];
var mappedItem = callback(item);
result.push(mappedItem);
}
return result;
};
Utils.forEach = function (array, callback) {
if (!array) {
return;
}
for (var i = 0; i < array.length; i++) {
var value = array[i];
callback(value, i);
}
};
Utils.filter = function (array, callback) {
var result = [];
array.forEach(function (item) {
if (callback(item)) {
result.push(item);
}
});
return result;
};
Utils.assign = function (object, source) {
Utils.iterateObject(source, function (key, value) {
object[key] = value;
});
};
Utils.getFunctionParameters = function (func) {
var fnStr = func.toString().replace(FUNCTION_STRIP_COMMENTS, '');
var result = fnStr.slice(fnStr.indexOf('(') + 1, fnStr.indexOf(')')).match(FUNCTION_ARGUMENT_NAMES);
if (result === null) {
return [];
}
else {
return result;
}
};
Utils.find = function (collection, predicate, value) {
if (collection === null || collection === undefined) {
return null;
}
for (var i = 0; i < collection.length; i++) {
if (collection[i][predicate] === value) {
return collection[i];
}
}
return null;
};
Utils.toStrings = function (array) {
return this.map(array, function (item) {
if (item === undefined || item === null || !item.toString) {
return null;
}
else {
return item.toString();
}
});
};
Utils.iterateArray = function (array, callback) {
for (var index = 0; index < array.length; index++) {
var value = array[index];
callback(value, index);
}
};
//Returns true if it is a DOM node
//taken from: http://stackoverflow.com/questions/384286/javascript-isdom-how-do-you-check-if-a-javascript-object-is-a-dom-object
Utils.isNode = function (o) {
return (typeof Node === "object" ? o instanceof Node :
o && typeof o === "object" && typeof o.nodeType === "number" && typeof o.nodeName === "string");
};
//Returns true if it is a DOM element
//taken from: http://stackoverflow.com/questions/384286/javascript-isdom-how-do-you-check-if-a-javascript-object-is-a-dom-object
Utils.isElement = function (o) {
return (typeof HTMLElement === "object" ? o instanceof HTMLElement :
o && typeof o === "object" && o !== null && o.nodeType === 1 && typeof o.nodeName === "string");
};
Utils.isNodeOrElement = function (o) {
return this.isNode(o) || this.isElement(o);
};
//adds all type of change listeners to an element, intended to be a text field
Utils.addChangeListener = function (element, listener) {
element.addEventListener("changed", listener);
element.addEventListener("paste", listener);
element.addEventListener("input", listener);
// IE doesn't fire changed for special keys (eg delete, backspace), so need to
// listen for this further ones
element.addEventListener("keydown", listener);
element.addEventListener("keyup", listener);
};
//if value is undefined, null or blank, returns null, otherwise returns the value
Utils.makeNull = function (value) {
if (value === null || value === undefined || value === "") {
return null;
}
else {
return value;
}
};
Utils.removeAllChildren = function (node) {
if (node) {
while (node.hasChildNodes()) {
node.removeChild(node.lastChild);
}
}
};
Utils.removeElement = function (parent, cssSelector) {
this.removeFromParent(parent.querySelector(cssSelector));
};
Utils.removeFromParent = function (node) {
if (node && node.parentNode) {
node.parentNode.removeChild(node);
}
};
Utils.isVisible = function (element) {
return (element.offsetParent !== null);
};
/**
* loads the template and returns it as an element. makes up for no simple way in
* the dom api to load html directly, eg we cannot do this: document.createElement(template)
*/
Utils.loadTemplate = function (template) {
var tempDiv = document.createElement("div");
tempDiv.innerHTML = template;
return tempDiv.firstChild;
};
Utils.querySelectorAll_addCssClass = function (eParent, selector, cssClass) {
var eRows = eParent.querySelectorAll(selector);
for (var k = 0; k < eRows.length; k++) {
this.addCssClass(eRows[k], cssClass);
}
};
Utils.querySelectorAll_removeCssClass = function (eParent, selector, cssClass) {
var eRows = eParent.querySelectorAll(selector);
for (var k = 0; k < eRows.length; k++) {
this.removeCssClass(eRows[k], cssClass);
}
};
Utils.querySelectorAll_replaceCssClass = function (eParent, selector, cssClassToRemove, cssClassToAdd) {
var eRows = eParent.querySelectorAll(selector);
for (var k = 0; k < eRows.length; k++) {
this.removeCssClass(eRows[k], cssClassToRemove);
this.addCssClass(eRows[k], cssClassToAdd);
}
};
Utils.addOrRemoveCssClass = function (element, className, addOrRemove) {
if (addOrRemove) {
this.addCssClass(element, className);
}
else {
this.removeCssClass(element, className);
}
};
Utils.addCssClass = function (element, className) {
if (element.className && element.className.length > 0) {
var cssClasses = element.className.split(' ');
if (cssClasses.indexOf(className) < 0) {
cssClasses.push(className);
element.className = cssClasses.join(' ');
}
}
else {
element.className = className;
}
};
Utils.offsetHeight = function (element) {
return element && element.clientHeight ? element.clientHeight : 0;
};
Utils.offsetWidth = function (element) {
return element && element.clientWidth ? element.clientWidth : 0;
};
Utils.removeCssClass = function (element, className) {
if (element.className && element.className.length > 0) {
var cssClasses = element.className.split(' ');
var index = cssClasses.indexOf(className);
if (index >= 0) {
cssClasses.splice(index, 1);
element.className = cssClasses.join(' ');
}
}
};
Utils.removeFromArray = function (array, object) {
if (array.indexOf(object) >= 0) {
array.splice(array.indexOf(object), 1);
}
};
Utils.defaultComparator = function (valueA, valueB) {
var valueAMissing = valueA === null || valueA === undefined;
var valueBMissing = valueB === null || valueB === undefined;
if (valueAMissing && valueBMissing) {
return 0;
}
if (valueAMissing) {
return -1;
}
if (valueBMissing) {
return 1;
}
if (valueA < valueB) {
return -1;
}
else if (valueA > valueB) {
return 1;
}
else {
return 0;
}
};
Utils.formatWidth = function (width) {
if (typeof width === "number") {
return width + "px";
}
else {
return width;
}
};
/**
* Tries to use the provided renderer.
*/
Utils.useRenderer = function (eParent, eRenderer, params) {
var resultFromRenderer = eRenderer(params);
//TypeScript type inference magic
if (typeof resultFromRenderer === 'string') {
var eTextSpan = document.createElement('span');
eTextSpan.innerHTML = resultFromRenderer;
eParent.appendChild(eTextSpan);
}
else if (this.isNodeOrElement(resultFromRenderer)) {
//a dom node or element was returned, so add child
eParent.appendChild(resultFromRenderer);
}
};
/**
* If icon provided, use this (either a string, or a function callback).
* if not, then use the second parameter, which is the svgFactory function
*/
Utils.createIcon = function (iconName, gridOptionsWrapper, colDefWrapper, svgFactoryFunc) {
var eResult = document.createElement('span');
var userProvidedIcon;
// check col for icon first
if (colDefWrapper && colDefWrapper.colDef.icons) {
userProvidedIcon = colDefWrapper.colDef.icons[iconName];
}
// it not in col, try grid options
if (!userProvidedIcon && gridOptionsWrapper.getIcons()) {
userProvidedIcon = gridOptionsWrapper.getIcons()[iconName];
}
// now if user provided, use it
if (userProvidedIcon) {
var rendererResult;
if (typeof userProvidedIcon === 'function') {
rendererResult = userProvidedIcon();
}
else if (typeof userProvidedIcon === 'string') {
rendererResult = userProvidedIcon;
}
else {
throw 'icon from grid options needs to be a string or a function';
}
if (typeof rendererResult === 'string') {
eResult.innerHTML = rendererResult;
}
else if (this.isNodeOrElement(rendererResult)) {
eResult.appendChild(rendererResult);
}
else {
throw 'iconRenderer should return back a string or a dom object';
}
}
else {
// otherwise we use the built in icon
eResult.appendChild(svgFactoryFunc());
}
return eResult;
};
Utils.addStylesToElement = function (eElement, styles) {
Object.keys(styles).forEach(function (key) {
eElement.style[key] = styles[key];
});
};
Utils.getScrollbarWidth = function () {
var outer = document.createElement("div");
outer.style.visibility = "hidden";
outer.style.width = "100px";
outer.style.msOverflowStyle = "scrollbar"; // needed for WinJS apps
document.body.appendChild(outer);
var widthNoScroll = outer.offsetWidth;
// force scrollbars
outer.style.overflow = "scroll";
// add innerdiv
var inner = document.createElement("div");
inner.style.width = "100%";
outer.appendChild(inner);
var widthWithScroll = inner.offsetWidth;
// remove divs
outer.parentNode.removeChild(outer);
return widthNoScroll - widthWithScroll;
};
Utils.isKeyPressed = function (event, keyToCheck) {
var pressedKey = event.which || event.keyCode;
return pressedKey === keyToCheck;
};
Utils.setVisible = function (element, visible) {
if (visible) {
element.style.display = 'inline';
}
else {
element.style.display = 'none';
}
};
Utils.isBrowserIE = function () {
return this.isIE;
};
Utils.isBrowserSafari = function () {
return this.isSafari;
};
// taken from:
// http://stackoverflow.com/questions/9847580/how-to-detect-safari-chrome-ie-firefox-and-opera-browser
Utils.isSafari = Object.prototype.toString.call(window.HTMLElement).indexOf('Constructor') > 0;
Utils.isIE = false || !!document.documentMode; // At least IE6
return Utils;
})();
grid.Utils = Utils;
})(grid = ag.grid || (ag.grid = {}));
})(ag || (ag = {}));
var ag;
(function (ag) {
var grid;
(function (grid) {
var Constants = (function () {
function Constants() {
}
Constants.STEP_EVERYTHING = 0;
Constants.STEP_FILTER = 1;
Constants.STEP_SORT = 2;
Constants.STEP_MAP = 3;
Constants.ASC = "asc";
Constants.DESC = "desc";
Constants.ROW_BUFFER_SIZE = 20;
Constants.MIN_COL_WIDTH = 10;
Constants.SUM = 'sum';
Constants.MIN = 'min';
Constants.MAX = 'max';
Constants.KEY_TAB = 9;
Constants.KEY_ENTER = 13;
Constants.KEY_BACKSPACE = 8;
Constants.KEY_DELETE = 46;
Constants.KEY_ESCAPE = 27;
Constants.KEY_SPACE = 32;
Constants.KEY_DOWN = 40;
Constants.KEY_UP = 38;
Constants.KEY_LEFT = 37;
Constants.KEY_RIGHT = 39;
return Constants;
})();
grid.Constants = Constants;
})(grid = ag.grid || (ag.grid = {}));
})(ag || (ag = {}));
/// <reference path="../constants.ts" />
var ag;
(function (ag) {
var grid;
(function (grid) {
var constants = grid.Constants;
var Column = (function () {
function Column(colDef, actualWidth) {
this.colDef = colDef;
this.actualWidth = actualWidth;
this.visible = !colDef.hide;
this.sort = colDef.sort;
this.sortedAt = colDef.sortedAt;
// in the future, the colKey might be something other than the index
if (colDef.colId) {
this.colId = colDef.colId;
}
else if (colDef.field) {
this.colId = colDef.field;
}
else {
this.colId = '' + Column.colIdSequence++;
}
}
Column.prototype.isGreaterThanMax = function (width) {
if (this.colDef.maxWidth >= constants.MIN_COL_WIDTH) {
return width > this.colDef.maxWidth;
}
else {
return false;
}
};
Column.prototype.getMinimumWidth = function () {
if (this.colDef.minWidth > constants.MIN_COL_WIDTH) {
return this.colDef.minWidth;
}
else {
return constants.MIN_COL_WIDTH;
}
};
Column.prototype.setMinimum = function () {
this.actualWidth = this.getMinimumWidth();
};
Column.colIdSequence = 0;
return Column;
})();
grid.Column = Column;
})(grid = ag.grid || (ag.grid = {}));
})(ag || (ag = {}));
var ag;
(function (ag) {
var grid;
(function (grid) {
var ColumnGroup = (function () {
function ColumnGroup(pinned, name) {
this.allColumns = [];
this.displayedColumns = [];
this.expandable = false;
this.expanded = false;
this.pinned = pinned;
this.name = name;
}
ColumnGroup.prototype.getMinimumWidth = function () {
var result = 0;
this.displayedColumns.forEach(function (column) {
result += column.getMinimumWidth();
});
return result;
};
ColumnGroup.prototype.addColumn = function (column) {
this.allColumns.push(column);
};
// need to check that this group has at least one col showing when both expanded and contracted.
// if not, then we don't allow expanding and contracting on this group
ColumnGroup.prototype.calculateExpandable = function () {
// want to make sure the group doesn't disappear when it's open
var atLeastOneShowingWhenOpen = false;
// want to make sure the group doesn't disappear when it's closed
var atLeastOneShowingWhenClosed = false;
// want to make sure the group has something to show / hide
var atLeastOneChangeable = false;
for (var i = 0, j = this.allColumns.length; i < j; i++) {
var column = this.allColumns[i];
if (column.colDef.headerGroupShow === 'open') {
atLeastOneShowingWhenOpen = true;
atLeastOneChangeable = true;
}
else if (column.colDef.headerGroupShow === 'closed') {
atLeastOneShowingWhenClosed = true;
atLeastOneChangeable = true;
}
else {
atLeastOneShowingWhenOpen = true;
atLeastOneShowingWhenClosed = true;
}
}
this.expandable = atLeastOneShowingWhenOpen && atLeastOneShowingWhenClosed && atLeastOneChangeable;
};
ColumnGroup.prototype.calculateActualWidth = function () {
var actualWidth = 0;
this.displayedColumns.forEach(function (column) {
actualWidth += column.actualWidth;
});
this.actualWidth = actualWidth;
};
ColumnGroup.prototype.calculateDisplayedColumns = function () {
// clear out last time we calculated
this.displayedColumns = [];
// it not expandable, everything is visible
if (!this.expandable) {
this.displayedColumns = this.allColumns;
return;
}
// and calculate again
for (var i = 0, j = this.allColumns.length; i < j; i++) {
var column = this.allColumns[i];
switch (column.colDef.headerGroupShow) {
case 'open':
// when set to open, only show col if group is open
if (this.expanded) {
this.displayedColumns.push(column);
}
break;
case 'closed':
// when set to open, only show col if group is open
if (!this.expanded) {
this.displayedColumns.push(column);
}
break;
default:
// default is always show the column
this.displayedColumns.push(column);
break;
}
}
};
// should replace with utils method 'add all'
ColumnGroup.prototype.addToVisibleColumns = function (colsToAdd) {
for (var i = 0; i < this.displayedColumns.length; i++) {
var column = this.displayedColumns[i];
colsToAdd.push(column);
}
};
return ColumnGroup;
})();
grid.ColumnGroup = ColumnGroup;
})(grid = ag.grid || (ag.grid = {}));
})(ag || (ag = {}));
/// <reference path="constants.ts" />
var ag;
(function (ag) {
var grid;
(function (grid) {
var DEFAULT_ROW_HEIGHT = 25;
var constants = grid.Constants;
function isTrue(value) {
return value === true || value === 'true';
}
var GridOptionsWrapper = (function () {
function GridOptionsWrapper() {
}
GridOptionsWrapper.prototype.init = function (gridOptions, eventService) {
this.gridOptions = gridOptions;
this.headerHeight = gridOptions.headerHeight;
this.groupHeaders = gridOptions.groupHeaders;
this.rowHeight = gridOptions.rowHeight;
this.floatingTopRowData = gridOptions.floatingTopRowData;
this.floatingBottomRowData = gridOptions.floatingBottomRowData;
eventService.addGlobalListener(this.globalEventHandler.bind(this));
// set defaults
if (!this.rowHeight) {
this.rowHeight = DEFAULT_ROW_HEIGHT;
}
this.checkForDeprecated();
};
GridOptionsWrapper.prototype.isRowSelection = function () { return this.gridOptions.rowSelection === "single" || this.gridOptions.rowSelection === "multiple"; };
GridOptionsWrapper.prototype.isRowDeselection = function () { return isTrue(this.gridOptions.rowDeselection); };
GridOptionsWrapper.prototype.isRowSelectionMulti = function () { return this.gridOptions.rowSelection === 'multiple'; };
GridOptionsWrapper.prototype.getContext = function () { return this.gridOptions.context; };
GridOptionsWrapper.prototype.isVirtualPaging = function () { return isTrue(this.gridOptions.virtualPaging); };
GridOptionsWrapper.prototype.isShowToolPanel = function () { return isTrue(this.gridOptions.showToolPanel); };
GridOptionsWrapper.prototype.isToolPanelSuppressPivot = function () { return isTrue(this.gridOptions.toolPanelSuppressPivot); };
GridOptionsWrapper.prototype.isToolPanelSuppressValues = function () { return isTrue(this.gridOptions.toolPanelSuppressValues); };
GridOptionsWrapper.prototype.isRowsAlreadyGrouped = function () { return isTrue(this.gridOptions.rowsAlreadyGrouped); };
GridOptionsWrapper.prototype.isGroupSelectsChildren = function () { return isTrue(this.gridOptions.groupSelectsChildren); };
GridOptionsWrapper.prototype.isGroupHidePivotColumns = function () { return isTrue(this.gridOptions.groupHidePivotColumns); };
GridOptionsWrapper.prototype.isGroupIncludeFooter = function () { return isTrue(this.gridOptions.groupIncludeFooter); };
GridOptionsWrapper.prototype.isGroupSuppressBlankHeader = function () { return isTrue(this.gridOptions.groupSuppressBlankHeader); };
GridOptionsWrapper.prototype.isSuppressRowClickSelection = function () { return isTrue(this.gridOptions.suppressRowClickSelection); };
GridOptionsWrapper.prototype.isSuppressCellSelection = function () { return isTrue(this.gridOptions.suppressCellSelection); };
GridOptionsWrapper.prototype.isSuppressMultiSort = function () { return isTrue(this.gridOptions.suppressMultiSort); };
GridOptionsWrapper.prototype.isGroupSuppressAutoColumn = function () { return isTrue(this.gridOptions.groupSuppressAutoColumn); };
GridOptionsWrapper.prototype.isForPrint = function () { return isTrue(this.gridOptions.forPrint); };
GridOptionsWrapper.prototype.isSuppressHorizontalScroll = function () { return isTrue(this.gridOptions.suppressHorizontalScroll); };
GridOptionsWrapper.prototype.isUnSortIcon = function () { return isTrue(this.gridOptions.unSortIcon); };
GridOptionsWrapper.prototype.isSuppressMenuHide = function () { return isTrue(this.gridOptions.suppressMenuHide); };
GridOptionsWrapper.prototype.getRowStyle = function () { return this.gridOptions.rowStyle; };
GridOptionsWrapper.prototype.getRowClass = function () { return this.gridOptions.rowClass; };
GridOptionsWrapper.prototype.getRowStyleFunc = function () { return this.gridOptions.getRowStyle; };
GridOptionsWrapper.prototype.getRowClassFunc = function () { return this.gridOptions.getRowClass; };
GridOptionsWrapper.prototype.getHeaderCellRenderer = function () { return this.gridOptions.headerCellRenderer; };
GridOptionsWrapper.prototype.getApi = function () { return this.gridOptions.api; };
GridOptionsWrapper.prototype.isEnableColResize = function () { return isTrue(this.gridOptions.enableColResize); };
GridOptionsWrapper.prototype.isSingleClickEdit = function () { return isTrue(this.gridOptions.singleClickEdit); };
GridOptionsWrapper.prototype.getGroupDefaultExpanded = function () { return this.gridOptions.groupDefaultExpanded; };
GridOptionsWrapper.prototype.getGroupKeys = function () { return this.gridOptions.groupKeys; };
GridOptionsWrapper.prototype.getGroupAggFunction = function () { return this.gridOptions.groupAggFunction; };
GridOptionsWrapper.prototype.getGroupAggFields = function () { return this.gridOptions.groupAggFields; };
GridOptionsWrapper.prototype.getRowData = function () { return this.gridOptions.rowData; };
GridOptionsWrapper.prototype.isGroupUseEntireRow = function () { return isTrue(this.gridOptions.groupUseEntireRow); };
GridOptionsWrapper.prototype.getGroupColumnDef = function () { return this.gridOptions.groupColumnDef; };
GridOptionsWrapper.prototype.isGroupSuppressRow = function () { return isTrue(this.gridOptions.groupSuppressRow); };
GridOptionsWrapper.prototype.isAngularCompileRows = function () { return isTrue(this.gridOptions.angularCompileRows); };
GridOptionsWrapper.prototype.isAngularCompileFilters = function () { return isTrue(this.gridOptions.angularCompileFilters); };
GridOptionsWrapper.prototype.isAngularCompileHeaders = function () { return isTrue(this.gridOptions.angularCompileHeaders); };
GridOptionsWrapper.prototype.isDebug = function () { return isTrue(this.gridOptions.debug); };
GridOptionsWrapper.prototype.getColumnDefs = function () { return this.gridOptions.columnDefs; };
GridOptionsWrapper.prototype.getDatasource = function () { return this.gridOptions.datasource; };
GridOptionsWrapper.prototype.getRowBuffer = function () { return this.gridOptions.rowBuffer; };
GridOptionsWrapper.prototype.isEnableSorting = function () { return isTrue(this.gridOptions.enableSorting) || isTrue(this.gridOptions.enableServerSideSorting); };
GridOptionsWrapper.prototype.isEnableCellExpressions = function () { return isTrue(this.gridOptions.enableCellExpressions); };
GridOptionsWrapper.prototype.isEnableServerSideSorting = function () { return isTrue(this.gridOptions.enableServerSideSorting); };
GridOptionsWrapper.prototype.isEnableFilter = function () { return isTrue(this.gridOptions.enableFilter) || isTrue(this.gridOptions.enableServerSideFilter); };
GridOptionsWrapper.prototype.isEnableServerSideFilter = function () { return this.gridOptions.enableServerSideFilter; };
GridOptionsWrapper.prototype.isSuppressScrollLag = function () { return isTrue(this.gridOptions.suppressScrollLag); };
GridOptionsWrapper.prototype.getIcons = function () { return this.gridOptions.icons; };
GridOptionsWrapper.prototype.getIsScrollLag = function () { return this.gridOptions.isScrollLag; };
GridOptionsWrapper.prototype.getSortingOrder = function () { return this.gridOptions.sortingOrder; };
GridOptionsWrapper.prototype.getSlaveGrids = function () { return this.gridOptions.slaveGrids; };
GridOptionsWrapper.prototype.getGroupRowRenderer = function () { return this.gridOptions.groupRowRenderer; };
GridOptionsWrapper.prototype.getRowHeight = function () { return this.rowHeight; };
// properties
GridOptionsWrapper.prototype.getHeaderHeight = function () {
if (typeof this.headerHeight === 'number') {
return this.headerHeight;
}
else {
// otherwise return 25 if no grouping, 50 if grouping
if (this.groupHeaders) {
return 50;
}
else {
return 25;
}
}
};
GridOptionsWrapper.prototype.setHeaderHeight = function (headerHeight) { this.headerHeight = headerHeight; };
GridOptionsWrapper.prototype.isGroupHeaders = function () { return isTrue(this.groupHeaders); };
GridOptionsWrapper.prototype.setGroupHeaders = function (groupHeaders) { this.groupHeaders = groupHeaders; };
GridOptionsWrapper.prototype.getFloatingTopRowData = function () { return this.floatingTopRowData; };
GridOptionsWrapper.prototype.setFloatingTopRowData = function (rows) { this.floatingTopRowData = rows; };
GridOptionsWrapper.prototype.getFloatingBottomRowData = function () { return this.floatingBottomRowData; };
GridOptionsWrapper.prototype.setFloatingBottomRowData = function (rows) { this.floatingBottomRowData = rows; };
GridOptionsWrapper.prototype.isExternalFilterPresent = function () {
if (typeof this.gridOptions.isExternalFilterPresent === 'function') {
return this.gridOptions.isExternalFilterPresent();
}
else {
return false;
}
};
GridOptionsWrapper.prototype.doesExternalFilterPass = function (node) {
if (typeof this.gridOptions.doesExternalFilterPass === 'function') {
return this.gridOptions.doesExternalFilterPass(node);
}
else {
return false;
}
};
GridOptionsWrapper.prototype.getGroupRowInnerRenderer = function () {
return this.gridOptions.groupRowInnerRenderer;
};
GridOptionsWrapper.prototype.getColWidth = function () {
if (typeof this.gridOptions.colWidth !== 'number' || this.gridOptions.colWidth < constants.MIN_COL_WIDTH) {
return 200;
}
else {
return this.gridOptions.colWidth;
}
};
GridOptionsWrapper.prototype.checkForDeprecated = function () {
// casting to generic object, so typescript compiles even though
// we are looking for attributes that don't exist
var options = this.gridOptions;
if (options.suppressUnSort) {
console.warn('ag-grid: as of v1.12.4 suppressUnSort is not used. Please use sortOrder instead.');
}
if (options.suppressDescSort) {
console.warn('ag-grid: as of v1.12.4 suppressDescSort is not used. Please use sortOrder instead.');
}
};
GridOptionsWrapper.prototype.getPinnedColCount = function () {
// if not using scrolls, then pinned columns doesn't make
// sense, so always return 0
if (this.isForPrint()) {
return 0;
}
if (this.gridOptions.pinnedColumnCount) {
//in case user puts in a string, cast to number
return Number(this.gridOptions.pinnedColumnCount);
}
else {
return 0;
}
};
GridOptionsWrapper.prototype.getLocaleTextFunc = function () {
if (this.gridOptions.localeTextFunc) {
return this.gridOptions.localeTextFunc;
}
var that = this;
return function (key, defaultValue) {
var localeText = that.gridOptions.localeText;
if (localeText && localeText[key]) {
return localeText[key];
}
else {
return defaultValue;
}
};
};
// responsible for calling the onXXX functions on gridOptions
GridOptionsWrapper.prototype.globalEventHandler = function (eventName, event) {
var callbackMethodName = this.getCallbackForEvent(eventName);
if (typeof this.gridOptions[callbackMethodName] === 'function') {
this.gridOptions[callbackMethodName](event);
}
};
GridOptionsWrapper.prototype.getCallbackForEvent = function (eventName) {
if (!eventName || eventName.length < 2) {
return eventName;
}
else {
return 'on' + eventName[0].toUpperCase() + eventName.substr(1);
}
};
return GridOptionsWrapper;
})();
grid.GridOptionsWrapper = GridOptionsWrapper;
})(grid = ag.grid || (ag.grid = {}));
})(ag || (ag = {}));
var ag;
(function (ag) {
var grid;
(function (grid) {
var LoggerFactory = (function () {
function LoggerFactory() {
}
LoggerFactory.prototype.init = function (gridOptionsWrapper) {
this.logging = gridOptionsWrapper.isDebug();
};
LoggerFactory.prototype.create = function (name) {
return new Logger(name, this.logging);
};
return LoggerFactory;
})();
grid.LoggerFactory = LoggerFactory;
var Logger = (function () {
function Logger(name, logging) {
this.name = name;
this.logging = logging;
}
Logger.prototype.log = function (message) {
if (this.logging) {
console.log(this.name + " " + message);
}
};
return Logger;
})();
grid.Logger = Logger;
})(grid = ag.grid || (ag.grid = {}));
})(ag || (ag = {}));
var ag;
(function (ag) {
var grid;
(function (grid) {
var Events = (function () {
function Events() {
}
/** A new set of columns has been entered, everything has potentially changed. */
Events.EVENT_COLUMN_EVERYTHING_CHANGED = 'columnEverythingChanged';
/** A pivot column was added, removed or order changed. */
Events.EVENT_COLUMN_PIVOT_CHANGE = 'columnPivotChanged';
/** A value column was added, removed or agg function was changed. */
Events.EVENT_COLUMN_VALUE_CHANGE = 'columnValueChanged';
/** A column was moved */
Events.EVENT_COLUMN_MOVED = 'columnMoved';
/** One or more columns was shown / hidden */
Events.EVENT_COLUMN_VISIBLE = 'columnVisible';
/** A column group was opened / closed */
Events.EVENT_COLUMN_GROUP_OPENED = 'columnGroupOpened';
/** One or more columns was resized. If just one, the column in the event is set. */
Events.EVENT_COLUMN_RESIZED = 'columnResized';
/** One or more columns was resized. If just one, the column in the event is set. */
Events.EVENT_COLUMN_PINNED_COUNT_CHANGED = 'columnPinnedCountChanged';
Events.EVENT_MODEL_UPDATED = 'modelUpdated';
Events.EVENT_CELL_CLICKED = 'cellClicked';
Events.EVENT_CELL_DOUBLE_CLICKED = 'cellDoubleClicked';
Events.EVENT_CELL_CONTEXT_MENU = 'cellContextMenu';
Events.EVENT_CELL_VALUE_CHANGED = 'cellValueChanged';
Events.EVENT_CELL_FOCUSED = 'cellFocused';
Events.EVENT_ROW_SELECTED = 'rowSelected';
Events.EVENT_SELECTION_CHANGED = 'selectionChanged';
Events.EVENT_BEFORE_FILTER_CHANGED = 'beforeFilterChanged';
Events.EVENT_AFTER_FILTER_CHANGED = 'afterFilterChanged';
Events.EVENT_FILTER_MODIFIED = 'filterModified';
Events.EVENT_BEFORE_SORT_CHANGED = 'beforeSortChanged';
Events.EVENT_AFTER_SORT_CHANGED = 'afterSortChanged';
Events.EVENT_VIRTUAL_ROW_REMOVED = 'virtualRowRemoved';
Events.EVENT_ROW_CLICKED = 'rowClicked';
Events.EVENT_READY = 'ready';
return Events;
})();
grid.Events = Events;
})(grid = ag.grid || (ag.grid = {}));
})(ag || (ag = {}));
/// <reference path="utils.ts" />
var ag;
(function (ag) {
var grid;
(function (grid) {
var _ = grid.Utils;
var EventService = (function () {
function EventService() {
this.allListeners = {};
this.globalListeners = [];
}
EventService.prototype.getListenerList = function (eventType) {
var listenerList = this.allListeners[eventType];
if (!listenerList) {
listenerList = [];
this.allListeners[eventType] = listenerList;
}
return listenerList;
};
EventService.prototype.addEventListener = function (eventType, listener) {
var listenerList = this.getListenerList(eventType);
if (listenerList.indexOf(listener) < 0) {
listenerList.push(listener);
}
};
EventService.prototype.addGlobalListener = function (listener) {
this.globalListeners.push(listener);
};
EventService.prototype.removeEventListener = function (eventType, listener) {
var listenerList = this.getListenerList(eventType);
_.removeFromArray(listenerList, listener);
};
EventService.prototype.removeGlobalListener = function (listener) {
_.removeFromArray(this.globalListeners, listener);
};
EventService.prototype.dispatchEvent = function (eventType, event) {
if (!event) {
event = {};
}
var listenerList = this.getListenerList(eventType);
listenerList.forEach(function (listener) {
listener(event);
});
this.globalListeners.forEach(function (listener) {
listener(eventType, event);
});
};
return EventService;
})();
grid.EventService = EventService;
})(grid = ag.grid || (ag.grid = {}));
})(ag || (ag = {}));
/// <reference path="columnController.ts" />
/// <reference path="gridOptionsWrapper.ts" />
/// <reference path="logger.ts" />
/// <reference path="events.ts" />
/// <reference path="eventService.ts" />
var ag;
(function (ag) {
var grid;
(function (grid) {
var MasterSlaveService = (function () {
function MasterSlaveService() {
// flag to mark if we are consuming. to avoid cyclic events (ie slave firing back to master
// while processing a master event) we mark this if consuming an event, and if we are, then
// we don't fire back any events.
this.consuming = false;
}
MasterSlaveService.prototype.init = function (gridOptionsWrapper, columnController, gridPanel, loggerFactory, eventService) {
this.gridOptionsWrapper = gridOptionsWrapper;
this.columnController = columnController;
this.gridPanel = gridPanel;
this.eventService = eventService;
this.logger = loggerFactory.create('MasterSlaveService');
eventService.addEventListener(grid.Events.EVENT_COLUMN_MOVED, this.fireColumnEvent.bind(this));
eventService.addEventListener(grid.Events.EVENT_COLUMN_VISIBLE, this.fireColumnEvent.bind(this));
eventService.addEventListener(grid.Events.EVENT_COLUMN_GROUP_OPENED, this.fireColumnEvent.bind(this));
eventService.addEventListener(grid.Events.EVENT_COLUMN_RESIZED, this.fireColumnEvent.bind(this));
eventService.addEventListener(grid.Events.EVENT_COLUMN_PINNED_COUNT_CHANGED, this.fireColumnEvent.bind(this));
};
// common logic across all the fire methods
MasterSlaveService.prototype.fireEvent = function (callback) {
// if we are already consuming, then we are acting on an event from a master,
// so we don't cause a cyclic firing of events
if (this.consuming) {
return;
}
// iterate through the slave grids, and pass each slave service to the callback
var slaveGrids = this.gridOptionsWrapper.getSlaveGrids();
if (slaveGrids) {
slaveGrids.forEach(function (slaveGridOptions) {
if (slaveGridOptions.api) {
var slaveService = slaveGridOptions.api.__getMasterSlaveService();
callback(slaveService);
}
});
}
};
// common logic across all consume methods. very little common logic, however extracting
// guarantees consistency across the methods.
MasterSlaveService.prototype.onEvent = function (callback) {
this.consuming = true;
callback();
this.consuming = false;
};
MasterSlaveService.prototype.fireColumnEvent = function (event) {
this.fireEvent(function (slaveService) {
slaveService.onColumnEvent(event);
});
};
MasterSlaveService.prototype.fireHorizontalScrollEvent = function (horizontalScroll) {
this.fireEvent(function (slaveService) {
slaveService.onScrollEvent(horizontalScroll);
});
};
MasterSlaveService.prototype.onScrollEvent = function (horizontalScroll) {
var _this = this;
this.onEvent(function () {
_this.gridPanel.setHorizontalScrollPosition(horizontalScroll);
});
};
MasterSlaveService.prototype.onColumnEvent = function (event) {
var _this = this;
this.onEvent(function () {
// the column in the even is from the master grid. need to
// look up the eq