ag-grid-community
Version:
Advanced Data Grid / Data Table supporting Javascript / Typescript / React / Angular / Vue
1,201 lines (1,188 loc) • 2.89 MB
JavaScript
/**
* ag-grid-community - Advanced Data Grid / Data Table supporting Javascript / Typescript / React / Angular / Vue * @version v31.1.1
* @link https://www.ag-grid.com/
' * @license MIT
*/
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
/**
* If value is undefined, null or blank, returns null, otherwise returns the value
* @param {T} value
* @returns {T | null}
*/
function makeNull(value) {
if (value == null || value === '') {
return null;
}
return value;
}
function exists(value, allowEmptyString) {
if (allowEmptyString === void 0) { allowEmptyString = false; }
return value != null && (value !== '' || allowEmptyString);
}
function missing(value) {
return !exists(value);
}
function missingOrEmpty(value) {
return value == null || value.length === 0;
}
function toStringOrNull(value) {
return value != null && typeof value.toString === 'function' ? value.toString() : null;
}
// for parsing html attributes, where we want empty strings and missing attributes to be undefined
function attrToNumber(value) {
if (value === undefined) {
// undefined or empty means ignore the value
return;
}
if (value === null || value === '') {
// null or blank means clear
return null;
}
if (typeof value === 'number') {
return isNaN(value) ? undefined : value;
}
var valueParsed = parseInt(value, 10);
return isNaN(valueParsed) ? undefined : valueParsed;
}
// for parsing html attributes, where we want empty strings and missing attributes to be undefined
function attrToBoolean(value) {
if (value === undefined) {
// undefined or empty means ignore the value
return;
}
if (value === null || value === '') {
// null means clear
return false;
}
if (typeof value === 'boolean') {
// if simple boolean, return the boolean
return value;
}
// if equal to the string 'true' (ignoring case) then return true
return (/true/i).test(value);
}
// for parsing html attributes, where we want empty strings and missing attributes to be undefined
function attrToString(value) {
if (value == null || value === '') {
return;
}
return value;
}
function jsonEquals(val1, val2) {
var val1Json = val1 ? JSON.stringify(val1) : null;
var val2Json = val2 ? JSON.stringify(val2) : null;
return val1Json === val2Json;
}
function defaultComparator(valueA, valueB, accentedCompare) {
if (accentedCompare === void 0) { accentedCompare = false; }
var valueAMissing = valueA == null;
var valueBMissing = valueB == null;
// this is for aggregations sum and avg, where the result can be a number that is wrapped.
// if we didn't do this, then the toString() value would be used, which would result in
// the strings getting used instead of the numbers.
if (valueA && valueA.toNumber) {
valueA = valueA.toNumber();
}
if (valueB && valueB.toNumber) {
valueB = valueB.toNumber();
}
if (valueAMissing && valueBMissing) {
return 0;
}
if (valueAMissing) {
return -1;
}
if (valueBMissing) {
return 1;
}
function doQuickCompare(a, b) {
return (a > b ? 1 : (a < b ? -1 : 0));
}
if (typeof valueA !== 'string') {
return doQuickCompare(valueA, valueB);
}
if (!accentedCompare) {
return doQuickCompare(valueA, valueB);
}
try {
// using local compare also allows chinese comparisons
return valueA.localeCompare(valueB);
}
catch (e) {
// if something wrong with localeCompare, eg not supported
// by browser, then just continue with the quick one
return doQuickCompare(valueA, valueB);
}
}
function values(object) {
if (object instanceof Set || object instanceof Map) {
var arr_1 = [];
object.forEach(function (value) { return arr_1.push(value); });
return arr_1;
}
return Object.values(object);
}
var GenericUtils = /*#__PURE__*/Object.freeze({
makeNull: makeNull,
exists: exists,
missing: missing,
missingOrEmpty: missingOrEmpty,
toStringOrNull: toStringOrNull,
attrToNumber: attrToNumber,
attrToBoolean: attrToBoolean,
attrToString: attrToString,
jsonEquals: jsonEquals,
defaultComparator: defaultComparator,
values: values
});
// class returns a unique id to use for the column. it checks the existing columns, and if the requested
var ColumnKeyCreator = /** @class */ (function () {
function ColumnKeyCreator() {
this.existingKeys = {};
}
ColumnKeyCreator.prototype.addExistingKeys = function (keys) {
for (var i = 0; i < keys.length; i++) {
this.existingKeys[keys[i]] = true;
}
};
ColumnKeyCreator.prototype.getUniqueKey = function (colId, colField) {
// in case user passed in number for colId, convert to string
colId = toStringOrNull(colId);
var count = 0;
while (true) {
var idToTry = void 0;
if (colId) {
idToTry = colId;
if (count !== 0) {
idToTry += '_' + count;
}
}
else if (colField) {
idToTry = colField;
if (count !== 0) {
idToTry += '_' + count;
}
}
else {
// no point in stringing this, object treats it the same anyway.
idToTry = count;
}
if (!this.existingKeys[idToTry]) {
this.existingKeys[idToTry] = true;
return String(idToTry);
}
count++;
}
};
return ColumnKeyCreator;
}());
var __values = (undefined && undefined.__values) || function(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
var __read = (undefined && undefined.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
function iterateObject(object, callback) {
var e_1, _a;
if (object == null) {
return;
}
if (Array.isArray(object)) {
for (var i = 0; i < object.length; i++) {
callback(i.toString(), object[i]);
}
return;
}
try {
for (var _b = __values(Object.entries(object)), _c = _b.next(); !_c.done; _c = _b.next()) {
var _d = __read(_c.value, 2), key = _d[0], value = _d[1];
callback(key, value);
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_1) throw e_1.error; }
}
}
function cloneObject(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;
}
// returns copy of an object, doing a deep clone of any objects with that object.
// this is used for eg creating copies of Column Definitions, where we want to
// deep copy all objects, but do not want to deep copy functions (eg when user provides
// a function or class for colDef.cellRenderer)
function deepCloneDefinition(object, keysToSkip) {
if (!object) {
return;
}
var obj = object;
var res = {};
Object.keys(obj).forEach(function (key) {
if (keysToSkip && keysToSkip.indexOf(key) >= 0) {
return;
}
var value = obj[key];
// 'simple object' means a bunch of key/value pairs, eg {filter: 'myFilter'}. it does
// NOT include the following:
// 1) arrays
// 2) functions or classes (eg ColumnAPI instance)
var sourceIsSimpleObject = isNonNullObject(value) && value.constructor === Object;
if (sourceIsSimpleObject) {
res[key] = deepCloneDefinition(value);
}
else {
res[key] = value;
}
});
return res;
}
function getAllValuesInObject(obj) {
if (!obj) {
return [];
}
var anyObject = Object;
if (typeof anyObject.values === 'function') {
return anyObject.values(obj);
}
var ret = [];
for (var key in obj) {
if (obj.hasOwnProperty(key) && obj.propertyIsEnumerable(key)) {
ret.push(obj[key]);
}
}
return ret;
}
function mergeDeep(dest, source, copyUndefined, makeCopyOfSimpleObjects) {
if (copyUndefined === void 0) { copyUndefined = true; }
if (makeCopyOfSimpleObjects === void 0) { makeCopyOfSimpleObjects = false; }
if (!exists(source)) {
return;
}
iterateObject(source, function (key, sourceValue) {
var destValue = dest[key];
if (destValue === sourceValue) {
return;
}
// when creating params, we don't want to just copy objects over. otherwise merging ColDefs (eg DefaultColDef
// and Column Types) would result in params getting shared between objects.
// by putting an empty value into destValue first, it means we end up copying over values from
// the source object, rather than just copying in the source object in it's entirety.
if (makeCopyOfSimpleObjects) {
var objectIsDueToBeCopied = destValue == null && sourceValue != null;
if (objectIsDueToBeCopied) {
// 'simple object' means a bunch of key/value pairs, eg {filter: 'myFilter'}, as opposed
// to a Class instance (such as ColumnAPI instance).
var sourceIsSimpleObject = typeof sourceValue === 'object' && sourceValue.constructor === Object;
var dontCopy = sourceIsSimpleObject;
if (dontCopy) {
destValue = {};
dest[key] = destValue;
}
}
}
if (isNonNullObject(sourceValue) && isNonNullObject(destValue) && !Array.isArray(destValue)) {
mergeDeep(destValue, sourceValue, copyUndefined, makeCopyOfSimpleObjects);
}
else if (copyUndefined || sourceValue !== undefined) {
dest[key] = sourceValue;
}
});
}
function getValueUsingField(data, field, fieldContainsDots) {
if (!field || !data) {
return;
}
// if no '.', then it's not a deep value
if (!fieldContainsDots) {
return data[field];
}
// otherwise it is a deep value, so need to dig for it
var fields = field.split('.');
var currentObject = data;
for (var i = 0; i < fields.length; i++) {
if (currentObject == null) {
return undefined;
}
currentObject = currentObject[fields[i]];
}
return currentObject;
}
// used by GridAPI to remove all references, so keeping grid in memory resulting in a
// memory leak if user is not disposing of the GridAPI references
function removeAllReferences(obj, preserveKeys, preDestroyLink) {
if (preserveKeys === void 0) { preserveKeys = []; }
Object.keys(obj).forEach(function (key) {
var value = obj[key];
// we want to replace all the @autowired services, which are objects. any simple types (boolean, string etc)
// we don't care about
if (typeof value === 'object' && !preserveKeys.includes(key)) {
obj[key] = undefined;
}
});
var proto = Object.getPrototypeOf(obj);
var properties = {};
var msgFunc = function (key) {
return "AG Grid: Grid API function ".concat(key, "() cannot be called as the grid has been destroyed.\n It is recommended to remove local references to the grid api. Alternatively, check gridApi.isDestroyed() to avoid calling methods against a destroyed grid.\n To run logic when the grid is about to be destroyed use the gridPreDestroy event. See: ").concat(preDestroyLink);
};
Object.getOwnPropertyNames(proto).forEach(function (key) {
var value = proto[key];
// leave all basic types and preserveKeys this is needed for GridAPI to leave the "destroyed: boolean" attribute and isDestroyed() function.
if (typeof value === 'function' && !preserveKeys.includes(key)) {
var func = function () {
console.warn(msgFunc(key));
};
properties[key] = { value: func, writable: true };
}
});
Object.defineProperties(obj, properties);
}
function isNonNullObject(value) {
return typeof value === 'object' && value !== null;
}
var ObjectUtils = /*#__PURE__*/Object.freeze({
iterateObject: iterateObject,
cloneObject: cloneObject,
deepCloneDefinition: deepCloneDefinition,
getAllValuesInObject: getAllValuesInObject,
mergeDeep: mergeDeep,
getValueUsingField: getValueUsingField,
removeAllReferences: removeAllReferences,
isNonNullObject: isNonNullObject
});
var doOnceFlags = {};
/**
* If the key was passed before, then doesn't execute the func
* @param {Function} func
* @param {string} key
*/
function doOnce(func, key) {
if (doOnceFlags[key]) {
return;
}
func();
doOnceFlags[key] = true;
}
function warnOnce(msg) {
doOnce(function () { return console.warn("AG Grid: " + msg); }, msg);
}
function errorOnce(msg) {
doOnce(function () { return console.error("AG Grid: " + msg); }, msg);
}
function getFunctionName(funcConstructor) {
// for every other browser in the world
if (funcConstructor.name) {
return funcConstructor.name;
}
// for the pestilence that is ie11
var matches = /function\s+([^\(]+)/.exec(funcConstructor.toString());
return matches && matches.length === 2 ? matches[1].trim() : null;
}
function isFunction(val) {
return !!(val && val.constructor && val.call && val.apply);
}
function executeInAWhile(funcs) {
executeAfter(funcs, 400);
}
var executeNextVMTurnFuncs = [];
var executeNextVMTurnPending = false;
function executeNextVMTurn(func) {
executeNextVMTurnFuncs.push(func);
if (executeNextVMTurnPending) {
return;
}
executeNextVMTurnPending = true;
window.setTimeout(function () {
var funcsCopy = executeNextVMTurnFuncs.slice();
executeNextVMTurnFuncs.length = 0;
executeNextVMTurnPending = false;
funcsCopy.forEach(function (func) { return func(); });
}, 0);
}
function executeAfter(funcs, milliseconds) {
if (milliseconds === void 0) { milliseconds = 0; }
if (funcs.length > 0) {
window.setTimeout(function () { return funcs.forEach(function (func) { return func(); }); }, milliseconds);
}
}
/**
* @param {Function} func The function to be debounced
* @param {number} delay The time in ms to debounce
* @return {Function} The debounced function
*/
function debounce(func, delay) {
var timeout;
// Calling debounce returns a new anonymous function
return function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var context = this;
window.clearTimeout(timeout);
// Set the new timeout
timeout = window.setTimeout(function () {
func.apply(context, args);
}, delay);
};
}
/**
* @param {Function} func The function to be throttled
* @param {number} wait The time in ms to throttle
* @return {Function} The throttled function
*/
function throttle(func, wait) {
var previousCall = 0;
return function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var context = this;
var currentCall = new Date().getTime();
if (currentCall - previousCall < wait) {
return;
}
previousCall = currentCall;
func.apply(context, args);
};
}
function waitUntil(condition, callback, timeout, timeoutMessage) {
if (timeout === void 0) { timeout = 100; }
var timeStamp = new Date().getTime();
var interval = null;
var executed = false;
var internalCallback = function () {
var reachedTimeout = ((new Date().getTime()) - timeStamp) > timeout;
if (condition() || reachedTimeout) {
callback();
executed = true;
if (interval != null) {
window.clearInterval(interval);
interval = null;
}
if (reachedTimeout && timeoutMessage) {
console.warn(timeoutMessage);
}
}
};
internalCallback();
if (!executed) {
interval = window.setInterval(internalCallback, 10);
}
}
function compose() {
var fns = [];
for (var _i = 0; _i < arguments.length; _i++) {
fns[_i] = arguments[_i];
}
return function (arg) { return fns.reduce(function (composed, f) { return f(composed); }, arg); };
}
var noop = function () { return; };
var FunctionUtils = /*#__PURE__*/Object.freeze({
doOnce: doOnce,
warnOnce: warnOnce,
errorOnce: errorOnce,
getFunctionName: getFunctionName,
isFunction: isFunction,
executeInAWhile: executeInAWhile,
executeNextVMTurn: executeNextVMTurn,
executeAfter: executeAfter,
debounce: debounce,
throttle: throttle,
waitUntil: waitUntil,
compose: compose,
noop: noop
});
(function (ModuleNames) {
ModuleNames["CommunityCoreModule"] = "@ag-grid-community/core";
// community modules
ModuleNames["InfiniteRowModelModule"] = "@ag-grid-community/infinite-row-model";
ModuleNames["ClientSideRowModelModule"] = "@ag-grid-community/client-side-row-model";
ModuleNames["CsvExportModule"] = "@ag-grid-community/csv-export";
// enterprise core - users don't need to import on this, but other enterprise modules do
ModuleNames["EnterpriseCoreModule"] = "@ag-grid-enterprise/core";
// enterprise modules
ModuleNames["RowGroupingModule"] = "@ag-grid-enterprise/row-grouping";
ModuleNames["ColumnsToolPanelModule"] = "@ag-grid-enterprise/column-tool-panel";
ModuleNames["FiltersToolPanelModule"] = "@ag-grid-enterprise/filter-tool-panel";
ModuleNames["MenuModule"] = "@ag-grid-enterprise/menu";
ModuleNames["SetFilterModule"] = "@ag-grid-enterprise/set-filter";
ModuleNames["MultiFilterModule"] = "@ag-grid-enterprise/multi-filter";
ModuleNames["StatusBarModule"] = "@ag-grid-enterprise/status-bar";
ModuleNames["SideBarModule"] = "@ag-grid-enterprise/side-bar";
ModuleNames["RangeSelectionModule"] = "@ag-grid-enterprise/range-selection";
ModuleNames["MasterDetailModule"] = "@ag-grid-enterprise/master-detail";
ModuleNames["RichSelectModule"] = "@ag-grid-enterprise/rich-select";
ModuleNames["GridChartsModule"] = "@ag-grid-enterprise/charts";
ModuleNames["ViewportRowModelModule"] = "@ag-grid-enterprise/viewport-row-model";
ModuleNames["ServerSideRowModelModule"] = "@ag-grid-enterprise/server-side-row-model";
ModuleNames["ExcelExportModule"] = "@ag-grid-enterprise/excel-export";
ModuleNames["ClipboardModule"] = "@ag-grid-enterprise/clipboard";
ModuleNames["SparklinesModule"] = "@ag-grid-enterprise/sparklines";
ModuleNames["AdvancedFilterModule"] = "@ag-grid-enterprise/advanced-filter";
// framework wrappers currently don't provide beans, comps etc, so no need to be modules,
// however i argue they should be as in theory they 'could' provide beans etc
ModuleNames["AngularModule"] = "@ag-grid-community/angular";
ModuleNames["ReactModule"] = "@ag-grid-community/react";
ModuleNames["VueModule"] = "@ag-grid-community/vue";
// and then this, which is definitely not a grid module, as it should not have any dependency
// on the grid (ie shouldn't even reference the Module interface)
// ChartsModule = "@ag-grid-community/charts-core",
})(exports.ModuleNames || (exports.ModuleNames = {}));
var __read$1 = (undefined && undefined.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
var __spreadArray = (undefined && undefined.__spreadArray) || function (to, from, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
};
var ModuleRegistry = /** @class */ (function () {
function ModuleRegistry() {
}
/**
* Globally register the given module for all grids.
* @param module - module to register
*/
ModuleRegistry.register = function (module) {
ModuleRegistry.__register(module, true, undefined);
};
/**
* Globally register the given modules for all grids.
* @param modules - modules to register
*/
ModuleRegistry.registerModules = function (modules) {
ModuleRegistry.__registerModules(modules, true, undefined);
};
/** AG GRID INTERNAL - Module registration helper. */
ModuleRegistry.__register = function (module, moduleBased, gridId) {
ModuleRegistry.runVersionChecks(module);
if (gridId !== undefined) {
ModuleRegistry.areGridScopedModules = true;
if (ModuleRegistry.gridModulesMap[gridId] === undefined) {
ModuleRegistry.gridModulesMap[gridId] = {};
}
ModuleRegistry.gridModulesMap[gridId][module.moduleName] = module;
}
else {
ModuleRegistry.globalModulesMap[module.moduleName] = module;
}
ModuleRegistry.setModuleBased(moduleBased);
};
/** AG GRID INTERNAL - Unregister grid scoped module. */
ModuleRegistry.__unRegisterGridModules = function (gridId) {
delete ModuleRegistry.gridModulesMap[gridId];
};
/** AG GRID INTERNAL - Module registration helper. */
ModuleRegistry.__registerModules = function (modules, moduleBased, gridId) {
ModuleRegistry.setModuleBased(moduleBased);
if (!modules) {
return;
}
modules.forEach(function (module) { return ModuleRegistry.__register(module, moduleBased, gridId); });
};
ModuleRegistry.isValidModuleVersion = function (module) {
var _a = __read$1(module.version.split('.') || [], 2), moduleMajor = _a[0], moduleMinor = _a[1];
var _b = __read$1(ModuleRegistry.currentModuleVersion.split('.') || [], 2), currentModuleMajor = _b[0], currentModuleMinor = _b[1];
return moduleMajor === currentModuleMajor && moduleMinor === currentModuleMinor;
};
ModuleRegistry.runVersionChecks = function (module) {
if (!ModuleRegistry.currentModuleVersion) {
ModuleRegistry.currentModuleVersion = module.version;
}
if (!module.version) {
console.error("AG Grid: You are using incompatible versions of AG Grid modules. Major and minor versions should always match across modules. '".concat(module.moduleName, "' is incompatible. Please update all modules to the same version."));
}
else if (!ModuleRegistry.isValidModuleVersion(module)) {
console.error("AG Grid: You are using incompatible versions of AG Grid modules. Major and minor versions should always match across modules. '".concat(module.moduleName, "' is version ").concat(module.version, " but the other modules are version ").concat(this.currentModuleVersion, ". Please update all modules to the same version."));
}
if (module.validate) {
var result = module.validate();
if (!result.isValid) {
var errorResult = result;
console.error("AG Grid: ".concat(errorResult.message));
}
}
};
ModuleRegistry.setModuleBased = function (moduleBased) {
if (ModuleRegistry.moduleBased === undefined) {
ModuleRegistry.moduleBased = moduleBased;
}
else {
if (ModuleRegistry.moduleBased !== moduleBased) {
doOnce(function () {
console.warn("AG Grid: You are mixing modules (i.e. @ag-grid-community/core) and packages (ag-grid-community) - you can only use one or the other of these mechanisms.");
console.warn('Please see https://www.ag-grid.com/javascript-grid/packages-modules/ for more information.');
}, 'ModulePackageCheck');
}
}
};
/**
* AG GRID INTERNAL - Set if files are being served from a single UMD bundle to provide accurate enterprise upgrade steps.
*/
ModuleRegistry.__setIsBundled = function () {
ModuleRegistry.isBundled = true;
};
/** AG GRID INTERNAL - Assert a given module has been register, globally or individually with this grid. */
ModuleRegistry.__assertRegistered = function (moduleName, reason, gridId) {
var _a;
if (this.__isRegistered(moduleName, gridId)) {
return true;
}
var warningKey = reason + moduleName;
var warningMessage;
if (ModuleRegistry.isBundled) {
{
warningMessage =
"AG Grid: unable to use ".concat(reason, " as 'ag-grid-enterprise' has not been loaded. Check you are using the Enterprise bundle:\n \n <script src=\"https://cdn.jsdelivr.net/npm/ag-grid-enterprise@AG_GRID_VERSION/dist/ag-grid-enterprise.min.js\"></script>\n \nFor more info see: https://ag-grid.com/javascript-data-grid/getting-started/#getting-started-with-ag-grid-enterprise");
}
}
else if (ModuleRegistry.moduleBased || ModuleRegistry.moduleBased === undefined) {
var modName = (_a = Object.entries(exports.ModuleNames).find(function (_a) {
var _b = __read$1(_a, 2), k = _b[0], v = _b[1];
return v === moduleName;
})) === null || _a === void 0 ? void 0 : _a[0];
warningMessage =
"AG Grid: unable to use ".concat(reason, " as the ").concat(modName, " is not registered").concat(ModuleRegistry.areGridScopedModules ? " for gridId: ".concat(gridId) : '', ". Check if you have registered the module:\n \n import { ModuleRegistry } from '@ag-grid-community/core';\n import { ").concat(modName, " } from '").concat(moduleName, "';\n \n ModuleRegistry.registerModules([ ").concat(modName, " ]);\n\nFor more info see: https://www.ag-grid.com/javascript-grid/modules/");
}
else {
warningMessage =
"AG Grid: unable to use ".concat(reason, " as package 'ag-grid-enterprise' has not been imported. Check that you have imported the package:\n \n import 'ag-grid-enterprise';\n \nFor more info see: https://www.ag-grid.com/javascript-grid/packages/");
}
doOnce(function () {
console.warn(warningMessage);
}, warningKey);
return false;
};
/**
* AG GRID INTERNAL - Warn that a given integrated chart type is not supported under the community distribution.
*/
ModuleRegistry.__warnEnterpriseChartDisabled = function (chartType) {
var reason = 'ag-charts-enterprise';
var warningKey = reason + ':' + chartType;
var url = 'https://ag-grid.com/javascript-data-grid/integrated-charts/';
var warningMessage = "AG Grid: the '".concat(chartType, "' chart type is not supported in AG Charts Community. See ").concat(url, " for more details.");
doOnce(function () {
console.warn(warningMessage);
}, warningKey);
};
/** AG GRID INTERNAL - Is the given module registered, globally or individually with this grid. */
ModuleRegistry.__isRegistered = function (moduleName, gridId) {
var _a;
return !!ModuleRegistry.globalModulesMap[moduleName] || !!((_a = ModuleRegistry.gridModulesMap[gridId]) === null || _a === void 0 ? void 0 : _a[moduleName]);
};
/** AG GRID INTERNAL - Get all registered modules globally / individually for this grid. */
ModuleRegistry.__getRegisteredModules = function (gridId) {
return __spreadArray(__spreadArray([], __read$1(values(ModuleRegistry.globalModulesMap)), false), __read$1(values(ModuleRegistry.gridModulesMap[gridId] || {})), false);
};
/** AG GRID INTERNAL - Get the list of modules registered individually for this grid. */
ModuleRegistry.__getGridRegisteredModules = function (gridId) {
var _a;
return values((_a = ModuleRegistry.gridModulesMap[gridId]) !== null && _a !== void 0 ? _a : {}) || [];
};
/** INTERNAL */
ModuleRegistry.__isPackageBased = function () {
return !ModuleRegistry.moduleBased;
};
// having in a map a) removes duplicates and b) allows fast lookup
ModuleRegistry.globalModulesMap = {};
ModuleRegistry.gridModulesMap = {};
ModuleRegistry.areGridScopedModules = false;
return ModuleRegistry;
}());
var __read$2 = (undefined && undefined.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
var __spreadArray$1 = (undefined && undefined.__spreadArray) || function (to, from, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
};
var Context = /** @class */ (function () {
function Context(params, logger) {
this.beanWrappers = {};
this.destroyed = false;
if (!params || !params.beanClasses) {
return;
}
this.contextParams = params;
this.logger = logger;
this.logger.log(">> creating ag-Application Context");
this.createBeans();
var beanInstances = this.getBeanInstances();
this.wireBeans(beanInstances);
this.logger.log(">> ag-Application Context ready - component is alive");
}
Context.prototype.getBeanInstances = function () {
return values(this.beanWrappers).map(function (beanEntry) { return beanEntry.beanInstance; });
};
Context.prototype.createBean = function (bean, afterPreCreateCallback) {
if (!bean) {
throw Error("Can't wire to bean since it is null");
}
this.wireBeans([bean], afterPreCreateCallback);
return bean;
};
Context.prototype.wireBeans = function (beanInstances, afterPreCreateCallback) {
this.autoWireBeans(beanInstances);
this.methodWireBeans(beanInstances);
this.callLifeCycleMethods(beanInstances, 'preConstructMethods');
// the callback sets the attributes, so the component has access to attributes
// before postConstruct methods in the component are executed
if (exists(afterPreCreateCallback)) {
beanInstances.forEach(afterPreCreateCallback);
}
this.callLifeCycleMethods(beanInstances, 'postConstructMethods');
};
Context.prototype.createBeans = function () {
var _this = this;
// register all normal beans
this.contextParams.beanClasses.forEach(this.createBeanWrapper.bind(this));
// register override beans, these will overwrite beans above of same name
// instantiate all beans - overridden beans will be left out
iterateObject(this.beanWrappers, function (key, beanEntry) {
var constructorParamsMeta;
if (beanEntry.bean.__agBeanMetaData && beanEntry.bean.__agBeanMetaData.autowireMethods && beanEntry.bean.__agBeanMetaData.autowireMethods.agConstructor) {
constructorParamsMeta = beanEntry.bean.__agBeanMetaData.autowireMethods.agConstructor;
}
var constructorParams = _this.getBeansForParameters(constructorParamsMeta, beanEntry.bean.name);
var newInstance = new (beanEntry.bean.bind.apply(beanEntry.bean, __spreadArray$1([null], __read$2(constructorParams), false)));
beanEntry.beanInstance = newInstance;
});
var createdBeanNames = Object.keys(this.beanWrappers).join(', ');
this.logger.log("created beans: ".concat(createdBeanNames));
};
// tslint:disable-next-line
Context.prototype.createBeanWrapper = function (BeanClass) {
var metaData = BeanClass.__agBeanMetaData;
if (!metaData) {
var beanName = void 0;
if (BeanClass.prototype.constructor) {
beanName = getFunctionName(BeanClass.prototype.constructor);
}
else {
beanName = "" + BeanClass;
}
console.error("Context item ".concat(beanName, " is not a bean"));
return;
}
var beanEntry = {
bean: BeanClass,
beanInstance: null,
beanName: metaData.beanName
};
this.beanWrappers[metaData.beanName] = beanEntry;
};
Context.prototype.autoWireBeans = function (beanInstances) {
var _this = this;
beanInstances.forEach(function (beanInstance) {
_this.forEachMetaDataInHierarchy(beanInstance, function (metaData, beanName) {
var attributes = metaData.agClassAttributes;
if (!attributes) {
return;
}
attributes.forEach(function (attribute) {
var otherBean = _this.lookupBeanInstance(beanName, attribute.beanName, attribute.optional);
beanInstance[attribute.attributeName] = otherBean;
});
});
});
};
Context.prototype.methodWireBeans = function (beanInstances) {
var _this = this;
beanInstances.forEach(function (beanInstance) {
_this.forEachMetaDataInHierarchy(beanInstance, function (metaData, beanName) {
iterateObject(metaData.autowireMethods, function (methodName, wireParams) {
// skip constructor, as this is dealt with elsewhere
if (methodName === "agConstructor") {
return;
}
var initParams = _this.getBeansForParameters(wireParams, beanName);
beanInstance[methodName].apply(beanInstance, initParams);
});
});
});
};
Context.prototype.forEachMetaDataInHierarchy = function (beanInstance, callback) {
var prototype = Object.getPrototypeOf(beanInstance);
while (prototype != null) {
var constructor = prototype.constructor;
if (constructor.hasOwnProperty('__agBeanMetaData')) {
var metaData = constructor.__agBeanMetaData;
var beanName = this.getBeanName(constructor);
callback(metaData, beanName);
}
prototype = Object.getPrototypeOf(prototype);
}
};
Context.prototype.getBeanName = function (constructor) {
if (constructor.__agBeanMetaData && constructor.__agBeanMetaData.beanName) {
return constructor.__agBeanMetaData.beanName;
}
var constructorString = constructor.toString();
var beanName = constructorString.substring(9, constructorString.indexOf("("));
return beanName;
};
Context.prototype.getBeansForParameters = function (parameters, beanName) {
var _this = this;
var beansList = [];
if (parameters) {
iterateObject(parameters, function (paramIndex, otherBeanName) {
var otherBean = _this.lookupBeanInstance(beanName, otherBeanName);
beansList[Number(paramIndex)] = otherBean;
});
}
return beansList;
};
Context.prototype.lookupBeanInstance = function (wiringBean, beanName, optional) {
if (optional === void 0) { optional = false; }
if (this.destroyed) {
this.logger.log("AG Grid: bean reference ".concat(beanName, " is used after the grid is destroyed!"));
return null;
}
if (beanName === "context") {
return this;
}
if (this.contextParams.providedBeanInstances && this.contextParams.providedBeanInstances.hasOwnProperty(beanName)) {
return this.contextParams.providedBeanInstances[beanName];
}
var beanEntry = this.beanWrappers[beanName];
if (beanEntry) {
return beanEntry.beanInstance;
}
if (!optional) {
console.error("AG Grid: unable to find bean reference ".concat(beanName, " while initialising ").concat(wiringBean));
}
return null;
};
Context.prototype.callLifeCycleMethods = function (beanInstances, lifeCycleMethod) {
var _this = this;
beanInstances.forEach(function (beanInstance) { return _this.callLifeCycleMethodsOnBean(beanInstance, lifeCycleMethod); });
};
Context.prototype.callLifeCycleMethodsOnBean = function (beanInstance, lifeCycleMethod, methodToIgnore) {
// putting all methods into a map removes duplicates
var allMethods = {};
// dump methods from each level of the metadata hierarchy
this.forEachMetaDataInHierarchy(beanInstance, function (metaData) {
var methods = metaData[lifeCycleMethod];
if (methods) {
methods.forEach(function (methodName) {
if (methodName != methodToIgnore) {
allMethods[methodName] = true;
}
});
}
});
var allMethodsList = Object.keys(allMethods);
allMethodsList.forEach(function (methodName) { return beanInstance[methodName](); });
};
Context.prototype.getBean = function (name) {
return this.lookupBeanInstance("getBean", name, true);
};
Context.prototype.destroy = function () {
if (this.destroyed) {
return;
}
// Set before doing the destroy, so if context.destroy() gets called via another bean
// we are marked as destroyed already to prevent running destroy() twice
this.destroyed = true;
this.logger.log(">> Shutting down ag-Application Context");
var beanInstances = this.getBeanInstances();
this.destroyBeans(beanInstances);
this.contextParams.providedBeanInstances = null;
ModuleRegistry.__unRegisterGridModules(this.contextParams.gridId);
this.logger.log(">> ag-Application Context shut down - component is dead");
};
Context.prototype.destroyBean = function (bean) {
if (!bean) {
return;
}
this.destroyBeans([bean]);
};
Context.prototype.destroyBeans = function (beans) {
var _this = this;
if (!beans) {
return [];
}
beans.forEach(function (bean) {
_this.callLifeCycleMethodsOnBean(bean, 'preDestroyMethods', 'destroy');
// call destroy() explicitly if it exists
var beanAny = bean;
if (typeof beanAny.destroy === 'function') {
beanAny.destroy();
}
});
return [];
};
Context.prototype.isDestroyed = function () {
return this.destroyed;
};
Context.prototype.getGridId = function () {
return this.contextParams.gridId;
};
return Context;
}());
function PreConstruct(target, methodName, descriptor) {
var props = getOrCreateProps(target.constructor);
if (!props.preConstructMethods) {
props.preConstructMethods = [];
}
props.preConstructMethods.push(methodName);
}
function PostConstruct(target, methodName, descriptor) {
var props = getOrCreateProps(target.constructor);
if (!props.postConstructMethods) {
props.postConstructMethods = [];
}
props.postConstructMethods.push(methodName);
}
function PreDestroy(target, methodName, descriptor) {
var props = getOrCreateProps(target.constructor);
if (!props.preDestroyMethods) {
props.preDestroyMethods = [];
}
props.preDestroyMethods.push(methodName);
}
function Bean(beanName) {
return function (classConstructor) {
var props = getOrCreateProps(classConstructor);
props.beanName = beanName;
};
}
function Autowired(name) {
return function (target, propertyKey, descriptor) {
autowiredFunc(target, name, false, target, propertyKey, null);
};
}
function Optional(name) {
return function (target, propertyKey, descriptor) {
autowiredFunc(target, name, true, target, propertyKey, null);
};
}
function autowiredFunc(target, name, optional, classPrototype, methodOrAttributeName, index) {
if (name === null) {
console.error("AG Grid: Autowired name should not be null");
return;
}
if (typeof index === "number") {
console.error("AG Grid: Autowired should be on an attribute");
return;
}
// it's an attribute on the class
var props = getOrCreateProps(target.constructor);
if (!props.agClassAttributes) {
props.agClassAttributes = [];
}
props.agClassAttributes.push({
attributeName: methodOrAttributeName,
beanName: name,
optional: optional
});
}
function Qualifier(name) {
return function (classPrototype, methodOrAttributeName, index) {
var constructor = typeof classPrototype == "function" ? classPrototype : classPrototype.constructor;
var props;
if (typeof index === "number") {
// it's a parameter on a method
var methodName = void 0;
if (methodOrAttributeName) {
props = getOrCreateProps(constructor);
methodName = methodOrAttributeName;
}
else {
props = getOrCreateProps(constructor);
methodName = "agConstructor";
}
if (!props.autowireMethods) {
props.autowireMethods = {};
}
if (!props.autowireMethods[methodName]) {
props.autowireMethods[methodName] = {};
}
props.autowireMethods[methodName][index] = name;
}
};
}
function getOrCreateProps(target) {
if (!target.hasOwnProperty("__agBeanMetaData")) {
target.__agBeanMetaData = {};
}
return target.__agBeanMetaData;
}
var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
var EventService = /** @class */ (function () {
function EventService() {
this.allSyncListeners = new Map();
this.allAsyncListeners = new Map();
this.globalSyncListeners = new Set();
this.globalAsyncListeners = new Set();
this.asyncFunctionsQueue = [];
this.scheduled = false;
// using an object performs better than a Set for the number of different events we have
this.firedEvents = {};
}
// because this class is used both inside the context and outside the context, we do not
// use autowired attributes, as that would be confusing, as sometimes the attributes
// would be wired, and sometimes not.
//
// the global event servers used by AG Grid is autowired by the context once, and this
// setBeans method gets called once.
//
// the times when this class is used outside of the context (eg RowNode has an instance of this
// class) then it is not a bean, and this setBeans method is not called.
EventService.prototype.setBeans = function (gridOptionsService, frameworkOverrides, globalEventListener, globalSyncEventListener) {
if (globalEventListener === void 0) { globalEventListener = null; }
if (globalSyncEventListener === void 0) { globalSyncEventListener = null; }
this.frameworkOverrides = frameworkOverrides;
this.gridOptionsService = gridOptionsService;
if (globalEventListener) {
var async = gridOptionsService.useAsyncEvents();
this.addGlobalListener(globalEventListener, async);
}
if (globalSyncEventListener) {
this.addGlobalListener(globalSyncEventListener, false);
}
};
EventService.prototype.setFrameworkOverrides = function (frameworkOverrides) {
this.frameworkOverrides = frameworkOverrides;
};
EventService.prototype.getListeners = function (eventType, async, autoCreateListenerCollection) {
var listenerMap = async ? this.allAsyncListeners : this.allSyncListeners;
var listeners = listenerMap.get(eventType);
// Note: 'autoCreateListenerCollection' should only be 'true' if a listener is about to be added. For instance
// getListeners() is also called during event dispatch even though no listeners are added. This measure protects
// against 'memory bloat' as empty collections will prevent the RowNode's event service from being removed after
// the RowComp is destroyed, see noRegisteredListenersExist() below.
if (!listeners && autoCreateListenerCollection) {
listeners = new Set();
listenerMap.set(eventType, listeners);
}
return listeners;
};
EventService.prototype.noRegisteredListenersExist = function () {
return this.allSyncListeners.size === 0 && this.allAsyncListeners.size === 0 &&
this.globalSyncListeners.size === 0 && this.globalAsyncListeners.size === 0;
};
EventService.prototype.addEventListener = function (eventType, listener, async) {
if (async === void 0) { async = false; }
this.getListeners(eventType, async, true).add(listener);
};
EventService.prototype.removeEventListener = function (eventType, listener, async) {
if (async === void 0) { async = false; }
var listeners = this.getListeners(eventType, async, false);
if (!listeners) {
return;
}
listeners.delete(listener);
if (listeners.size === 0) {
var listenerMap = async ? this.allAsyncListeners : this.allSyncListeners;
listenerMap.delete(eventType);
}
};
EventService.prototype.addGlobalListener = function (listener, async) {
if (async === void 0) { async = false; }
(async ? this.globalAsyncListeners : this.globalSyncListeners).add(listener);
};
EventService.prototype.removeGlobalListener = function (listener, async) {
if (async === void 0) { async = false; }
(async ? this.globalAsyncListeners : this.globalSyncListeners).delete(listener);
};
EventService.prototype.dispatchEvent = function (event) {
var agEvent = event;
if (this.gridOptionsService) {
// Apply common properties to all dispatched events if this event service has had its beans set with gridOptionsService.
// Note there are multiple instances of EventService that are used local to components which do not set gridOptionsService.
this.gridOptionsService.addGridCommonParams(agEvent);
}
this.dispatchToListeners(agEvent, true);
this.dispatchToListeners(agEvent, false);
this.firedEvents[agEvent.type] = true;
};
EventService.prototype.dispatchEventOnce = function (event) {
if (!this.firedEvents[event.type]) {
this.dispatchEvent(event);
}
};
EventService.prototype.dispatchToListeners = function (event, async) {
var _this = this;
var _a;
var eventType = event.type;
if (async && 'event' in event) {
var browserEvent = event.event;
if (browserEvent instanceof Event) {
// AG-7893 - Persist composedPath() so that its result can still be accessed by the