is not ideal, but it's the best we can do at the moment to enable\n // eventSvc to have the best typing at the expense of BeanStub local events\n /** Add a local event listener against this BeanStub */\n addEventListener(eventType, listener, async) {\n if (!this.localEventService) {\n this.localEventService = new LocalEventService();\n }\n this.localEventService.addEventListener(eventType, listener, async);\n }\n /** Remove a local event listener from this BeanStub */\n removeEventListener(eventType, listener, async) {\n this.localEventService?.removeEventListener(eventType, listener, async);\n }\n dispatchLocalEvent(event) {\n this.localEventService?.dispatchEvent(event);\n }\n addManagedElementListeners(object, handlers) {\n return this._setupListeners(object, handlers);\n }\n addManagedEventListeners(handlers) {\n return this._setupListeners(this.eventSvc, handlers);\n }\n addManagedListeners(object, handlers) {\n return this._setupListeners(object, handlers);\n }\n _setupListeners(object, handlers) {\n const destroyFuncs = [];\n for (const k of Object.keys(handlers)) {\n const handler = handlers[k];\n if (handler) {\n destroyFuncs.push(this._setupListener(object, k, handler));\n }\n }\n return destroyFuncs;\n }\n _setupListener(object, event, listener) {\n if (this.destroyed) {\n return () => null;\n }\n let destroyFunc;\n if (isAgEventEmitter(object)) {\n object.__addEventListener(event, listener);\n destroyFunc = () => {\n object.__removeEventListener(event, listener);\n return null;\n };\n } else {\n if (object instanceof HTMLElement) {\n _addSafePassiveEventListener(this.beans.frameworkOverrides, object, event, listener);\n } else {\n object.addEventListener(event, listener);\n }\n destroyFunc = () => {\n object.removeEventListener(event, listener);\n return null;\n };\n }\n this.destroyFunctions.push(destroyFunc);\n return () => {\n destroyFunc();\n this.destroyFunctions = this.destroyFunctions.filter((fn) => fn !== destroyFunc);\n return null;\n };\n }\n /**\n * Setup a managed property listener for the given GridOption property.\n * However, stores the destroy function in the beanStub so that if this bean\n * is a component the destroy function will be called when the component is destroyed\n * as opposed to being cleaned up only when the GridOptionsService is destroyed.\n */\n setupGridOptionListener(event, listener) {\n const { gos } = this;\n gos.addPropertyEventListener(event, listener);\n const destroyFunc = () => {\n gos.removePropertyEventListener(event, listener);\n return null;\n };\n this.destroyFunctions.push(destroyFunc);\n return () => {\n destroyFunc();\n this.destroyFunctions = this.destroyFunctions.filter((fn) => fn !== destroyFunc);\n return null;\n };\n }\n /**\n * Setup a managed property listener for the given GridOption property.\n * @param event GridOption property to listen to changes for.\n * @param listener Listener to run when property value changes\n */\n addManagedPropertyListener(event, listener) {\n if (this.destroyed) {\n return () => null;\n }\n return this.setupGridOptionListener(event, listener);\n }\n /**\n * Setup managed property listeners for the given set of GridOption properties.\n * The listener will be run if any of the property changes but will only run once if\n * multiple of the properties change within the same framework lifecycle event.\n * Works on the basis that GridOptionsService updates all properties *before* any property change events are fired.\n * @param events Array of GridOption properties to listen for changes too.\n * @param listener Shared listener to run if any of the properties change\n */\n addManagedPropertyListeners(events, listener) {\n if (this.destroyed) {\n return;\n }\n const eventsKey = events.join(\"-\") + this.propertyListenerId++;\n const wrappedListener = (event) => {\n if (event.changeSet) {\n if (event.changeSet && event.changeSet.id === this.lastChangeSetIdLookup[eventsKey]) {\n return;\n }\n this.lastChangeSetIdLookup[eventsKey] = event.changeSet.id;\n }\n const propertiesChangeEvent = {\n type: \"gridPropertyChanged\",\n changeSet: event.changeSet,\n source: event.source\n };\n listener(propertiesChangeEvent);\n };\n events.forEach((event) => this.setupGridOptionListener(event, wrappedListener));\n }\n getLocaleTextFunc() {\n return _getLocaleTextFunc(this.beans.localeSvc);\n }\n addDestroyFunc(func) {\n if (this.isAlive()) {\n this.destroyFunctions.push(func);\n } else {\n func();\n }\n }\n /** doesn't throw an error if `bean` is undefined */\n createOptionalManagedBean(bean, context) {\n return bean ? this.createManagedBean(bean, context) : void 0;\n }\n createManagedBean(bean, context) {\n const res = this.createBean(bean, context);\n this.addDestroyFunc(this.destroyBean.bind(this, bean, context));\n return res;\n }\n createBean(bean, context, afterPreCreateCallback) {\n return (context || this.stubContext).createBean(bean, afterPreCreateCallback);\n }\n /**\n * Destroys a bean and returns undefined to support destruction and clean up in a single line.\n * this.dateComp = this.context.destroyBean(this.dateComp);\n */\n destroyBean(bean, context) {\n return (context || this.stubContext).destroyBean(bean);\n }\n /**\n * Destroys an array of beans and returns an empty array to support destruction and clean up in a single line.\n * this.dateComps = this.context.destroyBeans(this.dateComps);\n */\n destroyBeans(beans, context) {\n return (context || this.stubContext).destroyBeans(beans);\n }\n};\nfunction isAgEventEmitter(object) {\n return object.__addEventListener !== void 0;\n}\n\n// packages/ag-grid-community/src/utils/object.ts\nvar SKIP_JS_BUILTINS = /* @__PURE__ */ new Set([\"__proto__\", \"constructor\", \"prototype\"]);\nfunction _iterateObject(object, callback) {\n if (object == null) {\n return;\n }\n if (Array.isArray(object)) {\n for (let i = 0; i < object.length; i++) {\n callback(i.toString(), object[i]);\n }\n return;\n }\n for (const key of Object.keys(object)) {\n callback(key, object[key]);\n }\n}\nfunction _mergeDeep(dest, source, copyUndefined = true, makeCopyOfSimpleObjects = false) {\n if (!_exists(source)) {\n return;\n }\n _iterateObject(source, (key, sourceValue) => {\n if (SKIP_JS_BUILTINS.has(key)) {\n return;\n }\n let destValue = dest[key];\n if (destValue === sourceValue) {\n return;\n }\n if (makeCopyOfSimpleObjects) {\n const objectIsDueToBeCopied = destValue == null && sourceValue != null;\n if (objectIsDueToBeCopied) {\n const doNotCopyAsSourceIsSimpleObject = typeof sourceValue === \"object\" && sourceValue.constructor === Object;\n if (doNotCopyAsSourceIsSimpleObject) {\n destValue = {};\n dest[key] = destValue;\n }\n }\n }\n if (_isNonNullObject(sourceValue) && _isNonNullObject(destValue) && !Array.isArray(destValue)) {\n _mergeDeep(destValue, sourceValue, copyUndefined, makeCopyOfSimpleObjects);\n } else if (copyUndefined || sourceValue !== void 0) {\n dest[key] = sourceValue;\n }\n });\n}\nfunction _getValueUsingField(data, field, fieldContainsDots) {\n if (!field || !data) {\n return;\n }\n if (!fieldContainsDots) {\n return data[field];\n }\n const fields = field.split(\".\");\n let currentObject = data;\n for (let i = 0; i < fields.length; i++) {\n if (currentObject == null) {\n return void 0;\n }\n currentObject = currentObject[fields[i]];\n }\n return currentObject;\n}\nfunction _isNonNullObject(value) {\n return typeof value === \"object\" && value !== null;\n}\n\n// packages/ag-grid-community/src/utils/string.ts\nvar reUnescapedHtml = /[&<>\"']/g;\nvar HTML_ESCAPES = {\n \"&\": \"&\",\n \"<\": \"<\",\n \">\": \">\",\n '\"': \""\",\n \"'\": \"'\"\n};\nfunction _escapeString(toEscape, skipEscapingHtmlChars) {\n if (toEscape == null) {\n return null;\n }\n const stringResult = toEscape.toString().toString();\n if (skipEscapingHtmlChars) {\n return stringResult;\n }\n return stringResult.replace(reUnescapedHtml, (chr) => HTML_ESCAPES[chr]);\n}\n\n// packages/ag-grid-community/src/entities/agColumn.ts\nvar COL_DEF_DEFAULTS = {\n resizable: true,\n sortable: true\n};\nvar instanceIdSequence = 0;\nfunction getNextColInstanceId() {\n return instanceIdSequence++;\n}\nfunction isColumn(col) {\n return col instanceof AgColumn;\n}\nvar AgColumn = class extends BeanStub {\n constructor(colDef, userProvidedColDef, colId, primary) {\n super();\n this.colDef = colDef;\n this.userProvidedColDef = userProvidedColDef;\n this.colId = colId;\n this.primary = primary;\n this.isColumn = true;\n // used by React (and possibly other frameworks) as key for rendering. also used to\n // identify old vs new columns for destroying cols when no longer used.\n this.instanceId = getNextColInstanceId();\n // The measured height of this column's header when autoHeaderHeight is enabled\n this.autoHeaderHeight = null;\n this.moving = false;\n this.menuVisible = false;\n this.lastLeftPinned = false;\n this.firstRightPinned = false;\n this.filterActive = false;\n this.colEventSvc = new LocalEventService();\n this.tooltipEnabled = false;\n this.rowGroupActive = false;\n this.pivotActive = false;\n this.aggregationActive = false;\n this.flex = null;\n this.colIdSanitised = _escapeString(colId);\n }\n destroy() {\n super.destroy();\n this.beans.rowSpanSvc?.deregister(this);\n }\n getInstanceId() {\n return this.instanceId;\n }\n setState() {\n const {\n colDef,\n beans: { sortSvc, pinnedCols, colFlex }\n } = this;\n sortSvc?.initCol(this);\n const hide = colDef.hide;\n if (hide !== void 0) {\n this.visible = !hide;\n } else {\n this.visible = !colDef.initialHide;\n }\n pinnedCols?.initCol(this);\n colFlex?.initCol(this);\n }\n // gets called when user provides an alternative colDef, eg\n setColDef(colDef, userProvidedColDef, source) {\n const colSpanChanged = colDef.spanRows !== this.colDef.spanRows;\n this.colDef = colDef;\n this.userProvidedColDef = userProvidedColDef;\n this.initMinAndMaxWidths();\n this.initDotNotation();\n this.initTooltip();\n if (colSpanChanged) {\n this.beans.rowSpanSvc?.deregister(this);\n this.initRowSpan();\n }\n this.dispatchColEvent(\"colDefChanged\", source);\n }\n getUserProvidedColDef() {\n return this.userProvidedColDef;\n }\n getParent() {\n return this.parent;\n }\n getOriginalParent() {\n return this.originalParent;\n }\n // this is done after constructor as it uses gridOptionsService\n postConstruct() {\n this.setState();\n this.initMinAndMaxWidths();\n this.resetActualWidth(\"gridInitializing\");\n this.initDotNotation();\n this.initTooltip();\n this.initRowSpan();\n }\n initDotNotation() {\n const {\n gos,\n colDef: { field, tooltipField }\n } = this;\n const suppressDotNotation = gos.get(\"suppressFieldDotNotation\");\n this.fieldContainsDots = _exists(field) && field.indexOf(\".\") >= 0 && !suppressDotNotation;\n this.tooltipFieldContainsDots = _exists(tooltipField) && tooltipField.indexOf(\".\") >= 0 && !suppressDotNotation;\n }\n initMinAndMaxWidths() {\n const colDef = this.colDef;\n this.minWidth = colDef.minWidth ?? this.beans.environment.getDefaultColumnMinWidth();\n this.maxWidth = colDef.maxWidth ?? Number.MAX_SAFE_INTEGER;\n }\n initTooltip() {\n this.beans.tooltipSvc?.initCol(this);\n }\n initRowSpan() {\n if (this.colDef.spanRows) {\n this.beans.rowSpanSvc?.register(this);\n }\n }\n resetActualWidth(source) {\n const initialWidth = this.calculateColInitialWidth(this.colDef);\n this.setActualWidth(initialWidth, source, true);\n }\n calculateColInitialWidth(colDef) {\n let width;\n const colDefWidth = colDef.width;\n const colDefInitialWidth = colDef.initialWidth;\n if (colDefWidth != null) {\n width = colDefWidth;\n } else if (colDefInitialWidth != null) {\n width = colDefInitialWidth;\n } else {\n width = 200;\n }\n return Math.max(Math.min(width, this.maxWidth), this.minWidth);\n }\n isEmptyGroup() {\n return false;\n }\n isRowGroupDisplayed(colId) {\n return this.beans.showRowGroupCols?.isRowGroupDisplayed(this, colId) ?? false;\n }\n isPrimary() {\n return this.primary;\n }\n isFilterAllowed() {\n const filterDefined = !!this.colDef.filter;\n return filterDefined;\n }\n isFieldContainsDots() {\n return this.fieldContainsDots;\n }\n isTooltipEnabled() {\n return this.tooltipEnabled;\n }\n isTooltipFieldContainsDots() {\n return this.tooltipFieldContainsDots;\n }\n getHighlighted() {\n return this.highlighted;\n }\n __addEventListener(eventType, listener) {\n this.colEventSvc.addEventListener(eventType, listener);\n }\n __removeEventListener(eventType, listener) {\n this.colEventSvc.removeEventListener(eventType, listener);\n }\n /**\n * PUBLIC USE ONLY: for internal use within AG Grid use the `__addEventListener` and `__removeEventListener` methods.\n */\n addEventListener(eventType, userListener) {\n this.frameworkEventListenerService = this.beans.frameworkOverrides.createLocalEventListenerWrapper?.(\n this.frameworkEventListenerService,\n this.colEventSvc\n );\n const listener = this.frameworkEventListenerService?.wrap(userListener) ?? userListener;\n this.colEventSvc.addEventListener(eventType, listener);\n }\n /**\n * PUBLIC USE ONLY: for internal use within AG Grid use the `__addEventListener` and `__removeEventListener` methods.\n */\n removeEventListener(eventType, userListener) {\n const listener = this.frameworkEventListenerService?.unwrap(userListener) ?? userListener;\n this.colEventSvc.removeEventListener(eventType, listener);\n }\n createColumnFunctionCallbackParams(rowNode) {\n return _addGridCommonParams(this.gos, {\n node: rowNode,\n data: rowNode.data,\n column: this,\n colDef: this.colDef\n });\n }\n isSuppressNavigable(rowNode) {\n return this.beans.cellNavigation?.isSuppressNavigable(this, rowNode) ?? false;\n }\n isCellEditable(rowNode) {\n return this.beans.editSvc?.isCellEditable(this, rowNode) ?? false;\n }\n isSuppressFillHandle() {\n return !!this.colDef.suppressFillHandle;\n }\n isAutoHeight() {\n return !!this.colDef.autoHeight;\n }\n isAutoHeaderHeight() {\n return !!this.colDef.autoHeaderHeight;\n }\n isRowDrag(rowNode) {\n return this.isColumnFunc(rowNode, this.colDef.rowDrag);\n }\n isDndSource(rowNode) {\n return this.isColumnFunc(rowNode, this.colDef.dndSource);\n }\n isCellCheckboxSelection(rowNode) {\n return this.beans.selectionSvc?.isCellCheckboxSelection(this, rowNode) ?? false;\n }\n isSuppressPaste(rowNode) {\n return this.isColumnFunc(rowNode, this.colDef?.suppressPaste ?? null);\n }\n isResizable() {\n return !!this.getColDefValue(\"resizable\");\n }\n /** Get value from ColDef or default if it exists. */\n getColDefValue(key) {\n return this.colDef[key] ?? COL_DEF_DEFAULTS[key];\n }\n isColumnFunc(rowNode, value) {\n if (typeof value === \"boolean\") {\n return value;\n }\n if (typeof value === \"function\") {\n const params = this.createColumnFunctionCallbackParams(rowNode);\n const editableFunc = value;\n return editableFunc(params);\n }\n return false;\n }\n createColumnEvent(type, source) {\n return _addGridCommonParams(this.gos, {\n type,\n column: this,\n columns: [this],\n source\n });\n }\n isMoving() {\n return this.moving;\n }\n getSort() {\n return this.sort;\n }\n isSortable() {\n return !!this.getColDefValue(\"sortable\");\n }\n /** @deprecated v32 use col.getSort() === 'asc */\n isSortAscending() {\n return this.sort === \"asc\";\n }\n /** @deprecated v32 use col.getSort() === 'desc */\n isSortDescending() {\n return this.sort === \"desc\";\n }\n /** @deprecated v32 use col.getSort() === undefined */\n isSortNone() {\n return _missing(this.sort);\n }\n /** @deprecated v32 use col.getSort() !== undefined */\n isSorting() {\n return _exists(this.sort);\n }\n getSortIndex() {\n return this.sortIndex;\n }\n isMenuVisible() {\n return this.menuVisible;\n }\n getAggFunc() {\n return this.aggFunc;\n }\n getLeft() {\n return this.left;\n }\n getOldLeft() {\n return this.oldLeft;\n }\n getRight() {\n return this.left + this.actualWidth;\n }\n setLeft(left, source) {\n this.oldLeft = this.left;\n if (this.left !== left) {\n this.left = left;\n this.dispatchColEvent(\"leftChanged\", source);\n }\n }\n isFilterActive() {\n return this.filterActive;\n }\n /** @deprecated v33 Use `api.isColumnHovered(column)` instead. */\n isHovered() {\n _warn(261);\n return !!this.beans.colHover?.isHovered(this);\n }\n setFirstRightPinned(firstRightPinned, source) {\n if (this.firstRightPinned !== firstRightPinned) {\n this.firstRightPinned = firstRightPinned;\n this.dispatchColEvent(\"firstRightPinnedChanged\", source);\n }\n }\n setLastLeftPinned(lastLeftPinned, source) {\n if (this.lastLeftPinned !== lastLeftPinned) {\n this.lastLeftPinned = lastLeftPinned;\n this.dispatchColEvent(\"lastLeftPinnedChanged\", source);\n }\n }\n isFirstRightPinned() {\n return this.firstRightPinned;\n }\n isLastLeftPinned() {\n return this.lastLeftPinned;\n }\n isPinned() {\n return this.pinned === \"left\" || this.pinned === \"right\";\n }\n isPinnedLeft() {\n return this.pinned === \"left\";\n }\n isPinnedRight() {\n return this.pinned === \"right\";\n }\n getPinned() {\n return this.pinned;\n }\n setVisible(visible, source) {\n const newValue = visible === true;\n if (this.visible !== newValue) {\n this.visible = newValue;\n this.dispatchColEvent(\"visibleChanged\", source);\n }\n this.dispatchStateUpdatedEvent(\"hide\");\n }\n isVisible() {\n return this.visible;\n }\n isSpanHeaderHeight() {\n const colDef = this.getColDef();\n return !colDef.suppressSpanHeaderHeight;\n }\n getColumnGroupPaddingInfo() {\n let parent = this.getParent();\n if (!parent || !parent.isPadding()) {\n return { numberOfParents: 0, isSpanningTotal: false };\n }\n const numberOfParents = parent.getPaddingLevel() + 1;\n let isSpanningTotal = true;\n while (parent) {\n if (!parent.isPadding()) {\n isSpanningTotal = false;\n break;\n }\n parent = parent.getParent();\n }\n return { numberOfParents, isSpanningTotal };\n }\n getColDef() {\n return this.colDef;\n }\n getDefinition() {\n return this.colDef;\n }\n getColumnGroupShow() {\n return this.colDef.columnGroupShow;\n }\n getColId() {\n return this.colId;\n }\n getId() {\n return this.colId;\n }\n getUniqueId() {\n return this.colId;\n }\n getActualWidth() {\n return this.actualWidth;\n }\n getAutoHeaderHeight() {\n return this.autoHeaderHeight;\n }\n /** Returns true if the header height has changed */\n setAutoHeaderHeight(height) {\n const changed = height !== this.autoHeaderHeight;\n this.autoHeaderHeight = height;\n return changed;\n }\n createBaseColDefParams(rowNode) {\n const params = _addGridCommonParams(this.gos, {\n node: rowNode,\n data: rowNode.data,\n colDef: this.colDef,\n column: this\n });\n return params;\n }\n getColSpan(rowNode) {\n if (_missing(this.colDef.colSpan)) {\n return 1;\n }\n const params = this.createBaseColDefParams(rowNode);\n const colSpan = this.colDef.colSpan(params);\n return Math.max(colSpan, 1);\n }\n getRowSpan(rowNode) {\n if (_missing(this.colDef.rowSpan)) {\n return 1;\n }\n const params = this.createBaseColDefParams(rowNode);\n const rowSpan = this.colDef.rowSpan(params);\n return Math.max(rowSpan, 1);\n }\n setActualWidth(actualWidth, source, silent = false) {\n actualWidth = Math.max(actualWidth, this.minWidth);\n actualWidth = Math.min(actualWidth, this.maxWidth);\n if (this.actualWidth !== actualWidth) {\n this.actualWidth = actualWidth;\n if (this.flex != null && source !== \"flex\" && source !== \"gridInitializing\") {\n this.flex = null;\n }\n if (!silent) {\n this.fireColumnWidthChangedEvent(source);\n }\n }\n this.dispatchStateUpdatedEvent(\"width\");\n }\n fireColumnWidthChangedEvent(source) {\n this.dispatchColEvent(\"widthChanged\", source);\n }\n isGreaterThanMax(width) {\n return width > this.maxWidth;\n }\n getMinWidth() {\n return this.minWidth;\n }\n getMaxWidth() {\n return this.maxWidth;\n }\n getFlex() {\n return this.flex;\n }\n isRowGroupActive() {\n return this.rowGroupActive;\n }\n isPivotActive() {\n return this.pivotActive;\n }\n isAnyFunctionActive() {\n return this.isPivotActive() || this.isRowGroupActive() || this.isValueActive();\n }\n isAnyFunctionAllowed() {\n return this.isAllowPivot() || this.isAllowRowGroup() || this.isAllowValue();\n }\n isValueActive() {\n return this.aggregationActive;\n }\n isAllowPivot() {\n return this.colDef.enablePivot === true;\n }\n isAllowValue() {\n return this.colDef.enableValue === true;\n }\n isAllowRowGroup() {\n return this.colDef.enableRowGroup === true;\n }\n dispatchColEvent(type, source, additionalEventAttributes) {\n const colEvent = this.createColumnEvent(type, source);\n if (additionalEventAttributes) {\n _mergeDeep(colEvent, additionalEventAttributes);\n }\n this.colEventSvc.dispatchEvent(colEvent);\n }\n dispatchStateUpdatedEvent(key) {\n this.colEventSvc.dispatchEvent({\n type: \"columnStateUpdated\",\n key\n });\n }\n};\n\n// packages/ag-grid-community/src/entities/agProvidedColumnGroup.ts\nfunction isProvidedColumnGroup(col) {\n return col instanceof AgProvidedColumnGroup;\n}\nvar AgProvidedColumnGroup = class extends BeanStub {\n constructor(colGroupDef, groupId, padding, level) {\n super();\n this.colGroupDef = colGroupDef;\n this.groupId = groupId;\n this.padding = padding;\n this.level = level;\n this.isColumn = false;\n this.expandable = false;\n // used by React (and possibly other frameworks) as key for rendering. also used to\n // identify old vs new columns for destroying cols when no longer used.\n this.instanceId = getNextColInstanceId();\n this.expandableListenerRemoveCallback = null;\n this.expanded = !!colGroupDef?.openByDefault;\n }\n destroy() {\n if (this.expandableListenerRemoveCallback) {\n this.reset(null, void 0);\n }\n super.destroy();\n }\n reset(colGroupDef, level) {\n this.colGroupDef = colGroupDef;\n this.level = level;\n this.originalParent = null;\n if (this.expandableListenerRemoveCallback) {\n this.expandableListenerRemoveCallback();\n }\n this.children = void 0;\n this.expandable = void 0;\n }\n getInstanceId() {\n return this.instanceId;\n }\n getOriginalParent() {\n return this.originalParent;\n }\n getLevel() {\n return this.level;\n }\n isVisible() {\n if (this.children) {\n return this.children.some((child) => child.isVisible());\n }\n return false;\n }\n isPadding() {\n return this.padding;\n }\n setExpanded(expanded) {\n this.expanded = expanded === void 0 ? false : expanded;\n this.dispatchLocalEvent({ type: \"expandedChanged\" });\n }\n isExpandable() {\n return this.expandable;\n }\n isExpanded() {\n return this.expanded;\n }\n getGroupId() {\n return this.groupId;\n }\n getId() {\n return this.getGroupId();\n }\n setChildren(children) {\n this.children = children;\n }\n getChildren() {\n return this.children;\n }\n getColGroupDef() {\n return this.colGroupDef;\n }\n getLeafColumns() {\n const result = [];\n this.addLeafColumns(result);\n return result;\n }\n addLeafColumns(leafColumns) {\n if (!this.children) {\n return;\n }\n this.children.forEach((child) => {\n if (isColumn(child)) {\n leafColumns.push(child);\n } else if (isProvidedColumnGroup(child)) {\n child.addLeafColumns(leafColumns);\n }\n });\n }\n getColumnGroupShow() {\n const colGroupDef = this.colGroupDef;\n if (!colGroupDef) {\n return;\n }\n return colGroupDef.columnGroupShow;\n }\n // need to check that this group has at least one col showing when both expanded and contracted.\n // if not, then we don't allow expanding and contracting on this group\n setupExpandable() {\n this.setExpandable();\n if (this.expandableListenerRemoveCallback) {\n this.expandableListenerRemoveCallback();\n }\n const listener = this.onColumnVisibilityChanged.bind(this);\n this.getLeafColumns().forEach((col) => col.__addEventListener(\"visibleChanged\", listener));\n this.expandableListenerRemoveCallback = () => {\n this.getLeafColumns().forEach((col) => col.__removeEventListener(\"visibleChanged\", listener));\n this.expandableListenerRemoveCallback = null;\n };\n }\n setExpandable() {\n if (this.isPadding()) {\n return;\n }\n let atLeastOneShowingWhenOpen = false;\n let atLeastOneShowingWhenClosed = false;\n let atLeastOneChangeable = false;\n const children = this.findChildrenRemovingPadding();\n for (let i = 0, j = children.length; i < j; i++) {\n const abstractColumn = children[i];\n if (!abstractColumn.isVisible()) {\n continue;\n }\n const headerGroupShow = abstractColumn.getColumnGroupShow();\n if (headerGroupShow === \"open\") {\n atLeastOneShowingWhenOpen = true;\n atLeastOneChangeable = true;\n } else if (headerGroupShow === \"closed\") {\n atLeastOneShowingWhenClosed = true;\n atLeastOneChangeable = true;\n } else {\n atLeastOneShowingWhenOpen = true;\n atLeastOneShowingWhenClosed = true;\n }\n }\n const expandable = atLeastOneShowingWhenOpen && atLeastOneShowingWhenClosed && atLeastOneChangeable;\n if (this.expandable !== expandable) {\n this.expandable = expandable;\n this.dispatchLocalEvent({ type: \"expandableChanged\" });\n }\n }\n findChildrenRemovingPadding() {\n const res = [];\n const process = (items) => {\n items.forEach((item) => {\n const skipBecausePadding = isProvidedColumnGroup(item) && item.isPadding();\n if (skipBecausePadding) {\n process(item.children);\n } else {\n res.push(item);\n }\n });\n };\n process(this.children);\n return res;\n }\n onColumnVisibilityChanged() {\n this.setExpandable();\n }\n};\n\n// packages/ag-grid-community/src/entities/defaultColumnTypes.ts\nvar DefaultColumnTypes = {\n numericColumn: {\n headerClass: \"ag-right-aligned-header\",\n cellClass: \"ag-right-aligned-cell\"\n },\n rightAligned: {\n headerClass: \"ag-right-aligned-header\",\n cellClass: \"ag-right-aligned-cell\"\n }\n};\n\n// packages/ag-grid-community/src/columns/columnKeyCreator.ts\nvar ColumnKeyCreator = class {\n constructor() {\n this.existingKeys = {};\n }\n addExistingKeys(keys) {\n for (let i = 0; i < keys.length; i++) {\n this.existingKeys[keys[i]] = true;\n }\n }\n getUniqueKey(colId, colField) {\n colId = _toStringOrNull(colId);\n let count = 0;\n while (true) {\n let idToTry = colId ?? colField;\n if (idToTry) {\n if (count !== 0) {\n idToTry += \"_\" + count;\n }\n } else {\n idToTry = count;\n }\n if (!this.existingKeys[idToTry]) {\n this.existingKeys[idToTry] = true;\n return String(idToTry);\n }\n count++;\n }\n }\n};\n\n// packages/ag-grid-community/src/utils/array.ts\nvar _EmptyArray = Object.freeze([]);\nfunction _last(arr) {\n if (!arr?.length) {\n return;\n }\n return arr[arr.length - 1];\n}\nfunction _areEqual(a, b, comparator) {\n if (a == null && b == null) {\n return true;\n }\n return a != null && b != null && a.length === b.length && a.every((value, index) => comparator ? comparator(value, b[index]) : b[index] === value);\n}\nfunction _sortNumerically(array) {\n return array.sort((a, b) => a - b);\n}\nfunction _removeFromArray(array, object) {\n const index = array.indexOf(object);\n if (index >= 0) {\n array.splice(index, 1);\n }\n}\nfunction _moveInArray(array, objectsToMove, toIndex) {\n for (let i = 0; i < objectsToMove.length; i++) {\n _removeFromArray(array, objectsToMove[i]);\n }\n for (let i = objectsToMove.length - 1; i >= 0; i--) {\n array.splice(toIndex, 0, objectsToMove[i]);\n }\n}\n\n// packages/ag-grid-community/src/columns/columnUtils.ts\nvar GROUP_AUTO_COLUMN_ID = \"ag-Grid-AutoColumn\";\nvar SELECTION_COLUMN_ID = \"ag-Grid-SelectionColumn\";\nvar ROW_NUMBERS_COLUMN_ID = \"ag-Grid-RowNumbersColumn\";\nfunction _getColumnsFromTree(rootColumns) {\n const result = [];\n const recursiveFindColumns = (childColumns) => {\n for (let i = 0; i < childColumns.length; i++) {\n const child = childColumns[i];\n if (isColumn(child)) {\n result.push(child);\n } else if (isProvidedColumnGroup(child)) {\n recursiveFindColumns(child.getChildren());\n }\n }\n };\n recursiveFindColumns(rootColumns);\n return result;\n}\nfunction getWidthOfColsInList(columnList) {\n return columnList.reduce((width, col) => width + col.getActualWidth(), 0);\n}\nfunction _destroyColumnTree(beans, oldTree, newTree) {\n const oldObjectsById = {};\n if (!oldTree) {\n return;\n }\n depthFirstOriginalTreeSearch(null, oldTree, (child) => {\n oldObjectsById[child.getInstanceId()] = child;\n });\n if (newTree) {\n depthFirstOriginalTreeSearch(null, newTree, (child) => {\n oldObjectsById[child.getInstanceId()] = null;\n });\n }\n const colsToDestroy = Object.values(oldObjectsById).filter((item) => item != null);\n beans.context.destroyBeans(colsToDestroy);\n}\nfunction isColumnGroupAutoCol(col) {\n const colId = col.getId();\n return colId.startsWith(GROUP_AUTO_COLUMN_ID);\n}\nfunction isColumnSelectionCol(col) {\n const id = typeof col === \"string\" ? col : \"getColId\" in col ? col.getColId() : col.colId;\n return id?.startsWith(SELECTION_COLUMN_ID) ?? false;\n}\nfunction isRowNumberCol(col) {\n const id = typeof col === \"string\" ? col : \"getColId\" in col ? col.getColId() : col.colId;\n return id?.startsWith(ROW_NUMBERS_COLUMN_ID) ?? false;\n}\nfunction convertColumnTypes(type) {\n let typeKeys = [];\n if (type instanceof Array) {\n typeKeys = type;\n } else if (typeof type === \"string\") {\n typeKeys = type.split(\",\");\n }\n return typeKeys;\n}\nfunction _areColIdsEqual(colsA, colsB) {\n return _areEqual(colsA, colsB, (a, b) => a.getColId() === b.getColId());\n}\nfunction _updateColsMap(cols) {\n cols.map = {};\n cols.list.forEach((col) => cols.map[col.getId()] = col);\n}\nfunction _convertColumnEventSourceType(source) {\n return source === \"gridOptionsUpdated\" ? \"gridOptionsChanged\" : source;\n}\nfunction _columnsMatch(column, key) {\n const columnMatches = column === key;\n const colDefMatches = column.getColDef() === key;\n const idMatches = column.getColId() == key;\n return columnMatches || colDefMatches || idMatches;\n}\nvar getValueFactory = (stateItem, defaultState) => (key1, key2) => {\n const obj = {\n value1: void 0,\n value2: void 0\n };\n let calculated = false;\n if (stateItem) {\n if (stateItem[key1] !== void 0) {\n obj.value1 = stateItem[key1];\n calculated = true;\n }\n if (_exists(key2) && stateItem[key2] !== void 0) {\n obj.value2 = stateItem[key2];\n calculated = true;\n }\n }\n if (!calculated && defaultState) {\n if (defaultState[key1] !== void 0) {\n obj.value1 = defaultState[key1];\n }\n if (_exists(key2) && defaultState[key2] !== void 0) {\n obj.value2 = defaultState[key2];\n }\n }\n return obj;\n};\n\n// packages/ag-grid-community/src/columns/columnFactoryUtils.ts\nfunction _createColumnTree(beans, defs = null, primaryColumns, existingTree, source) {\n const columnKeyCreator = new ColumnKeyCreator();\n const { existingCols, existingGroups, existingColKeys } = extractExistingTreeData(existingTree);\n columnKeyCreator.addExistingKeys(existingColKeys);\n const unbalancedTree = _recursivelyCreateColumns(\n beans,\n defs,\n 0,\n primaryColumns,\n existingCols,\n columnKeyCreator,\n existingGroups,\n source\n );\n const { colGroupSvc } = beans;\n const treeDept = colGroupSvc?.findMaxDepth(unbalancedTree, 0) ?? 0;\n const columnTree = colGroupSvc ? colGroupSvc.balanceColumnTree(unbalancedTree, 0, treeDept, columnKeyCreator) : unbalancedTree;\n const deptFirstCallback = (child, parent) => {\n if (isProvidedColumnGroup(child)) {\n child.setupExpandable();\n }\n child.originalParent = parent;\n };\n depthFirstOriginalTreeSearch(null, columnTree, deptFirstCallback);\n return {\n columnTree,\n treeDept\n };\n}\nfunction extractExistingTreeData(existingTree) {\n const existingCols = [];\n const existingGroups = [];\n const existingColKeys = [];\n if (existingTree) {\n depthFirstOriginalTreeSearch(null, existingTree, (item) => {\n if (isProvidedColumnGroup(item)) {\n const group = item;\n existingGroups.push(group);\n } else {\n const col = item;\n existingColKeys.push(col.getId());\n existingCols.push(col);\n }\n });\n }\n return { existingCols, existingGroups, existingColKeys };\n}\nfunction _recursivelyCreateColumns(beans, defs, level, primaryColumns, existingColsCopy, columnKeyCreator, existingGroups, source) {\n if (!defs)\n return [];\n const { colGroupSvc } = beans;\n const result = new Array(defs.length);\n for (let i = 0; i < result.length; i++) {\n const def = defs[i];\n if (colGroupSvc && isColumnGroup(def)) {\n result[i] = colGroupSvc.createProvidedColumnGroup(\n primaryColumns,\n def,\n level,\n existingColsCopy,\n columnKeyCreator,\n existingGroups,\n source\n );\n } else {\n result[i] = createColumn(beans, primaryColumns, def, existingColsCopy, columnKeyCreator, source);\n }\n }\n return result;\n}\nfunction createColumn(beans, primaryColumns, colDef, existingColsCopy, columnKeyCreator, source) {\n const existingColAndIndex = findExistingColumn(colDef, existingColsCopy);\n if (existingColAndIndex) {\n existingColsCopy?.splice(existingColAndIndex.idx, 1);\n }\n let column = existingColAndIndex?.column;\n if (!column) {\n const colId = columnKeyCreator.getUniqueKey(colDef.colId, colDef.field);\n const colDefMerged = _addColumnDefaultAndTypes(beans, colDef, colId);\n column = new AgColumn(colDefMerged, colDef, colId, primaryColumns);\n beans.context.createBean(column);\n } else {\n const colDefMerged = _addColumnDefaultAndTypes(beans, colDef, column.getColId());\n column.setColDef(colDefMerged, colDef, source);\n _updateColumnState(beans, column, colDefMerged, source);\n }\n beans.dataTypeSvc?.addColumnListeners(column);\n return column;\n}\nfunction updateSomeColumnState(beans, column, hide, sort, sortIndex, pinned, flex, source) {\n const { sortSvc, pinnedCols, colFlex } = beans;\n if (hide !== void 0) {\n column.setVisible(!hide, source);\n }\n if (sortSvc) {\n sortSvc.updateColSort(column, sort, source);\n if (sortIndex !== void 0) {\n sortSvc.setColSortIndex(column, sortIndex);\n }\n }\n if (pinned !== void 0) {\n pinnedCols?.setColPinned(column, pinned);\n }\n if (flex !== void 0) {\n colFlex?.setColFlex(column, flex);\n }\n}\nfunction _updateColumnState(beans, column, colDef, source) {\n updateSomeColumnState(\n beans,\n column,\n colDef.hide,\n colDef.sort,\n colDef.sortIndex,\n colDef.pinned,\n colDef.flex,\n source\n );\n const colFlex = column.getFlex();\n if (colFlex != null && colFlex > 0) {\n return;\n }\n if (colDef.width != null) {\n column.setActualWidth(colDef.width, source);\n } else {\n const widthBeforeUpdate = column.getActualWidth();\n column.setActualWidth(widthBeforeUpdate, source);\n }\n}\nfunction findExistingColumn(newColDef, existingColsCopy) {\n if (!existingColsCopy)\n return void 0;\n for (let i = 0; i < existingColsCopy.length; i++) {\n const def = existingColsCopy[i].getUserProvidedColDef();\n if (!def)\n continue;\n const newHasId = newColDef.colId != null;\n if (newHasId) {\n if (existingColsCopy[i].getId() === newColDef.colId) {\n return { idx: i, column: existingColsCopy[i] };\n }\n continue;\n }\n const newHasField = newColDef.field != null;\n if (newHasField) {\n if (def.field === newColDef.field) {\n return { idx: i, column: existingColsCopy[i] };\n }\n continue;\n }\n if (def === newColDef) {\n return { idx: i, column: existingColsCopy[i] };\n }\n }\n return void 0;\n}\nfunction _addColumnDefaultAndTypes(beans, colDef, colId, isAutoCol) {\n const { gos, dataTypeSvc, validation: validation2 } = beans;\n const res = {};\n const defaultColDef = gos.get(\"defaultColDef\");\n _mergeDeep(res, defaultColDef, false, true);\n const columnType = updateColDefAndGetColumnType(beans, res, colDef, colId);\n if (columnType) {\n assignColumnTypes(beans, columnType, res);\n }\n _mergeDeep(res, colDef, false, true);\n const autoGroupColDef = gos.get(\"autoGroupColumnDef\");\n const isSortingCoupled = _isColumnsSortingCoupledToGroup(gos);\n if (colDef.rowGroup && autoGroupColDef && isSortingCoupled) {\n _mergeDeep(\n res,\n { sort: autoGroupColDef.sort, initialSort: autoGroupColDef.initialSort },\n false,\n true\n );\n }\n dataTypeSvc?.validateColDef(res);\n validation2?.validateColDef(res, colId, isAutoCol);\n return res;\n}\nfunction updateColDefAndGetColumnType(beans, colDef, userColDef, colId) {\n const dataTypeDefinitionColumnType = beans.dataTypeSvc?.updateColDefAndGetColumnType(colDef, userColDef, colId);\n const columnTypes = userColDef.type ?? dataTypeDefinitionColumnType ?? colDef.type;\n colDef.type = columnTypes;\n return columnTypes ? convertColumnTypes(columnTypes) : void 0;\n}\nfunction assignColumnTypes(beans, typeKeys, colDefMerged) {\n if (!typeKeys.length) {\n return;\n }\n const allColumnTypes = Object.assign({}, DefaultColumnTypes);\n const userTypes = beans.gos.get(\"columnTypes\") || {};\n for (const key of Object.keys(userTypes)) {\n const value = userTypes[key];\n if (key in allColumnTypes) {\n _warn(34, { key });\n } else {\n const colType = value;\n if (colType.type) {\n _warn(35);\n }\n allColumnTypes[key] = value;\n }\n }\n typeKeys.forEach((t) => {\n const typeColDef = allColumnTypes[t.trim()];\n if (typeColDef) {\n _mergeDeep(colDefMerged, typeColDef, false, true);\n } else {\n _warn(36, { t });\n }\n });\n}\nfunction isColumnGroup(abstractColDef) {\n return abstractColDef.children !== void 0;\n}\nfunction depthFirstOriginalTreeSearch(parent, tree, callback) {\n if (!tree) {\n return;\n }\n for (let i = 0; i < tree.length; i++) {\n const child = tree[i];\n if (isProvidedColumnGroup(child)) {\n depthFirstOriginalTreeSearch(child, child.getChildren(), callback);\n }\n callback(child, parent);\n }\n}\n\n// packages/ag-grid-community/src/columnMove/columnMoveUtils.ts\nfunction placeLockedColumns(cols, gos) {\n const left = [];\n const normal = [];\n const right = [];\n cols.forEach((col) => {\n const position = col.getColDef().lockPosition;\n if (position === \"right\") {\n right.push(col);\n } else if (position === \"left\" || position === true) {\n left.push(col);\n } else {\n normal.push(col);\n }\n });\n const isRtl = gos.get(\"enableRtl\");\n if (isRtl) {\n return [...right, ...normal, ...left];\n }\n return [...left, ...normal, ...right];\n}\nfunction doesMovePassMarryChildren(allColumnsCopy, gridBalancedTree) {\n let rulePassed = true;\n depthFirstOriginalTreeSearch(null, gridBalancedTree, (child) => {\n if (!isProvidedColumnGroup(child)) {\n return;\n }\n const columnGroup = child;\n const colGroupDef = columnGroup.getColGroupDef();\n const marryChildren = colGroupDef && colGroupDef.marryChildren;\n if (!marryChildren) {\n return;\n }\n const newIndexes = [];\n columnGroup.getLeafColumns().forEach((col) => {\n const newColIndex = allColumnsCopy.indexOf(col);\n newIndexes.push(newColIndex);\n });\n const maxIndex = Math.max.apply(Math, newIndexes);\n const minIndex = Math.min.apply(Math, newIndexes);\n const spread = maxIndex - minIndex;\n const maxSpread = columnGroup.getLeafColumns().length - 1;\n if (spread > maxSpread) {\n rulePassed = false;\n }\n });\n return rulePassed;\n}\n\n// packages/ag-grid-community/src/columns/columnEventUtils.ts\nfunction getCommonValue(cols, valueGetter) {\n if (!cols || cols.length == 0) {\n return void 0;\n }\n const firstValue = valueGetter(cols[0]);\n for (let i = 1; i < cols.length; i++) {\n if (firstValue !== valueGetter(cols[i])) {\n return void 0;\n }\n }\n return firstValue;\n}\nfunction dispatchColumnPinnedEvent(eventSvc, changedColumns, source) {\n if (!changedColumns.length) {\n return;\n }\n const column = changedColumns.length === 1 ? changedColumns[0] : null;\n const pinned = getCommonValue(changedColumns, (col) => col.getPinned());\n eventSvc.dispatchEvent({\n type: \"columnPinned\",\n // mistake in typing, 'undefined' should be allowed, as 'null' means 'not pinned'\n pinned: pinned != null ? pinned : null,\n columns: changedColumns,\n column,\n source\n });\n}\nfunction dispatchColumnVisibleEvent(eventSvc, changedColumns, source) {\n if (!changedColumns.length) {\n return;\n }\n const column = changedColumns.length === 1 ? changedColumns[0] : null;\n const visible = getCommonValue(changedColumns, (col) => col.isVisible());\n eventSvc.dispatchEvent({\n type: \"columnVisible\",\n visible,\n columns: changedColumns,\n column,\n source\n });\n}\nfunction dispatchColumnChangedEvent(eventSvc, type, columns, source) {\n eventSvc.dispatchEvent({\n type,\n columns,\n column: columns && columns.length == 1 ? columns[0] : null,\n source\n });\n}\nfunction dispatchColumnResizedEvent(eventSvc, columns, finished, source, flexColumns = null) {\n if (columns?.length) {\n eventSvc.dispatchEvent({\n type: \"columnResized\",\n columns,\n column: columns.length === 1 ? columns[0] : null,\n flexColumns,\n finished,\n source\n });\n }\n}\n\n// packages/ag-grid-community/src/columns/columnStateUtils.ts\nfunction _applyColumnState(beans, params, source) {\n const {\n colModel,\n rowGroupColsSvc,\n pivotColsSvc,\n autoColSvc,\n selectionColSvc,\n colAnimation,\n visibleCols,\n pivotResultCols,\n environment,\n valueColsSvc,\n eventSvc,\n gos\n } = beans;\n const providedCols = colModel.getColDefCols() || [];\n if (!providedCols?.length) {\n return false;\n }\n if (params?.state && !params.state.forEach) {\n _warn(32);\n return false;\n }\n const syncColumnWithStateItem = (column, stateItem, rowGroupIndexes, pivotIndexes, autoCol) => {\n if (!column) {\n return;\n }\n const getValue = getValueFactory(stateItem, params.defaultState);\n const flex = getValue(\"flex\").value1;\n updateSomeColumnState(\n beans,\n column,\n getValue(\"hide\").value1,\n getValue(\"sort\").value1,\n getValue(\"sortIndex\").value1,\n getValue(\"pinned\").value1,\n flex,\n source\n );\n if (flex == null) {\n const width = getValue(\"width\").value1;\n if (width != null) {\n const minColWidth = column.getColDef().minWidth ?? environment.getDefaultColumnMinWidth();\n if (minColWidth != null && width >= minColWidth) {\n column.setActualWidth(width, source);\n }\n }\n }\n if (autoCol || !column.isPrimary()) {\n return;\n }\n valueColsSvc?.syncColumnWithState(column, source, getValue);\n rowGroupColsSvc?.syncColumnWithState(column, source, getValue, rowGroupIndexes);\n pivotColsSvc?.syncColumnWithState(column, source, getValue, pivotIndexes);\n };\n const applyStates = (states, existingColumns, getById2) => {\n const dispatchEventsFunc = _compareColumnStatesAndDispatchEvents(beans, source);\n const columnsWithNoState = existingColumns.slice();\n const rowGroupIndexes = {};\n const pivotIndexes = {};\n const autoColStates = [];\n const selectionColStates = [];\n const unmatchedAndAutoStates2 = [];\n let unmatchedCount2 = 0;\n const previousRowGroupCols = rowGroupColsSvc?.columns.slice() ?? [];\n const previousPivotCols = pivotColsSvc?.columns.slice() ?? [];\n states.forEach((state) => {\n const colId = state.colId;\n const isAutoGroupColumn = colId.startsWith(GROUP_AUTO_COLUMN_ID);\n if (isAutoGroupColumn) {\n autoColStates.push(state);\n unmatchedAndAutoStates2.push(state);\n return;\n }\n if (isColumnSelectionCol(colId)) {\n selectionColStates.push(state);\n unmatchedAndAutoStates2.push(state);\n return;\n }\n const column = getById2(colId);\n if (!column) {\n unmatchedAndAutoStates2.push(state);\n unmatchedCount2 += 1;\n } else {\n syncColumnWithStateItem(column, state, rowGroupIndexes, pivotIndexes, false);\n _removeFromArray(columnsWithNoState, column);\n }\n });\n const applyDefaultsFunc = (col) => syncColumnWithStateItem(col, null, rowGroupIndexes, pivotIndexes, false);\n columnsWithNoState.forEach(applyDefaultsFunc);\n rowGroupColsSvc?.sortColumns(comparatorByIndex.bind(rowGroupColsSvc, rowGroupIndexes, previousRowGroupCols));\n pivotColsSvc?.sortColumns(comparatorByIndex.bind(pivotColsSvc, pivotIndexes, previousPivotCols));\n colModel.refreshCols(false);\n const syncColStates = (getCol, colStates, columns = []) => {\n colStates.forEach((stateItem) => {\n const col = getCol(stateItem.colId);\n _removeFromArray(columns, col);\n syncColumnWithStateItem(col, stateItem, null, null, true);\n });\n columns.forEach(applyDefaultsFunc);\n };\n syncColStates(\n (colId) => autoColSvc?.getColumn(colId) ?? null,\n autoColStates,\n autoColSvc?.getColumns()?.slice()\n );\n syncColStates(\n (colId) => selectionColSvc?.getColumn(colId) ?? null,\n selectionColStates,\n selectionColSvc?.getColumns()?.slice()\n );\n orderLiveColsLikeState(params, colModel, gos);\n visibleCols.refresh(source);\n eventSvc.dispatchEvent({\n type: \"columnEverythingChanged\",\n source\n });\n dispatchEventsFunc();\n return { unmatchedAndAutoStates: unmatchedAndAutoStates2, unmatchedCount: unmatchedCount2 };\n };\n colAnimation?.start();\n let { unmatchedAndAutoStates, unmatchedCount } = applyStates(\n params.state || [],\n providedCols,\n (id) => colModel.getColDefCol(id)\n );\n if (unmatchedAndAutoStates.length > 0 || _exists(params.defaultState)) {\n const pivotResultColsList = pivotResultCols?.getPivotResultCols()?.list ?? [];\n unmatchedCount = applyStates(\n unmatchedAndAutoStates,\n pivotResultColsList,\n (id) => pivotResultCols?.getPivotResultCol(id) ?? null\n ).unmatchedCount;\n }\n colAnimation?.finish();\n return unmatchedCount === 0;\n}\nfunction _resetColumnState(beans, source) {\n const { colModel, autoColSvc } = beans;\n const primaryCols = colModel.getColDefCols();\n if (!primaryCols?.length) {\n return;\n }\n const primaryColumnTree = colModel.getColDefColTree();\n const primaryColumns = _getColumnsFromTree(primaryColumnTree);\n const columnStates = [];\n let letRowGroupIndex = 1e3;\n let letPivotIndex = 1e3;\n let colsToProcess = [];\n const groupAutoCols = autoColSvc?.getColumns();\n if (groupAutoCols) {\n colsToProcess = colsToProcess.concat(groupAutoCols);\n }\n if (primaryColumns) {\n colsToProcess = colsToProcess.concat(primaryColumns);\n }\n colsToProcess.forEach((column) => {\n const stateItem = getColumnStateFromColDef(column);\n if (_missing(stateItem.rowGroupIndex) && stateItem.rowGroup) {\n stateItem.rowGroupIndex = letRowGroupIndex++;\n }\n if (_missing(stateItem.pivotIndex) && stateItem.pivot) {\n stateItem.pivotIndex = letPivotIndex++;\n }\n columnStates.push(stateItem);\n });\n _applyColumnState(beans, { state: columnStates, applyOrder: true }, source);\n}\nfunction _compareColumnStatesAndDispatchEvents(beans, source) {\n const { rowGroupColsSvc, pivotColsSvc, valueColsSvc, colModel, sortSvc, eventSvc } = beans;\n const startState = {\n rowGroupColumns: rowGroupColsSvc?.columns.slice() ?? [],\n pivotColumns: pivotColsSvc?.columns.slice() ?? [],\n valueColumns: valueColsSvc?.columns.slice() ?? []\n };\n const columnStateBefore = _getColumnState(beans);\n const columnStateBeforeMap = {};\n columnStateBefore.forEach((col) => {\n columnStateBeforeMap[col.colId] = col;\n });\n return () => {\n const colsForState = colModel.getAllCols();\n const dispatchWhenListsDifferent = (eventType, colsBefore, colsAfter, idMapper) => {\n const beforeList = colsBefore.map(idMapper);\n const afterList = colsAfter.map(idMapper);\n const unchanged = _areEqual(beforeList, afterList);\n if (unchanged) {\n return;\n }\n const changes = new Set(colsBefore);\n colsAfter.forEach((id) => {\n if (!changes.delete(id)) {\n changes.add(id);\n }\n });\n const changesArr = [...changes];\n eventSvc.dispatchEvent({\n type: eventType,\n columns: changesArr,\n column: changesArr.length === 1 ? changesArr[0] : null,\n source\n });\n };\n const getChangedColumns = (changedPredicate) => {\n const changedColumns2 = [];\n colsForState.forEach((column) => {\n const colStateBefore = columnStateBeforeMap[column.getColId()];\n if (colStateBefore && changedPredicate(colStateBefore, column)) {\n changedColumns2.push(column);\n }\n });\n return changedColumns2;\n };\n const columnIdMapper = (c) => c.getColId();\n dispatchWhenListsDifferent(\n \"columnRowGroupChanged\",\n startState.rowGroupColumns,\n rowGroupColsSvc?.columns ?? [],\n columnIdMapper\n );\n dispatchWhenListsDifferent(\n \"columnPivotChanged\",\n startState.pivotColumns,\n pivotColsSvc?.columns ?? [],\n columnIdMapper\n );\n const valueChangePredicate = (cs, c) => {\n const oldActive = cs.aggFunc != null;\n const activeChanged = oldActive != c.isValueActive();\n const aggFuncChanged = oldActive && cs.aggFunc != c.getAggFunc();\n return activeChanged || aggFuncChanged;\n };\n const changedValues = getChangedColumns(valueChangePredicate);\n if (changedValues.length > 0) {\n dispatchColumnChangedEvent(eventSvc, \"columnValueChanged\", changedValues, source);\n }\n const resizeChangePredicate = (cs, c) => cs.width != c.getActualWidth();\n dispatchColumnResizedEvent(eventSvc, getChangedColumns(resizeChangePredicate), true, source);\n const pinnedChangePredicate = (cs, c) => cs.pinned != c.getPinned();\n dispatchColumnPinnedEvent(eventSvc, getChangedColumns(pinnedChangePredicate), source);\n const visibilityChangePredicate = (cs, c) => cs.hide == c.isVisible();\n dispatchColumnVisibleEvent(eventSvc, getChangedColumns(visibilityChangePredicate), source);\n const sortChangePredicate = (cs, c) => cs.sort != c.getSort() || cs.sortIndex != c.getSortIndex();\n const changedColumns = getChangedColumns(sortChangePredicate);\n if (changedColumns.length > 0) {\n sortSvc?.dispatchSortChangedEvents(source, changedColumns);\n }\n const colStateAfter = _getColumnState(beans);\n normaliseColumnMovedEventForColumnState(columnStateBefore, colStateAfter, source, colModel, eventSvc);\n };\n}\nfunction _getColumnState(beans) {\n const { colModel, rowGroupColsSvc, pivotColsSvc } = beans;\n const primaryCols = colModel.getColDefCols();\n if (_missing(primaryCols) || !colModel.isAlive()) {\n return [];\n }\n const colsForState = colModel.getAllCols();\n const rowGroupColumns = rowGroupColsSvc?.columns;\n const pivotColumns = pivotColsSvc?.columns;\n const createStateItemFromColumn = (column) => {\n const rowGroupIndex = column.isRowGroupActive() && rowGroupColumns ? rowGroupColumns.indexOf(column) : null;\n const pivotIndex = column.isPivotActive() && pivotColumns ? pivotColumns.indexOf(column) : null;\n const aggFunc = column.isValueActive() ? column.getAggFunc() : null;\n const sort = column.getSort() != null ? column.getSort() : null;\n const sortIndex = column.getSortIndex() != null ? column.getSortIndex() : null;\n const res2 = {\n colId: column.getColId(),\n width: column.getActualWidth(),\n hide: !column.isVisible(),\n pinned: column.getPinned(),\n sort,\n sortIndex,\n aggFunc,\n rowGroup: column.isRowGroupActive(),\n rowGroupIndex,\n pivot: column.isPivotActive(),\n pivotIndex,\n flex: column.getFlex() ?? null\n };\n return res2;\n };\n const res = colsForState.map((col) => createStateItemFromColumn(col));\n const colIdToGridIndexMap = new Map(\n colModel.getCols().map((col, index) => [col.getColId(), index])\n );\n res.sort((itemA, itemB) => {\n const posA = colIdToGridIndexMap.has(itemA.colId) ? colIdToGridIndexMap.get(itemA.colId) : -1;\n const posB = colIdToGridIndexMap.has(itemB.colId) ? colIdToGridIndexMap.get(itemB.colId) : -1;\n return posA - posB;\n });\n return res;\n}\nfunction getColumnStateFromColDef(column) {\n const getValueOrNull = (a, b) => a != null ? a : b != null ? b : null;\n const colDef = column.getColDef();\n const sort = getValueOrNull(colDef.sort, colDef.initialSort);\n const sortIndex = getValueOrNull(colDef.sortIndex, colDef.initialSortIndex);\n const hide = getValueOrNull(colDef.hide, colDef.initialHide);\n const pinned = getValueOrNull(colDef.pinned, colDef.initialPinned);\n const width = getValueOrNull(colDef.width, colDef.initialWidth);\n const flex = getValueOrNull(colDef.flex, colDef.initialFlex);\n let rowGroupIndex = getValueOrNull(colDef.rowGroupIndex, colDef.initialRowGroupIndex);\n let rowGroup = getValueOrNull(colDef.rowGroup, colDef.initialRowGroup);\n if (rowGroupIndex == null && (rowGroup == null || rowGroup == false)) {\n rowGroupIndex = null;\n rowGroup = null;\n }\n let pivotIndex = getValueOrNull(colDef.pivotIndex, colDef.initialPivotIndex);\n let pivot = getValueOrNull(colDef.pivot, colDef.initialPivot);\n if (pivotIndex == null && (pivot == null || pivot == false)) {\n pivotIndex = null;\n pivot = null;\n }\n const aggFunc = getValueOrNull(colDef.aggFunc, colDef.initialAggFunc);\n return {\n colId: column.getColId(),\n sort,\n sortIndex,\n hide,\n pinned,\n width,\n flex,\n rowGroup,\n rowGroupIndex,\n pivot,\n pivotIndex,\n aggFunc\n };\n}\nfunction orderLiveColsLikeState(params, colModel, gos) {\n if (!params.applyOrder || !params.state) {\n return;\n }\n const colIds = [];\n params.state.forEach((item) => {\n if (item.colId != null) {\n colIds.push(item.colId);\n }\n });\n sortColsLikeKeys(colModel.cols, colIds, colModel, gos);\n}\nfunction sortColsLikeKeys(cols, colIds, colModel, gos) {\n if (cols == null) {\n return;\n }\n let newOrder = [];\n const processedColIds = {};\n colIds.forEach((colId) => {\n if (processedColIds[colId]) {\n return;\n }\n const col = cols.map[colId];\n if (col) {\n newOrder.push(col);\n processedColIds[colId] = true;\n }\n });\n let autoGroupInsertIndex = 0;\n cols.list.forEach((col) => {\n const colId = col.getColId();\n const alreadyProcessed = processedColIds[colId] != null;\n if (alreadyProcessed) {\n return;\n }\n const isAutoGroupCol = colId.startsWith(GROUP_AUTO_COLUMN_ID);\n if (isAutoGroupCol) {\n newOrder.splice(autoGroupInsertIndex++, 0, col);\n } else {\n newOrder.push(col);\n }\n });\n newOrder = placeLockedColumns(newOrder, gos);\n if (!doesMovePassMarryChildren(newOrder, colModel.getColTree())) {\n _warn(39);\n return;\n }\n cols.list = newOrder;\n}\nfunction normaliseColumnMovedEventForColumnState(colStateBefore, colStateAfter, source, colModel, eventSvc) {\n const colStateAfterMapped = {};\n colStateAfter.forEach((s) => colStateAfterMapped[s.colId] = s);\n const colsIntersectIds = {};\n colStateBefore.forEach((s) => {\n if (colStateAfterMapped[s.colId]) {\n colsIntersectIds[s.colId] = true;\n }\n });\n const beforeFiltered = colStateBefore.filter((c) => colsIntersectIds[c.colId]);\n const afterFiltered = colStateAfter.filter((c) => colsIntersectIds[c.colId]);\n const movedColumns = [];\n afterFiltered.forEach((csAfter, index) => {\n const csBefore = beforeFiltered && beforeFiltered[index];\n if (csBefore && csBefore.colId !== csAfter.colId) {\n const gridCol = colModel.getCol(csBefore.colId);\n if (gridCol) {\n movedColumns.push(gridCol);\n }\n }\n });\n if (!movedColumns.length) {\n return;\n }\n eventSvc.dispatchEvent({\n type: \"columnMoved\",\n columns: movedColumns,\n column: movedColumns.length === 1 ? movedColumns[0] : null,\n finished: true,\n source\n });\n}\nvar comparatorByIndex = (indexes, oldList, colA, colB) => {\n const indexA = indexes[colA.getId()];\n const indexB = indexes[colB.getId()];\n const aHasIndex = indexA != null;\n const bHasIndex = indexB != null;\n if (aHasIndex && bHasIndex) {\n return indexA - indexB;\n }\n if (aHasIndex) {\n return -1;\n }\n if (bHasIndex) {\n return 1;\n }\n const oldIndexA = oldList.indexOf(colA);\n const oldIndexB = oldList.indexOf(colB);\n const aHasOldIndex = oldIndexA >= 0;\n const bHasOldIndex = oldIndexB >= 0;\n if (aHasOldIndex && bHasOldIndex) {\n return oldIndexA - oldIndexB;\n }\n if (aHasOldIndex) {\n return -1;\n }\n return 1;\n};\n\n// packages/ag-grid-community/src/columns/columnModel.ts\nvar ColumnModel = class extends BeanStub {\n constructor() {\n super(...arguments);\n this.beanName = \"colModel\";\n // if pivotMode is on, however pivot results are NOT shown if no pivot columns are set\n this.pivotMode = false;\n this.ready = false;\n this.changeEventsDispatching = false;\n }\n postConstruct() {\n this.pivotMode = this.gos.get(\"pivotMode\");\n this.addManagedPropertyListeners(\n [\"groupDisplayType\", \"treeData\", \"treeDataDisplayType\", \"groupHideOpenParents\"],\n (event) => this.refreshAll(_convertColumnEventSourceType(event.source))\n );\n this.addManagedPropertyListeners(\n [\"defaultColDef\", \"defaultColGroupDef\", \"columnTypes\", \"suppressFieldDotNotation\"],\n this.recreateColumnDefs.bind(this)\n );\n this.addManagedPropertyListener(\n \"pivotMode\",\n (event) => this.setPivotMode(this.gos.get(\"pivotMode\"), _convertColumnEventSourceType(event.source))\n );\n }\n // called from SyncService, when grid has finished initialising\n createColsFromColDefs(source) {\n const { beans } = this;\n const {\n valueCache,\n colAutosize,\n rowGroupColsSvc,\n pivotColsSvc,\n valueColsSvc,\n visibleCols,\n colViewport,\n eventSvc\n } = beans;\n const dispatchEventsFunc = this.colDefs ? _compareColumnStatesAndDispatchEvents(beans, source) : void 0;\n valueCache?.expire();\n const oldCols = this.colDefCols?.list;\n const oldTree = this.colDefCols?.tree;\n const newTree = _createColumnTree(beans, this.colDefs, true, oldTree, source);\n _destroyColumnTree(beans, this.colDefCols?.tree, newTree.columnTree);\n const tree = newTree.columnTree;\n const treeDepth = newTree.treeDept;\n const list = _getColumnsFromTree(tree);\n const map = {};\n list.forEach((col) => map[col.getId()] = col);\n this.colDefCols = { tree, treeDepth, list, map };\n rowGroupColsSvc?.extractCols(source, oldCols);\n pivotColsSvc?.extractCols(source, oldCols);\n valueColsSvc?.extractCols(source, oldCols);\n this.ready = true;\n this.refreshCols(true);\n visibleCols.refresh(source);\n colViewport.checkViewportColumns();\n eventSvc.dispatchEvent({\n type: \"columnEverythingChanged\",\n source\n });\n if (dispatchEventsFunc) {\n this.changeEventsDispatching = true;\n dispatchEventsFunc();\n this.changeEventsDispatching = false;\n }\n eventSvc.dispatchEvent({\n type: \"newColumnsLoaded\",\n source\n });\n if (source === \"gridInitializing\") {\n colAutosize?.applyAutosizeStrategy();\n }\n }\n // called from: buildAutoGroupColumns (events 'groupDisplayType', 'treeData', 'treeDataDisplayType', 'groupHideOpenParents')\n // createColsFromColDefs (recreateColumnDefs, setColumnsDefs),\n // setPivotMode, applyColumnState,\n // functionColsService.setPrimaryColList, functionColsService.updatePrimaryColList,\n // pivotResultCols.setPivotResultCols\n refreshCols(newColDefs) {\n if (!this.colDefCols) {\n return;\n }\n const prevColTree = this.cols?.tree;\n this.saveColOrder();\n const {\n autoColSvc,\n selectionColSvc,\n rowNumbersSvc,\n quickFilter,\n pivotResultCols,\n showRowGroupCols,\n rowAutoHeight,\n visibleCols,\n colViewport,\n eventSvc\n } = this.beans;\n const cols = this.selectCols(pivotResultCols, this.colDefCols);\n this.createColumnsForService([autoColSvc, selectionColSvc, rowNumbersSvc], cols);\n const shouldSortNewColDefs = _shouldMaintainColumnOrder(this.gos, this.showingPivotResult);\n if (!newColDefs || shouldSortNewColDefs) {\n this.restoreColOrder(cols);\n }\n this.positionLockedCols(cols);\n showRowGroupCols?.refresh();\n quickFilter?.refreshCols();\n this.setColSpanActive();\n rowAutoHeight?.setAutoHeightActive(cols);\n visibleCols.clear();\n colViewport.clear();\n const dispatchChangedEvent = !_areEqual(prevColTree, this.cols.tree);\n if (dispatchChangedEvent) {\n eventSvc.dispatchEvent({\n type: \"gridColumnsChanged\"\n });\n }\n }\n createColumnsForService(services, cols) {\n for (const service of services) {\n if (!service) {\n continue;\n }\n service.createColumns(cols, (updateOrder) => {\n this.lastOrder = updateOrder(this.lastOrder);\n this.lastPivotOrder = updateOrder(this.lastPivotOrder);\n });\n service.addColumns(cols);\n }\n }\n selectCols(pivotResultColsSvc, colDefCols) {\n const pivotResultCols = pivotResultColsSvc?.getPivotResultCols() ?? null;\n this.showingPivotResult = pivotResultCols != null;\n const { map, list, tree, treeDepth } = pivotResultCols ?? colDefCols;\n this.cols = {\n list: list.slice(),\n map: { ...map },\n tree: tree.slice(),\n treeDepth\n };\n if (pivotResultCols) {\n const hasSameColumns = pivotResultCols.list.some((col) => this.cols?.map[col.getColId()] !== void 0);\n if (!hasSameColumns) {\n this.lastPivotOrder = null;\n }\n }\n return this.cols;\n }\n getColsToShow() {\n if (!this.cols) {\n return [];\n }\n const showAutoGroupAndValuesOnly = this.isPivotMode() && !this.showingPivotResult;\n const valueColumns = this.beans.valueColsSvc?.columns;\n const res = this.cols.list.filter((col) => {\n const isAutoGroupCol = isColumnGroupAutoCol(col);\n if (showAutoGroupAndValuesOnly) {\n const isValueCol = valueColumns?.includes(col);\n return isAutoGroupCol || isValueCol;\n } else {\n return isAutoGroupCol || col.isVisible();\n }\n });\n return res;\n }\n // on events 'groupDisplayType', 'treeData', 'treeDataDisplayType', 'groupHideOpenParents'\n refreshAll(source) {\n if (!this.ready) {\n return;\n }\n this.refreshCols(false);\n this.beans.visibleCols.refresh(source);\n }\n setColsVisible(keys, visible = false, source) {\n _applyColumnState(\n this.beans,\n {\n state: keys.map((key) => ({\n colId: typeof key === \"string\" ? key : key.getColId(),\n hide: !visible\n }))\n },\n source\n );\n }\n restoreColOrder(cols) {\n const lastOrder = this.showingPivotResult ? this.lastPivotOrder : this.lastOrder;\n if (!lastOrder) {\n return;\n }\n const lastOrderMapped = new Map(lastOrder.map((col, index) => [col, index]));\n const noColsFound = !cols.list.some((col) => lastOrderMapped.has(col));\n if (noColsFound) {\n return;\n }\n const colsMap = new Map(cols.list.map((col) => [col, true]));\n const lastOrderFiltered = lastOrder.filter((col) => colsMap.has(col));\n const lastOrderFilteredMap = new Map(lastOrderFiltered.map((col) => [col, true]));\n const missingFromLastOrder = cols.list.filter((col) => !lastOrderFilteredMap.has(col));\n const res = lastOrderFiltered.slice();\n missingFromLastOrder.forEach((newCol) => {\n let parent = newCol.getOriginalParent();\n if (!parent) {\n res.push(newCol);\n return;\n }\n const siblings = [];\n while (!siblings.length && parent) {\n const leafCols = parent.getLeafColumns();\n leafCols.forEach((leafCol) => {\n const presentInNewCols = res.indexOf(leafCol) >= 0;\n const notYetInSiblings = siblings.indexOf(leafCol) < 0;\n if (presentInNewCols && notYetInSiblings) {\n siblings.push(leafCol);\n }\n });\n parent = parent.getOriginalParent();\n }\n if (!siblings.length) {\n res.push(newCol);\n return;\n }\n const indexes = siblings.map((col) => res.indexOf(col));\n const lastIndex = Math.max(...indexes);\n res.splice(lastIndex + 1, 0, newCol);\n });\n cols.list = res;\n }\n positionLockedCols(cols) {\n cols.list = placeLockedColumns(cols.list, this.gos);\n }\n saveColOrder() {\n if (this.showingPivotResult) {\n this.lastPivotOrder = this.cols?.list ?? null;\n } else {\n this.lastOrder = this.cols?.list ?? null;\n }\n }\n getColumnDefs() {\n return this.colDefCols ? this.beans.colDefFactory?.getColumnDefs(\n this.colDefCols.list,\n this.showingPivotResult,\n this.lastOrder,\n this.cols?.list ?? []\n ) : void 0;\n }\n setColSpanActive() {\n this.colSpanActive = !!this.cols?.list.some((col) => col.getColDef().colSpan != null);\n }\n isPivotMode() {\n return this.pivotMode;\n }\n setPivotMode(pivotMode, source) {\n if (pivotMode === this.pivotMode) {\n return;\n }\n this.pivotMode = pivotMode;\n if (!this.ready) {\n return;\n }\n this.refreshCols(false);\n const { visibleCols, eventSvc } = this.beans;\n visibleCols.refresh(source);\n eventSvc.dispatchEvent({\n type: \"columnPivotModeChanged\"\n });\n }\n // + clientSideRowModel\n isPivotActive() {\n const pivotColumns = this.beans.pivotColsSvc?.columns;\n return this.pivotMode && !!pivotColumns?.length;\n }\n // called when dataTypes change\n recreateColumnDefs(e) {\n if (!this.cols) {\n return;\n }\n this.beans.autoColSvc?.updateColumns(e);\n const source = _convertColumnEventSourceType(e.source);\n this.createColsFromColDefs(source);\n }\n setColumnDefs(columnDefs, source) {\n this.colDefs = columnDefs;\n this.createColsFromColDefs(source);\n }\n destroy() {\n _destroyColumnTree(this.beans, this.colDefCols?.tree);\n super.destroy();\n }\n getColTree() {\n return this.cols?.tree ?? [];\n }\n // + columnSelectPanel\n getColDefColTree() {\n return this.colDefCols?.tree ?? [];\n }\n // + clientSideRowController -> sorting, building quick filter text\n // + headerRenderer -> sorting (clearing icon)\n getColDefCols() {\n return this.colDefCols?.list ?? null;\n }\n // + moveColumnController\n getCols() {\n return this.cols?.list ?? [];\n }\n // returns colDefCols, pivotResultCols and autoCols\n getAllCols() {\n const { pivotResultCols, autoColSvc, selectionColSvc } = this.beans;\n const pivotResultColsList = pivotResultCols?.getPivotResultCols()?.list;\n return [\n this.colDefCols?.list ?? [],\n autoColSvc?.columns?.list ?? [],\n selectionColSvc?.columns?.list ?? [],\n pivotResultColsList ?? []\n ].flat();\n }\n getColsForKeys(keys) {\n if (!keys) {\n return [];\n }\n return keys.map((key) => this.getCol(key)).filter((col) => col != null);\n }\n getColDefCol(key) {\n if (!this.colDefCols?.list) {\n return null;\n }\n return this.getColFromCollection(key, this.colDefCols);\n }\n getCol(key) {\n if (key == null) {\n return null;\n }\n return this.getColFromCollection(key, this.cols);\n }\n getColFromCollection(key, cols) {\n if (cols == null) {\n return null;\n }\n const { map, list } = cols;\n if (typeof key == \"string\" && map[key]) {\n return map[key];\n }\n for (let i = 0; i < list.length; i++) {\n if (_columnsMatch(list[i], key)) {\n return list[i];\n }\n }\n return this.beans.autoColSvc?.getColumn(key) ?? this.beans.selectionColSvc?.getColumn(key) ?? null;\n }\n};\n\n// packages/ag-grid-community/src/columns/baseColsService.ts\nvar BaseColsService = class extends BeanStub {\n constructor() {\n super(...arguments);\n this.dispatchColumnChangedEvent = dispatchColumnChangedEvent;\n this.columns = [];\n }\n wireBeans(beans) {\n this.colModel = beans.colModel;\n this.aggFuncSvc = beans.aggFuncSvc;\n this.visibleCols = beans.visibleCols;\n }\n sortColumns(compareFn) {\n this.columns.sort(compareFn);\n }\n setColumns(colKeys, source) {\n this.setColList(colKeys, this.columns, this.eventName, true, true, this.columnProcessors.set, source);\n }\n addColumns(colKeys, source) {\n this.updateColList(colKeys, this.columns, true, true, this.columnProcessors.add, this.eventName, source);\n }\n removeColumns(colKeys, source) {\n this.updateColList(colKeys, this.columns, false, true, this.columnProcessors.remove, this.eventName, source);\n }\n setColList(colKeys = [], masterList, eventName, detectOrderChange, autoGroupsNeedBuilding, columnCallback, source) {\n const gridColumns = this.colModel.getCols();\n if (!gridColumns || gridColumns.length === 0) {\n return;\n }\n const changes = /* @__PURE__ */ new Map();\n masterList.forEach((col, idx) => changes.set(col, idx));\n masterList.length = 0;\n if (_exists(colKeys)) {\n colKeys.forEach((key) => {\n const column = this.colModel.getColDefCol(key);\n if (column) {\n masterList.push(column);\n }\n });\n }\n masterList.forEach((col, idx) => {\n const oldIndex = changes.get(col);\n if (oldIndex === void 0) {\n changes.set(col, 0);\n return;\n }\n if (detectOrderChange && oldIndex !== idx) {\n return;\n }\n changes.delete(col);\n });\n const primaryCols = this.colModel.getColDefCols();\n (primaryCols || []).forEach((column) => {\n const added = masterList.indexOf(column) >= 0;\n columnCallback(column, added, source);\n });\n autoGroupsNeedBuilding && this.colModel.refreshCols(false);\n this.visibleCols.refresh(source);\n this.dispatchColumnChangedEvent(this.eventSvc, eventName, [...changes.keys()], source);\n }\n updateColList(keys = [], masterList, actionIsAdd, autoGroupsNeedBuilding, columnCallback, eventType, source) {\n if (!keys || keys.length === 0) {\n return;\n }\n let atLeastOne = false;\n const updatedCols = /* @__PURE__ */ new Set();\n keys.forEach((key) => {\n if (!key) {\n return;\n }\n const columnToAdd = this.colModel.getColDefCol(key);\n if (!columnToAdd) {\n return;\n }\n updatedCols.add(columnToAdd);\n if (actionIsAdd) {\n if (masterList.indexOf(columnToAdd) >= 0) {\n return;\n }\n masterList.push(columnToAdd);\n } else {\n const currentIndex = masterList.indexOf(columnToAdd);\n if (currentIndex < 0) {\n return;\n }\n for (let i = currentIndex + 1; i < masterList.length; i++) {\n updatedCols.add(masterList[i]);\n }\n _removeFromArray(masterList, columnToAdd);\n }\n columnCallback(columnToAdd, actionIsAdd, source);\n atLeastOne = true;\n });\n if (!atLeastOne) {\n return;\n }\n if (autoGroupsNeedBuilding) {\n this.colModel.refreshCols(false);\n }\n this.visibleCols.refresh(source);\n const eventColumns = Array.from(updatedCols);\n this.eventSvc.dispatchEvent({\n type: eventType,\n columns: eventColumns,\n column: eventColumns.length === 1 ? eventColumns[0] : null,\n source\n });\n }\n extractCols(source, oldProvidedCols = []) {\n const previousCols = this.columns;\n const colsWithIndex = [];\n const colsWithValue = [];\n const { setFlagFunc, getIndexFunc, getInitialIndexFunc, getValueFunc, getInitialValueFunc } = this.columnExtractors;\n const primaryCols = this.colModel.getColDefCols() || [];\n primaryCols.forEach((col) => {\n const colIsNew = oldProvidedCols.indexOf(col) < 0;\n const colDef = col.getColDef();\n const value = getValueFunc(colDef);\n const initialValue = getInitialValueFunc(colDef);\n const index = getIndexFunc(colDef);\n const initialIndex = getInitialIndexFunc(colDef);\n let include;\n const valuePresent = value !== void 0;\n const indexPresent = index !== void 0;\n const initialValuePresent = initialValue !== void 0;\n const initialIndexPresent = initialIndex !== void 0;\n if (valuePresent) {\n include = value;\n } else if (indexPresent) {\n if (index === null) {\n include = false;\n } else {\n include = index >= 0;\n }\n } else {\n if (colIsNew) {\n if (initialValuePresent) {\n include = initialValue;\n } else if (initialIndexPresent) {\n include = initialIndex != null && initialIndex >= 0;\n } else {\n include = false;\n }\n } else {\n include = previousCols.indexOf(col) >= 0;\n }\n }\n if (include) {\n const useIndex = colIsNew ? index != null || initialIndex != null : index != null;\n useIndex ? colsWithIndex.push(col) : colsWithValue.push(col);\n }\n });\n const getIndexForCol = (col) => {\n const index = getIndexFunc(col.getColDef());\n const defaultIndex = getInitialIndexFunc(col.getColDef());\n return index != null ? index : defaultIndex;\n };\n colsWithIndex.sort((colA, colB) => {\n const indexA = getIndexForCol(colA);\n const indexB = getIndexForCol(colB);\n if (indexA === indexB) {\n return 0;\n }\n if (indexA < indexB) {\n return -1;\n }\n return 1;\n });\n const res = [].concat(colsWithIndex);\n previousCols.forEach((col) => {\n if (colsWithValue.indexOf(col) >= 0) {\n res.push(col);\n }\n });\n colsWithValue.forEach((col) => {\n if (res.indexOf(col) < 0) {\n res.push(col);\n }\n });\n previousCols.forEach((col) => {\n if (res.indexOf(col) < 0) {\n setFlagFunc(col, false, source);\n }\n });\n res.forEach((col) => {\n if (previousCols.indexOf(col) < 0) {\n setFlagFunc(col, true, source);\n }\n });\n return this.columns = res;\n }\n restoreColumnOrder(columnStateAccumulator, incomingColumnState) {\n const colList = this.columns;\n const primaryCols = this.colModel.getColDefCols();\n if (!colList.length || !primaryCols) {\n return columnStateAccumulator;\n }\n const updatedColIdArray = Object.keys(incomingColumnState);\n const updatedColIds = new Set(updatedColIdArray);\n const newColIds = new Set(updatedColIdArray);\n const allColIds = new Set(\n colList.map((column) => {\n const colId = column.getColId();\n newColIds.delete(colId);\n return colId;\n }).concat(updatedColIdArray)\n );\n const colIdsInOriginalOrder = [];\n const originalOrderMap = {};\n let orderIndex = 0;\n for (let i = 0; i < primaryCols.length; i++) {\n const colId = primaryCols[i].getColId();\n if (allColIds.has(colId)) {\n colIdsInOriginalOrder.push(colId);\n originalOrderMap[colId] = orderIndex++;\n }\n }\n let index = 1e3;\n let hasAddedNewCols = false;\n let lastIndex = 0;\n const enableProp = this.columnOrdering.enableProp;\n const initialEnableProp = this.columnOrdering.initialEnableProp;\n const indexProp = this.columnOrdering.indexProp;\n const initialIndexProp = this.columnOrdering.initialIndexProp;\n const processPrecedingNewCols = (colId) => {\n const originalOrderIndex = originalOrderMap[colId];\n for (let i = lastIndex; i < originalOrderIndex; i++) {\n const newColId = colIdsInOriginalOrder[i];\n if (newColIds.has(newColId)) {\n incomingColumnState[newColId][indexProp] = index++;\n newColIds.delete(newColId);\n }\n }\n lastIndex = originalOrderIndex;\n };\n colList.forEach((column) => {\n const colId = column.getColId();\n if (updatedColIds.has(colId)) {\n processPrecedingNewCols(colId);\n incomingColumnState[colId][indexProp] = index++;\n } else {\n const colDef = column.getColDef();\n const missingIndex = colDef[indexProp] === null || colDef[indexProp] === void 0 && colDef[initialIndexProp] == null;\n if (missingIndex) {\n if (!hasAddedNewCols) {\n const propEnabled = colDef[enableProp] || colDef[enableProp] === void 0 && colDef[initialEnableProp];\n if (propEnabled) {\n processPrecedingNewCols(colId);\n } else {\n newColIds.forEach((newColId) => {\n incomingColumnState[newColId][indexProp] = index + originalOrderMap[newColId];\n });\n index += colIdsInOriginalOrder.length;\n hasAddedNewCols = true;\n }\n }\n if (!columnStateAccumulator[colId]) {\n columnStateAccumulator[colId] = { colId };\n }\n columnStateAccumulator[colId][indexProp] = index++;\n }\n }\n });\n return columnStateAccumulator;\n }\n};\n\n// packages/ag-grid-community/src/columns/groupInstanceIdCreator.ts\nvar GroupInstanceIdCreator = class {\n constructor() {\n // this map contains keys to numbers, so we remember what the last call was\n this.existingIds = {};\n }\n getInstanceIdForKey(key) {\n const lastResult = this.existingIds[key];\n let result;\n if (typeof lastResult !== \"number\") {\n result = 0;\n } else {\n result = lastResult + 1;\n }\n this.existingIds[key] = result;\n return result;\n }\n};\n\n// packages/ag-grid-community/src/components/emptyBean.ts\nvar EmptyBean = class extends BeanStub {\n};\nfunction setupCompBean(ctrl, ctx, compBean) {\n if (compBean) {\n ctrl.addDestroyFunc(() => ctx.destroyBean(compBean));\n }\n return compBean ?? ctrl;\n}\n\n// packages/ag-grid-community/src/rendering/cssClassManager.ts\nvar CssClassManager = class {\n constructor(getGui) {\n // to minimise DOM hits, we only apply CSS classes if they have changed. as adding a CSS class that is already\n // there, or removing one that wasn't present, all takes CPU.\n this.cssClassStates = {};\n this.getGui = getGui;\n }\n addCssClass(className) {\n this.addOrRemoveCssClass(className, true);\n }\n removeCssClass(className) {\n this.addOrRemoveCssClass(className, false);\n }\n containsCssClass(className) {\n const eGui = this.getGui();\n if (!eGui) {\n return false;\n }\n return eGui.classList.contains(className);\n }\n addOrRemoveCssClass(className, addOrRemove) {\n if (!className) {\n return;\n }\n if (className.indexOf(\" \") >= 0) {\n const list = (className || \"\").split(\" \");\n if (list.length > 1) {\n list.forEach((cls) => this.addOrRemoveCssClass(cls, addOrRemove));\n return;\n }\n }\n const updateNeeded = this.cssClassStates[className] !== addOrRemove;\n if (updateNeeded && className.length) {\n const eGui = this.getGui();\n if (eGui) {\n eGui.classList.toggle(className, addOrRemove);\n }\n this.cssClassStates[className] = addOrRemove;\n }\n }\n};\n\n// packages/ag-grid-community/src/widgets/component.ts\nvar compIdSequence = 0;\nvar RefPlaceholder = null;\nvar Component = class extends BeanStub {\n constructor(template, componentSelectors) {\n super();\n this.suppressDataRefValidation = false;\n // if false, then CSS class \"ag-hidden\" is applied, which sets \"display: none\"\n this.displayed = true;\n // if false, then CSS class \"ag-invisible\" is applied, which sets \"visibility: hidden\"\n this.visible = true;\n // unique id for this row component. this is used for getting a reference to the HTML dom.\n // we cannot use the RowNode id as this is not unique (due to animation, old rows can be lying\n // around as we create a new rowComp instance for the same row node).\n this.compId = compIdSequence++;\n this.cssClassManager = new CssClassManager(() => this.eGui);\n this.componentSelectors = new Map((componentSelectors ?? []).map((comp) => [comp.selector, comp]));\n if (template) {\n this.setTemplate(template);\n }\n }\n preConstruct() {\n this.wireTemplate(this.getGui());\n const debugId = \"component-\" + Object.getPrototypeOf(this)?.constructor?.name;\n this.css?.forEach((css) => this.beans.environment.addGlobalCSS(css, debugId));\n }\n wireTemplate(element, paramsMap) {\n if (element && this.gos) {\n this.applyElementsToComponent(element);\n this.createChildComponentsFromTags(element, paramsMap);\n }\n }\n getCompId() {\n return this.compId;\n }\n getDataRefAttribute(element) {\n if (element.getAttribute) {\n return element.getAttribute(\"data-ref\");\n }\n return null;\n }\n applyElementsToComponent(element, elementRef, paramsMap, newComponent = null) {\n if (elementRef === void 0) {\n elementRef = this.getDataRefAttribute(element);\n }\n if (elementRef) {\n const current = this[elementRef];\n if (current === RefPlaceholder) {\n this[elementRef] = newComponent ?? element;\n } else {\n const usedAsParamRef = paramsMap && paramsMap[elementRef];\n if (!this.suppressDataRefValidation && !usedAsParamRef) {\n throw new Error(`data-ref: ${elementRef} on ${this.constructor.name} with ${current}`);\n }\n }\n }\n }\n // for registered components only, eg creates AgCheckbox instance from ag-checkbox HTML tag\n createChildComponentsFromTags(parentNode, paramsMap) {\n const childNodeList = _copyNodeList(parentNode.childNodes);\n childNodeList.forEach((childNode) => {\n if (!(childNode instanceof HTMLElement)) {\n return;\n }\n const childComp = this.createComponentFromElement(\n childNode,\n (childComp2) => {\n const childGui = childComp2.getGui();\n if (childGui) {\n this.copyAttributesFromNode(childNode, childComp2.getGui());\n }\n },\n paramsMap\n );\n if (childComp) {\n if (childComp.addItems && childNode.children.length) {\n this.createChildComponentsFromTags(childNode, paramsMap);\n const items = Array.prototype.slice.call(childNode.children);\n childComp.addItems(items);\n }\n this.swapComponentForNode(childComp, parentNode, childNode);\n } else if (childNode.childNodes) {\n this.createChildComponentsFromTags(childNode, paramsMap);\n }\n });\n }\n createComponentFromElement(element, afterPreCreateCallback, paramsMap) {\n const key = element.nodeName;\n const elementRef = this.getDataRefAttribute(element);\n const isAgGridComponent = key.indexOf(\"AG-\") === 0;\n const componentSelector = isAgGridComponent ? this.componentSelectors.get(key) : null;\n let newComponent = null;\n if (componentSelector) {\n const componentParams = paramsMap && elementRef ? paramsMap[elementRef] : void 0;\n newComponent = new componentSelector.component(componentParams);\n newComponent.setParentComponent(this);\n this.createBean(newComponent, null, afterPreCreateCallback);\n } else if (isAgGridComponent) {\n throw new Error(`selector: ${key}`);\n }\n this.applyElementsToComponent(element, elementRef, paramsMap, newComponent);\n return newComponent;\n }\n copyAttributesFromNode(source, dest) {\n _iterateNamedNodeMap(source.attributes, (name, value) => dest.setAttribute(name, value));\n }\n swapComponentForNode(newComponent, parentNode, childNode) {\n const eComponent = newComponent.getGui();\n parentNode.replaceChild(eComponent, childNode);\n parentNode.insertBefore(document.createComment(childNode.nodeName), eComponent);\n this.addDestroyFunc(this.destroyBean.bind(this, newComponent));\n }\n activateTabIndex(elements) {\n const tabIndex = this.gos.get(\"tabIndex\");\n if (!elements) {\n elements = [];\n }\n if (!elements.length) {\n elements.push(this.getGui());\n }\n elements.forEach((el) => el.setAttribute(\"tabindex\", tabIndex.toString()));\n }\n setTemplate(template, componentSelectors, paramsMap) {\n const eGui = _loadTemplate(template);\n this.setTemplateFromElement(eGui, componentSelectors, paramsMap);\n }\n setTemplateFromElement(element, components, paramsMap, suppressDataRefValidation = false) {\n this.eGui = element;\n this.suppressDataRefValidation = suppressDataRefValidation;\n if (components) {\n for (let i = 0; i < components.length; i++) {\n const component = components[i];\n this.componentSelectors.set(component.selector, component);\n }\n }\n this.wireTemplate(element, paramsMap);\n }\n getGui() {\n return this.eGui;\n }\n getFocusableElement() {\n return this.eGui;\n }\n getAriaElement() {\n return this.getFocusableElement();\n }\n setParentComponent(component) {\n this.parentComponent = component;\n }\n getParentComponent() {\n return this.parentComponent;\n }\n // this method is for older code, that wants to provide the gui element,\n // it is not intended for this to be in ag-Stack\n setGui(eGui) {\n this.eGui = eGui;\n }\n queryForHtmlElement(cssSelector) {\n return this.eGui.querySelector(cssSelector);\n }\n getContainerAndElement(newChild, container) {\n let parent = container;\n if (newChild == null) {\n return null;\n }\n if (!parent) {\n parent = this.eGui;\n }\n if (_isNodeOrElement(newChild)) {\n return {\n element: newChild,\n parent\n };\n }\n return {\n element: newChild.getGui(),\n parent\n };\n }\n prependChild(newChild, container) {\n const { element, parent } = this.getContainerAndElement(newChild, container) || {};\n if (!element || !parent) {\n return;\n }\n parent.insertAdjacentElement(\"afterbegin\", element);\n }\n appendChild(newChild, container) {\n const { element, parent } = this.getContainerAndElement(newChild, container) || {};\n if (!element || !parent) {\n return;\n }\n parent.appendChild(element);\n }\n isDisplayed() {\n return this.displayed;\n }\n setVisible(visible, options = {}) {\n if (visible !== this.visible) {\n this.visible = visible;\n const { skipAriaHidden } = options;\n _setVisible(this.eGui, visible, { skipAriaHidden });\n }\n }\n setDisplayed(displayed, options = {}) {\n if (displayed !== this.displayed) {\n this.displayed = displayed;\n const { skipAriaHidden } = options;\n _setDisplayed(this.eGui, displayed, { skipAriaHidden });\n const event = {\n type: \"displayChanged\",\n visible: this.displayed\n };\n this.dispatchLocalEvent(event);\n }\n }\n destroy() {\n if (this.parentComponent) {\n this.parentComponent = void 0;\n }\n super.destroy();\n }\n addGuiEventListener(event, listener, options) {\n this.eGui.addEventListener(event, listener, options);\n this.addDestroyFunc(() => this.eGui.removeEventListener(event, listener));\n }\n addCssClass(className) {\n this.cssClassManager.addCssClass(className);\n }\n removeCssClass(className) {\n this.cssClassManager.removeCssClass(className);\n }\n containsCssClass(className) {\n return this.cssClassManager.containsCssClass(className);\n }\n addOrRemoveCssClass(className, addOrRemove) {\n this.cssClassManager.addOrRemoveCssClass(className, addOrRemove);\n }\n registerCSS(css) {\n this.css || (this.css = []);\n this.css.push(css);\n }\n};\n\n// packages/ag-grid-community/src/utils/promise.ts\nfunction _isPromise(fn) {\n if (typeof fn.then === \"function\") {\n return true;\n }\n return false;\n}\nvar AgPromise = class _AgPromise {\n constructor(callback) {\n this.status = 0 /* IN_PROGRESS */;\n this.resolution = null;\n this.waiters = [];\n callback(\n (value) => this.onDone(value),\n (params) => this.onReject(params)\n );\n }\n static all(promises) {\n return promises.length ? new _AgPromise((resolve) => {\n let remainingToResolve = promises.length;\n const combinedValues = new Array(remainingToResolve);\n promises.forEach((promise, index) => {\n promise.then((value) => {\n combinedValues[index] = value;\n remainingToResolve--;\n if (remainingToResolve === 0) {\n resolve(combinedValues);\n }\n });\n });\n }) : _AgPromise.resolve();\n }\n static resolve(value = null) {\n return new _AgPromise((resolve) => resolve(value));\n }\n then(func) {\n return new _AgPromise((resolve) => {\n if (this.status === 1 /* RESOLVED */) {\n resolve(func(this.resolution));\n } else {\n this.waiters.push((value) => resolve(func(value)));\n }\n });\n }\n onDone(value) {\n this.status = 1 /* RESOLVED */;\n this.resolution = value;\n this.waiters.forEach((waiter) => waiter(value));\n }\n onReject(_) {\n }\n};\n\n// packages/ag-grid-community/src/components/framework/userComponentFactory.ts\nfunction doesImplementIComponent(candidate) {\n if (!candidate) {\n return false;\n }\n return candidate.prototype && \"getGui\" in candidate.prototype;\n}\nfunction _getUserCompKeys(frameworkOverrides, defObject, type, params) {\n const { name } = type;\n let compName;\n let jsComp;\n let fwComp;\n let paramsFromSelector;\n let popupFromSelector;\n let popupPositionFromSelector;\n if (defObject) {\n const defObjectAny = defObject;\n const selectorFunc = defObjectAny[name + \"Selector\"];\n const selectorRes = selectorFunc ? selectorFunc(params) : null;\n const assignComp = (providedJsComp) => {\n if (typeof providedJsComp === \"string\") {\n compName = providedJsComp;\n } else if (providedJsComp != null && providedJsComp !== true) {\n const isFwkComp = frameworkOverrides.isFrameworkComponent(providedJsComp);\n if (isFwkComp) {\n fwComp = providedJsComp;\n } else {\n jsComp = providedJsComp;\n }\n }\n };\n if (selectorRes) {\n assignComp(selectorRes.component);\n paramsFromSelector = selectorRes.params;\n popupFromSelector = selectorRes.popup;\n popupPositionFromSelector = selectorRes.popupPosition;\n } else {\n assignComp(defObjectAny[name]);\n }\n }\n return { compName, jsComp, fwComp, paramsFromSelector, popupFromSelector, popupPositionFromSelector };\n}\nvar UserComponentFactory = class extends BeanStub {\n constructor() {\n super(...arguments);\n this.beanName = \"userCompFactory\";\n }\n wireBeans(beans) {\n this.agCompUtils = beans.agCompUtils;\n this.registry = beans.registry;\n this.frameworkCompWrapper = beans.frameworkCompWrapper;\n this.gridOptions = beans.gridOptions;\n }\n getCompDetailsFromGridOptions(type, defaultName, params, mandatory = false) {\n return this.getCompDetails(this.gridOptions, type, defaultName, params, mandatory);\n }\n getCompDetails(defObject, type, defaultName, params, mandatory = false) {\n const { name, cellRenderer } = type;\n let { compName, jsComp, fwComp, paramsFromSelector, popupFromSelector, popupPositionFromSelector } = _getUserCompKeys(this.beans.frameworkOverrides, defObject, type, params);\n let defaultCompParams;\n const lookupFromRegistry = (key) => {\n const item = this.registry.getUserComponent(name, key);\n if (item) {\n jsComp = !item.componentFromFramework ? item.component : void 0;\n fwComp = item.componentFromFramework ? item.component : void 0;\n defaultCompParams = item.params;\n }\n };\n if (compName != null) {\n lookupFromRegistry(compName);\n }\n if (jsComp == null && fwComp == null && defaultName != null) {\n lookupFromRegistry(defaultName);\n }\n if (jsComp && cellRenderer && !doesImplementIComponent(jsComp)) {\n jsComp = this.agCompUtils?.adaptFunction(type, jsComp);\n }\n if (!jsComp && !fwComp) {\n const { validation: validation2 } = this.beans;\n if (mandatory && (compName !== defaultName || !defaultName)) {\n if (compName) {\n if (!validation2?.isProvidedUserComp(compName)) {\n _error(50, { compName });\n }\n } else {\n if (defaultName) {\n if (!validation2) {\n _error(260, {\n ...this.gos.getModuleErrorParams(),\n propName: name,\n compName: defaultName\n });\n }\n } else {\n _error(216, { name });\n }\n }\n } else if (defaultName && !validation2) {\n _error(146, { comp: defaultName });\n }\n return;\n }\n const paramsMerged = this.mergeParams(defObject, type, params, paramsFromSelector, defaultCompParams);\n const componentFromFramework = jsComp == null;\n const componentClass = jsComp ?? fwComp;\n return {\n componentFromFramework,\n componentClass,\n params: paramsMerged,\n type,\n popupFromSelector,\n popupPositionFromSelector,\n newAgStackInstance: () => this.newAgStackInstance(componentClass, componentFromFramework, paramsMerged, type)\n };\n }\n newAgStackInstance(ComponentClass, componentFromFramework, params, type) {\n const jsComponent = !componentFromFramework;\n let instance;\n if (jsComponent) {\n instance = new ComponentClass();\n } else {\n instance = this.frameworkCompWrapper.wrap(\n ComponentClass,\n type.mandatoryMethods,\n type.optionalMethods,\n type\n );\n }\n this.createBean(instance);\n const deferredInit = instance.init?.(params);\n if (deferredInit == null) {\n return AgPromise.resolve(instance);\n }\n return deferredInit.then(() => instance);\n }\n /**\n * merges params with application provided params\n * used by Floating Filter\n */\n mergeParams(defObject, type, paramsFromGrid, paramsFromSelector = null, defaultCompParams) {\n const params = { ...paramsFromGrid, ...defaultCompParams };\n const defObjectAny = defObject;\n const userParams = defObjectAny && defObjectAny[type.name + \"Params\"];\n if (typeof userParams === \"function\") {\n const userParamsFromFunc = userParams(paramsFromGrid);\n _mergeDeep(params, userParamsFromFunc);\n } else if (typeof userParams === \"object\") {\n _mergeDeep(params, userParams);\n }\n _mergeDeep(params, paramsFromSelector);\n return params;\n }\n};\n\n// packages/ag-grid-community/src/components/framework/userCompUtils.ts\nvar DateComponent = {\n name: \"dateComponent\",\n mandatoryMethods: [\"getDate\", \"setDate\"],\n optionalMethods: [\"afterGuiAttached\", \"setInputPlaceholder\", \"setInputAriaLabel\", \"setDisabled\", \"refresh\"]\n};\nvar DragAndDropImageComponent = {\n name: \"dragAndDropImageComponent\",\n mandatoryMethods: [\"setIcon\", \"setLabel\"]\n};\nvar HeaderComponent = { name: \"headerComponent\", optionalMethods: [\"refresh\"] };\nvar InnerHeaderComponent = { name: \"innerHeaderComponent\" };\nvar InnerHeaderGroupComponent = { name: \"innerHeaderGroupComponent\" };\nvar HeaderGroupComponent = { name: \"headerGroupComponent\" };\nvar InnerCellRendererComponent = {\n name: \"innerRenderer\",\n cellRenderer: true,\n optionalMethods: [\"afterGuiAttached\"]\n};\nvar CellRendererComponent = {\n name: \"cellRenderer\",\n optionalMethods: [\"refresh\", \"afterGuiAttached\"],\n cellRenderer: true\n};\nvar EditorRendererComponent = {\n name: \"cellRenderer\",\n optionalMethods: [\"refresh\", \"afterGuiAttached\"]\n};\nvar LoadingCellRendererComponent = { name: \"loadingCellRenderer\", cellRenderer: true };\nvar CellEditorComponent = {\n name: \"cellEditor\",\n mandatoryMethods: [\"getValue\"],\n optionalMethods: [\n \"isPopup\",\n \"isCancelBeforeStart\",\n \"isCancelAfterEnd\",\n \"getPopupPosition\",\n \"focusIn\",\n \"focusOut\",\n \"afterGuiAttached\",\n \"refresh\"\n ]\n};\nvar LoadingOverlayComponent = { name: \"loadingOverlayComponent\", optionalMethods: [\"refresh\"] };\nvar NoRowsOverlayComponent = { name: \"noRowsOverlayComponent\", optionalMethods: [\"refresh\"] };\nvar TooltipComponent = { name: \"tooltipComponent\" };\nvar FilterComponent = {\n name: \"filter\",\n mandatoryMethods: [\"isFilterActive\", \"doesFilterPass\", \"getModel\", \"setModel\"],\n optionalMethods: [\n \"afterGuiAttached\",\n \"afterGuiDetached\",\n \"onNewRowsLoaded\",\n \"getModelAsString\",\n \"onFloatingFilterChanged\",\n \"onAnyFilterChanged\",\n \"refresh\"\n ]\n};\nvar FloatingFilterComponent = {\n name: \"floatingFilterComponent\",\n mandatoryMethods: [\"onParentModelChanged\"],\n optionalMethods: [\"afterGuiAttached\", \"refresh\"]\n};\nvar FullWidth = {\n name: \"fullWidthCellRenderer\",\n optionalMethods: [\"refresh\", \"afterGuiAttached\"],\n cellRenderer: true\n};\nvar FullWidthLoading = { name: \"loadingCellRenderer\", cellRenderer: true };\nvar FullWidthGroup = {\n name: \"groupRowRenderer\",\n optionalMethods: [\"afterGuiAttached\"],\n cellRenderer: true\n};\nvar FullWidthDetail = { name: \"detailCellRenderer\", optionalMethods: [\"refresh\"], cellRenderer: true };\nfunction _getDragAndDropImageCompDetails(userCompFactory, params) {\n return userCompFactory.getCompDetailsFromGridOptions(DragAndDropImageComponent, \"agDragAndDropImage\", params, true);\n}\nfunction _getInnerCellRendererDetails(userCompFactory, def, params) {\n return userCompFactory.getCompDetails(def, InnerCellRendererComponent, void 0, params);\n}\nfunction _getHeaderCompDetails(userCompFactory, colDef, params) {\n return userCompFactory.getCompDetails(colDef, HeaderComponent, \"agColumnHeader\", params);\n}\nfunction _getInnerHeaderCompDetails(userCompFactory, headerCompParams, params) {\n return userCompFactory.getCompDetails(headerCompParams, InnerHeaderComponent, void 0, params);\n}\nfunction _getHeaderGroupCompDetails(userCompFactory, params) {\n const colGroupDef = params.columnGroup.getColGroupDef();\n return userCompFactory.getCompDetails(colGroupDef, HeaderGroupComponent, \"agColumnGroupHeader\", params);\n}\nfunction _getInnerHeaderGroupCompDetails(userCompFactory, headerGroupCompParams, params) {\n return userCompFactory.getCompDetails(headerGroupCompParams, InnerHeaderGroupComponent, void 0, params);\n}\nfunction _getFullWidthCellRendererDetails(userCompFactory, params) {\n return userCompFactory.getCompDetailsFromGridOptions(FullWidth, void 0, params, true);\n}\nfunction _getFullWidthLoadingCellRendererDetails(userCompFactory, params) {\n return userCompFactory.getCompDetailsFromGridOptions(FullWidthLoading, \"agLoadingCellRenderer\", params, true);\n}\nfunction _getFullWidthGroupCellRendererDetails(userCompFactory, params) {\n return userCompFactory.getCompDetailsFromGridOptions(FullWidthGroup, \"agGroupRowRenderer\", params, true);\n}\nfunction _getFullWidthDetailCellRendererDetails(userCompFactory, params) {\n return userCompFactory.getCompDetailsFromGridOptions(FullWidthDetail, \"agDetailCellRenderer\", params, true);\n}\nfunction _getCellRendererDetails(userCompFactory, def, params) {\n return userCompFactory.getCompDetails(def, CellRendererComponent, void 0, params);\n}\nfunction _getEditorRendererDetails(userCompFactory, def, params) {\n return userCompFactory.getCompDetails(\n def,\n EditorRendererComponent,\n void 0,\n params\n );\n}\nfunction _getLoadingCellRendererDetails(userCompFactory, def, params) {\n return userCompFactory.getCompDetails(def, LoadingCellRendererComponent, \"agSkeletonCellRenderer\", params, true);\n}\nfunction _getCellEditorDetails(userCompFactory, def, params) {\n return userCompFactory.getCompDetails(def, CellEditorComponent, \"agCellEditor\", params, true);\n}\nfunction _getFilterDetails(userCompFactory, def, params, defaultFilter) {\n return userCompFactory.getCompDetails(def, FilterComponent, defaultFilter, params, true);\n}\nfunction _getDateCompDetails(userCompFactory, params) {\n return userCompFactory.getCompDetailsFromGridOptions(DateComponent, \"agDateInput\", params, true);\n}\nfunction _getLoadingOverlayCompDetails(userCompFactory, params) {\n return userCompFactory.getCompDetailsFromGridOptions(LoadingOverlayComponent, \"agLoadingOverlay\", params, true);\n}\nfunction _getNoRowsOverlayCompDetails(userCompFactory, params) {\n return userCompFactory.getCompDetailsFromGridOptions(NoRowsOverlayComponent, \"agNoRowsOverlay\", params, true);\n}\nfunction _getTooltipCompDetails(userCompFactory, params) {\n return userCompFactory.getCompDetails(params.colDef, TooltipComponent, \"agTooltipComponent\", params, true);\n}\nfunction _getFloatingFilterCompDetails(userCompFactory, def, params, defaultFloatingFilter) {\n return userCompFactory.getCompDetails(def, FloatingFilterComponent, defaultFloatingFilter, params);\n}\nfunction _getFilterCompKeys(frameworkOverrides, def) {\n return _getUserCompKeys(frameworkOverrides, def, FilterComponent);\n}\nfunction _mergeFilterParamsWithApplicationProvidedParams(userCompFactory, defObject, paramsFromGrid) {\n return userCompFactory.mergeParams(defObject, FilterComponent, paramsFromGrid);\n}\n\n// packages/ag-grid-community/src/components/framework/unwrapUserComp.ts\nfunction _unwrapUserComp(comp) {\n const compAsAny = comp;\n const isProxy = compAsAny != null && compAsAny.getFrameworkComponentInstance != null;\n return isProxy ? compAsAny.getFrameworkComponentInstance() : comp;\n}\n\n// packages/ag-grid-community/src/modules/moduleRegistry.ts\nvar allRegisteredModules = /* @__PURE__ */ new Set();\nvar globalModulesMap = {};\nvar gridModulesMap = {};\nvar currentModuleVersion;\nvar areGridScopedModules = false;\nvar isUmd = false;\nfunction isValidModuleVersion(module) {\n const [moduleMajor, moduleMinor] = module.version.split(\".\") || [];\n const [currentModuleMajor, currentModuleMinor] = currentModuleVersion.split(\".\") || [];\n return moduleMajor === currentModuleMajor && moduleMinor === currentModuleMinor;\n}\nfunction runVersionChecks(module) {\n if (!currentModuleVersion) {\n currentModuleVersion = module.version;\n }\n const errorMsg = (details) => `You are using incompatible versions of AG Grid modules. Major and minor versions should always match across modules. ${details} Please update all modules to the same version.`;\n if (!module.version) {\n _errorOnce(errorMsg(`'${module.moduleName}' is incompatible.`));\n } else if (!isValidModuleVersion(module)) {\n _errorOnce(\n errorMsg(\n `'${module.moduleName}' is version ${module.version} but the other modules are version ${currentModuleVersion}.`\n )\n );\n }\n if (module.validate) {\n const result = module.validate();\n if (!result.isValid) {\n const errorResult = result;\n _errorOnce(`${errorResult.message}`);\n }\n }\n}\nfunction _registerModule(module, gridId) {\n runVersionChecks(module);\n const rowModels = module.rowModels ?? [\"all\"];\n allRegisteredModules.add(module);\n let moduleStore;\n if (gridId !== void 0) {\n areGridScopedModules = true;\n if (gridModulesMap[gridId] === void 0) {\n gridModulesMap[gridId] = {};\n }\n moduleStore = gridModulesMap[gridId];\n } else {\n moduleStore = globalModulesMap;\n }\n rowModels.forEach((rowModel) => {\n if (moduleStore[rowModel] === void 0) {\n moduleStore[rowModel] = {};\n }\n moduleStore[rowModel][module.moduleName] = module;\n });\n if (module.dependsOn) {\n module.dependsOn.forEach((dependency) => _registerModule(dependency, gridId));\n }\n}\nfunction _unRegisterGridModules(gridId) {\n delete gridModulesMap[gridId];\n}\nfunction _isModuleRegistered(moduleName, gridId, rowModel) {\n const isRegisteredForRowModel = (model) => !!globalModulesMap[model]?.[moduleName] || !!gridModulesMap[gridId]?.[model]?.[moduleName];\n return isRegisteredForRowModel(rowModel) || isRegisteredForRowModel(\"all\");\n}\nfunction _areModulesGridScoped() {\n return areGridScopedModules;\n}\nfunction _getRegisteredModules(gridId, rowModel) {\n const gridModules = gridModulesMap[gridId] ?? {};\n return [\n ...Object.values(globalModulesMap[\"all\"] ?? {}),\n ...Object.values(gridModules[\"all\"] ?? {}),\n ...Object.values(globalModulesMap[rowModel] ?? {}),\n ...Object.values(gridModules[rowModel] ?? {})\n ];\n}\nfunction _getAllRegisteredModules() {\n return new Set(allRegisteredModules);\n}\nfunction _getGridRegisteredModules(gridId, rowModel) {\n const gridModules = gridModulesMap[gridId] ?? {};\n return [...Object.values(gridModules[\"all\"] ?? {}), ...Object.values(gridModules[rowModel] ?? {})];\n}\nfunction _isUmd() {\n return isUmd;\n}\nfunction _setUmd() {\n isUmd = true;\n}\nvar ModuleRegistry = class {\n /**\n * @deprecated v33 Use `registerModules([module])` instead.\n */\n static register(module) {\n _registerModule(module, void 0);\n }\n /**\n * Globally register the given modules for all grids.\n * @param modules - modules to register\n */\n static registerModules(modules) {\n modules.forEach((module) => _registerModule(module, void 0));\n }\n};\n\n// packages/ag-grid-community/src/context/genericContext.ts\nvar GenericContext = class {\n constructor(params) {\n this.beans = {};\n this.createdBeans = [];\n this.destroyed = false;\n if (!params || !params.beanClasses) {\n return;\n }\n this.beanDestroyComparator = params.beanDestroyComparator;\n this.init(params);\n }\n init(params) {\n for (const beanName of Object.keys(params.providedBeanInstances)) {\n this.beans[beanName] = params.providedBeanInstances[beanName];\n }\n params.beanClasses.forEach((BeanClass) => {\n const instance = new BeanClass();\n if (instance.beanName) {\n this.beans[instance.beanName] = instance;\n } else {\n console.error(`Bean ${BeanClass.name} is missing beanName`);\n }\n this.createdBeans.push(instance);\n });\n params.derivedBeans?.forEach((beanFunc) => {\n const { beanName, bean } = beanFunc(this);\n this.beans[beanName] = bean;\n this.createdBeans.push(bean);\n });\n if (params.beanInitComparator) {\n this.createdBeans.sort(params.beanInitComparator);\n }\n this.initBeans(this.createdBeans);\n }\n getBeanInstances() {\n return Object.values(this.beans);\n }\n createBean(bean, afterPreCreateCallback) {\n if (!bean) {\n throw Error(\"null bean\");\n }\n this.initBeans([bean], afterPreCreateCallback);\n return bean;\n }\n initBeans(beanInstances, afterPreCreateCallback) {\n beanInstances.forEach((instance) => {\n instance.preWireBeans?.(this.beans);\n instance.wireBeans?.(this.beans);\n });\n beanInstances.forEach((instance) => instance.preConstruct?.());\n if (afterPreCreateCallback) {\n beanInstances.forEach(afterPreCreateCallback);\n }\n beanInstances.forEach((instance) => instance.postConstruct?.());\n }\n getBeans() {\n return this.beans;\n }\n getBean(name) {\n return this.beans[name];\n }\n destroy() {\n if (this.destroyed) {\n return;\n }\n this.destroyed = true;\n const beanInstances = this.getBeanInstances();\n if (this.beanDestroyComparator) {\n beanInstances.sort(this.beanDestroyComparator);\n }\n this.destroyBeans(beanInstances);\n this.beans = {};\n this.createdBeans = [];\n }\n /**\n * Destroys a bean and returns undefined to support destruction and clean up in a single line.\n * this.dateComp = this.context.destroyBean(this.dateComp);\n */\n destroyBean(bean) {\n bean?.destroy?.();\n }\n /**\n * Destroys an array of beans and returns an empty array to support destruction and clean up in a single line.\n * this.dateComps = this.context.destroyBeans(this.dateComps);\n */\n destroyBeans(beans) {\n if (beans) {\n for (let i = 0; i < beans.length; i++) {\n this.destroyBean(beans[i]);\n }\n }\n return [];\n }\n isDestroyed() {\n return this.destroyed;\n }\n};\n\n// packages/ag-grid-community/src/context/context.ts\nvar Context = class extends GenericContext {\n init(params) {\n this.gridId = params.gridId;\n this.beans.context = this;\n this.destroyCallback = params.destroyCallback;\n super.init(params);\n }\n destroy() {\n super.destroy();\n _unRegisterGridModules(this.gridId);\n this.destroyCallback?.();\n }\n getGridId() {\n return this.gridId;\n }\n};\n\n// packages/ag-grid-community/src/headerRendering/cells/cssClassApplier.ts\nvar CSS_FIRST_COLUMN = \"ag-column-first\";\nvar CSS_LAST_COLUMN = \"ag-column-last\";\nfunction _getHeaderClassesFromColDef(abstractColDef, gos, column, columnGroup) {\n if (_missing(abstractColDef)) {\n return [];\n }\n return getColumnClassesFromCollDef(abstractColDef.headerClass, abstractColDef, gos, column, columnGroup);\n}\nfunction _getToolPanelClassesFromColDef(abstractColDef, gos, column, columnGroup) {\n if (_missing(abstractColDef)) {\n return [];\n }\n return getColumnClassesFromCollDef(abstractColDef.toolPanelClass, abstractColDef, gos, column, columnGroup);\n}\nfunction refreshFirstAndLastStyles(comp, column, presentedColsService) {\n comp.addOrRemoveCssClass(CSS_FIRST_COLUMN, presentedColsService.isColAtEdge(column, \"first\"));\n comp.addOrRemoveCssClass(CSS_LAST_COLUMN, presentedColsService.isColAtEdge(column, \"last\"));\n}\nfunction getClassParams(abstractColDef, gos, column, columnGroup) {\n return _addGridCommonParams(gos, {\n // bad naming, as colDef here can be a group or a column,\n // however most people won't appreciate the difference,\n // so keeping it as colDef to avoid confusion.\n colDef: abstractColDef,\n column,\n columnGroup\n });\n}\nfunction getColumnClassesFromCollDef(classesOrFunc, abstractColDef, gos, column, columnGroup) {\n if (_missing(classesOrFunc)) {\n return [];\n }\n let classToUse;\n if (typeof classesOrFunc === \"function\") {\n const params = getClassParams(abstractColDef, gos, column, columnGroup);\n classToUse = classesOrFunc(params);\n } else {\n classToUse = classesOrFunc;\n }\n if (typeof classToUse === \"string\") {\n return [classToUse];\n }\n if (Array.isArray(classToUse)) {\n return [...classToUse];\n }\n return [];\n}\n\n// packages/ag-grid-community/src/misc/animationFrameService.ts\nfunction _requestAnimationFrame(beans, callback) {\n const win = _getWindow(beans);\n if (win.requestAnimationFrame) {\n win.requestAnimationFrame(callback);\n } else if (win.webkitRequestAnimationFrame) {\n win.webkitRequestAnimationFrame(callback);\n } else {\n win.setTimeout(callback, 0);\n }\n}\nvar AnimationFrameService = class extends BeanStub {\n constructor() {\n super(...arguments);\n this.beanName = \"animationFrameSvc\";\n // p1 and p2 are create tasks are to do with row and cell creation.\n // for them we want to execute according to row order, so we use\n // TaskItem so we know what index the item is for.\n this.createTasksP1 = { list: [], sorted: false };\n // eg drawing back-ground of rows\n this.createTasksP2 = { list: [], sorted: false };\n // eg cell renderers, adding hover functionality\n // destroy tasks are to do with row removal. they are done after row creation as the user will need to see new\n // rows first (as blank is scrolled into view), when we remove the old rows (no longer in view) is not as\n // important.\n this.destroyTasks = [];\n this.ticking = false;\n // we need to know direction of scroll, to build up rows in the direction of\n // the scroll. eg if user scrolls down, we extend the rows by building down.\n this.scrollGoingDown = true;\n this.lastPage = 0;\n this.lastScrollTop = 0;\n this.taskCount = 0;\n this.cancelledTasks = /* @__PURE__ */ new Set();\n }\n setScrollTop(scrollTop) {\n const { gos, pagination } = this.beans;\n const isPaginationActive = gos.get(\"pagination\");\n this.scrollGoingDown = scrollTop >= this.lastScrollTop;\n if (isPaginationActive && scrollTop === 0) {\n const currentPage = pagination?.getCurrentPage() ?? 0;\n if (currentPage !== this.lastPage) {\n this.lastPage = currentPage;\n this.scrollGoingDown = true;\n }\n }\n this.lastScrollTop = scrollTop;\n }\n postConstruct() {\n this.active = !this.gos.get(\"suppressAnimationFrame\");\n }\n // this method is for our AG Grid sanity only - if animation frames are turned off,\n // then no place in the code should be looking to add any work to be done in animation\n // frames. this stops bugs - where some code is asking for a frame to be executed\n // when it should not.\n verifyAnimationFrameOn(methodName) {\n if (this.active === false) {\n _warn(92, { methodName });\n }\n }\n createTask(task, index, list) {\n this.verifyAnimationFrameOn(list);\n const taskItem = { task, index, createOrder: ++this.taskCount };\n this.addTaskToList(this[list], taskItem);\n this.schedule();\n }\n cancelTask(task) {\n this.cancelledTasks.add(task);\n }\n addTaskToList(taskList, task) {\n taskList.list.push(task);\n taskList.sorted = false;\n }\n sortTaskList(taskList) {\n if (taskList.sorted) {\n return;\n }\n const sortDirection = this.scrollGoingDown ? 1 : -1;\n taskList.list.sort(\n (a, b) => a.index !== b.index ? sortDirection * (b.index - a.index) : b.createOrder - a.createOrder\n );\n taskList.sorted = true;\n }\n addDestroyTask(task) {\n this.verifyAnimationFrameOn(\"createTasksP3\");\n this.destroyTasks.push(task);\n this.schedule();\n }\n executeFrame(millis) {\n this.verifyAnimationFrameOn(\"executeFrame\");\n const p1TaskList = this.createTasksP1;\n const p1Tasks = p1TaskList.list;\n const p2TaskList = this.createTasksP2;\n const p2Tasks = p2TaskList.list;\n const destroyTasks = this.destroyTasks;\n const frameStart = (/* @__PURE__ */ new Date()).getTime();\n let duration = (/* @__PURE__ */ new Date()).getTime() - frameStart;\n const noMaxMillis = millis <= 0;\n const scrollFeature = this.beans.ctrlsSvc.getScrollFeature();\n while (noMaxMillis || duration < millis) {\n const gridBodyDidSomething = scrollFeature.scrollGridIfNeeded();\n if (!gridBodyDidSomething) {\n let task;\n if (p1Tasks.length) {\n this.sortTaskList(p1TaskList);\n task = p1Tasks.pop().task;\n } else if (p2Tasks.length) {\n this.sortTaskList(p2TaskList);\n task = p2Tasks.pop().task;\n } else if (destroyTasks.length) {\n task = destroyTasks.pop();\n } else {\n this.cancelledTasks.clear();\n break;\n }\n if (!this.cancelledTasks.has(task)) {\n task();\n }\n }\n duration = (/* @__PURE__ */ new Date()).getTime() - frameStart;\n }\n if (p1Tasks.length || p2Tasks.length || destroyTasks.length) {\n this.requestFrame();\n } else {\n this.ticking = false;\n }\n }\n flushAllFrames() {\n if (!this.active) {\n return;\n }\n this.executeFrame(-1);\n }\n schedule() {\n if (!this.active) {\n return;\n }\n if (!this.ticking) {\n this.ticking = true;\n this.requestFrame();\n }\n }\n requestFrame() {\n const callback = this.executeFrame.bind(this, 60);\n _requestAnimationFrame(this.beans, callback);\n }\n isQueueEmpty() {\n return !this.ticking;\n }\n};\n\n// packages/ag-grid-community/src/constants/keyCode.ts\nvar KeyCode = {\n BACKSPACE: \"Backspace\",\n TAB: \"Tab\",\n ENTER: \"Enter\",\n ESCAPE: \"Escape\",\n SPACE: \" \",\n LEFT: \"ArrowLeft\",\n UP: \"ArrowUp\",\n RIGHT: \"ArrowRight\",\n DOWN: \"ArrowDown\",\n DELETE: \"Delete\",\n F2: \"F2\",\n PAGE_UP: \"PageUp\",\n PAGE_DOWN: \"PageDown\",\n PAGE_HOME: \"Home\",\n PAGE_END: \"End\",\n // these should be used with `event.code` instead of `event.key`\n // as `event.key` changes when non-latin keyboards are used\n A: \"KeyA\",\n C: \"KeyC\",\n D: \"KeyD\",\n V: \"KeyV\",\n X: \"KeyX\",\n Y: \"KeyY\",\n Z: \"KeyZ\"\n};\n\n// packages/ag-grid-community/src/utils/focus.ts\nvar keyboardModeActive = false;\nvar instanceCount = 0;\nfunction addKeyboardModeEvents(doc) {\n if (instanceCount > 0) {\n return;\n }\n doc.addEventListener(\"keydown\", toggleKeyboardMode);\n doc.addEventListener(\"mousedown\", toggleKeyboardMode);\n}\nfunction removeKeyboardModeEvents(doc) {\n if (instanceCount > 0)\n return;\n doc.removeEventListener(\"keydown\", toggleKeyboardMode);\n doc.removeEventListener(\"mousedown\", toggleKeyboardMode);\n}\nfunction toggleKeyboardMode(event) {\n const isKeyboardActive = keyboardModeActive;\n const isKeyboardEvent = event.type === \"keydown\";\n if (isKeyboardEvent) {\n if (event.ctrlKey || event.metaKey || event.altKey) {\n return;\n }\n }\n if (isKeyboardActive === isKeyboardEvent) {\n return;\n }\n keyboardModeActive = isKeyboardEvent;\n}\nfunction _registerKeyboardFocusEvents(beans) {\n const eDocument = _getDocument(beans);\n addKeyboardModeEvents(eDocument);\n instanceCount++;\n return () => {\n instanceCount--;\n removeKeyboardModeEvents(eDocument);\n };\n}\nfunction _isKeyboardMode() {\n return keyboardModeActive;\n}\nfunction _addFocusableContainerListener(beans, comp, eGui) {\n comp.addManagedElementListeners(eGui, {\n keydown: (e) => {\n if (!e.defaultPrevented && e.key === KeyCode.TAB) {\n const backwards = e.shiftKey;\n if (!_findNextFocusableElement(beans, eGui, false, backwards)) {\n if (_focusNextGridCoreContainer(beans, backwards)) {\n e.preventDefault();\n }\n }\n }\n }\n });\n}\nfunction _findFocusableElements(rootNode, exclude, onlyUnmanaged = false) {\n const focusableString = FOCUSABLE_SELECTOR;\n let excludeString = FOCUSABLE_EXCLUDE;\n if (exclude) {\n excludeString += \", \" + exclude;\n }\n if (onlyUnmanaged) {\n excludeString += ', [tabindex=\"-1\"]';\n }\n const nodes = Array.prototype.slice.apply(rootNode.querySelectorAll(focusableString)).filter((node) => {\n return _isVisible(node);\n });\n const excludeNodes = Array.prototype.slice.apply(rootNode.querySelectorAll(excludeString));\n if (!excludeNodes.length) {\n return nodes;\n }\n const diff = (a, b) => a.filter((element) => b.indexOf(element) === -1);\n return diff(nodes, excludeNodes);\n}\nfunction _focusInto(rootNode, up = false, onlyUnmanaged = false, excludeTabGuards = false) {\n const focusableElements = _findFocusableElements(\n rootNode,\n excludeTabGuards ? \".ag-tab-guard\" : null,\n onlyUnmanaged\n );\n const toFocus = up ? _last(focusableElements) : focusableElements[0];\n if (toFocus) {\n toFocus.focus({ preventScroll: true });\n return true;\n }\n return false;\n}\nfunction _findNextFocusableElement(beans, rootNode, onlyManaged, backwards) {\n const focusable = _findFocusableElements(rootNode, onlyManaged ? ':not([tabindex=\"-1\"])' : null);\n const activeEl = _getActiveDomElement(beans);\n let currentIndex;\n if (onlyManaged) {\n currentIndex = focusable.findIndex((el) => el.contains(activeEl));\n } else {\n currentIndex = focusable.indexOf(activeEl);\n }\n const nextIndex = currentIndex + (backwards ? -1 : 1);\n if (nextIndex < 0 || nextIndex >= focusable.length) {\n return null;\n }\n return focusable[nextIndex];\n}\nfunction _findTabbableParent(node, limit = 5) {\n let counter = 0;\n while (node && _getTabIndex(node) === null && ++counter <= limit) {\n node = node.parentElement;\n }\n if (_getTabIndex(node) === null) {\n return null;\n }\n return node;\n}\nfunction _focusGridInnerElement(beans, fromBottom) {\n return beans.ctrlsSvc.get(\"gridCtrl\").focusInnerElement(fromBottom);\n}\nfunction _isHeaderFocusSuppressed(beans) {\n return beans.gos.get(\"suppressHeaderFocus\") || !!beans.overlays?.isExclusive();\n}\nfunction _isCellFocusSuppressed(beans) {\n return beans.gos.get(\"suppressCellFocus\") || !!beans.overlays?.isExclusive();\n}\nfunction _focusNextGridCoreContainer(beans, backwards, forceOut = false) {\n const gridCtrl = beans.ctrlsSvc.get(\"gridCtrl\");\n if (!forceOut && gridCtrl.focusNextInnerContainer(backwards)) {\n return true;\n }\n if (forceOut || !backwards && !gridCtrl.isDetailGrid()) {\n gridCtrl.forceFocusOutOfContainer(backwards);\n }\n return false;\n}\n\n// packages/ag-grid-community/src/rendering/cell/cellKeyboardListenerFeature.ts\nfunction _isDeleteKey(key, alwaysReturnFalseOnBackspace = false) {\n if (key === KeyCode.DELETE) {\n return true;\n }\n if (!alwaysReturnFalseOnBackspace && key === KeyCode.BACKSPACE) {\n return _isMacOsUserAgent();\n }\n return false;\n}\nvar CellKeyboardListenerFeature = class extends BeanStub {\n constructor(cellCtrl, beans, rowNode, rowCtrl) {\n super();\n this.cellCtrl = cellCtrl;\n this.rowNode = rowNode;\n this.rowCtrl = rowCtrl;\n this.beans = beans;\n }\n init() {\n this.eGui = this.cellCtrl.eGui;\n }\n onKeyDown(event) {\n const key = event.key;\n switch (key) {\n case KeyCode.ENTER:\n this.onEnterKeyDown(event);\n break;\n case KeyCode.F2:\n this.onF2KeyDown(event);\n break;\n case KeyCode.ESCAPE:\n this.onEscapeKeyDown(event);\n break;\n case KeyCode.TAB:\n this.onTabKeyDown(event);\n break;\n case KeyCode.BACKSPACE:\n case KeyCode.DELETE:\n this.onBackspaceOrDeleteKeyDown(key, event);\n break;\n case KeyCode.DOWN:\n case KeyCode.UP:\n case KeyCode.RIGHT:\n case KeyCode.LEFT:\n this.onNavigationKeyDown(event, key);\n break;\n }\n }\n onNavigationKeyDown(event, key) {\n if (this.cellCtrl.editing) {\n return;\n }\n if (event.shiftKey && this.cellCtrl.isRangeSelectionEnabled()) {\n this.onShiftRangeSelect(event);\n } else {\n const currentCellPosition = this.cellCtrl.getFocusedCellPosition();\n this.beans.navigation?.navigateToNextCell(event, key, currentCellPosition, true);\n }\n event.preventDefault();\n }\n onShiftRangeSelect(event) {\n const { rangeSvc, navigation } = this.beans;\n if (!rangeSvc) {\n return;\n }\n const endCell = rangeSvc.extendLatestRangeInDirection(event);\n if (endCell) {\n navigation?.ensureCellVisible(endCell);\n }\n }\n onTabKeyDown(event) {\n this.beans.navigation?.onTabKeyDown(this.cellCtrl, event);\n }\n onBackspaceOrDeleteKeyDown(key, event) {\n const { cellCtrl, beans, rowNode } = this;\n const { gos, rangeSvc, eventSvc } = beans;\n if (cellCtrl.editing) {\n return;\n }\n eventSvc.dispatchEvent({ type: \"keyShortcutChangedCellStart\" });\n if (_isDeleteKey(key, gos.get(\"enableCellEditingOnBackspace\"))) {\n if (rangeSvc && _isCellSelectionEnabled(gos)) {\n rangeSvc.clearCellRangeCellValues({ dispatchWrapperEvents: true, wrapperEventSource: \"deleteKey\" });\n } else if (cellCtrl.isCellEditable()) {\n const { column } = cellCtrl;\n const emptyValue = this.beans.valueSvc.getDeleteValue(column, rowNode);\n rowNode.setDataValue(column, emptyValue, \"cellClear\");\n }\n } else {\n beans.editSvc?.startRowOrCellEdit(cellCtrl, key, event);\n }\n eventSvc.dispatchEvent({ type: \"keyShortcutChangedCellEnd\" });\n }\n onEnterKeyDown(e) {\n const { cellCtrl, beans } = this;\n if (cellCtrl.editing || this.rowCtrl.editing) {\n cellCtrl.stopEditingAndFocus(false, e.shiftKey);\n } else {\n if (beans.gos.get(\"enterNavigatesVertically\")) {\n const key = e.shiftKey ? KeyCode.UP : KeyCode.DOWN;\n beans.navigation?.navigateToNextCell(null, key, cellCtrl.cellPosition, false);\n } else {\n beans.editSvc?.startRowOrCellEdit(cellCtrl, KeyCode.ENTER, e);\n if (cellCtrl.editing) {\n e.preventDefault();\n }\n }\n }\n }\n onF2KeyDown(event) {\n const { cellCtrl, beans } = this;\n if (!cellCtrl.editing) {\n beans.editSvc?.startRowOrCellEdit(cellCtrl, KeyCode.F2, event);\n }\n }\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n onEscapeKeyDown(event) {\n const { cellCtrl, beans } = this;\n if (cellCtrl.editing) {\n beans.editSvc?.stopRowOrCellEdit(cellCtrl, true);\n cellCtrl.focusCell(true);\n }\n }\n processCharacter(event) {\n const eventTarget = event.target;\n const eventOnChildComponent = eventTarget !== this.eGui;\n if (eventOnChildComponent || this.cellCtrl.editing) {\n return;\n }\n const key = event.key;\n if (key === KeyCode.SPACE) {\n this.onSpaceKeyDown(event);\n } else {\n if (this.beans.editSvc?.startRowOrCellEdit(this.cellCtrl, key, event)) {\n event.preventDefault();\n }\n }\n }\n onSpaceKeyDown(event) {\n const { gos } = this.beans;\n if (!this.cellCtrl.editing && _isRowSelection(gos)) {\n this.beans.selectionSvc?.handleSelectionEvent(event, this.rowNode, \"spaceKey\");\n }\n event.preventDefault();\n }\n destroy() {\n super.destroy();\n }\n};\n\n// packages/ag-grid-community/src/rendering/cell/cellMouseListenerFeature.ts\nvar CellMouseListenerFeature = class extends BeanStub {\n constructor(cellCtrl, beans, column) {\n super();\n this.cellCtrl = cellCtrl;\n this.column = column;\n this.beans = beans;\n }\n onMouseEvent(eventName, mouseEvent) {\n if (_isStopPropagationForAgGrid(mouseEvent)) {\n return;\n }\n switch (eventName) {\n case \"click\":\n this.onCellClicked(mouseEvent);\n break;\n case \"mousedown\":\n case \"touchstart\":\n this.onMouseDown(mouseEvent);\n break;\n case \"dblclick\":\n this.onCellDoubleClicked(mouseEvent);\n break;\n case \"mouseout\":\n this.onMouseOut(mouseEvent);\n break;\n case \"mouseover\":\n this.onMouseOver(mouseEvent);\n break;\n }\n }\n onCellClicked(mouseEvent) {\n if (this.beans.touchSvc?.handleCellDoubleClick(this, mouseEvent)) {\n return;\n }\n const { eventSvc, rangeSvc, gos, editSvc } = this.beans;\n const isMultiKey = mouseEvent.ctrlKey || mouseEvent.metaKey;\n if (rangeSvc && isMultiKey) {\n if (rangeSvc.getCellRangeCount(this.cellCtrl.cellPosition) > 1) {\n rangeSvc.intersectLastRange(true);\n }\n }\n const cellClickedEvent = this.cellCtrl.createEvent(mouseEvent, \"cellClicked\");\n eventSvc.dispatchEvent(cellClickedEvent);\n const colDef = this.column.getColDef();\n if (colDef.onCellClicked) {\n window.setTimeout(() => {\n this.beans.frameworkOverrides.wrapOutgoing(() => {\n colDef.onCellClicked(cellClickedEvent);\n });\n }, 0);\n }\n const editOnSingleClick = (gos.get(\"singleClickEdit\") || colDef.singleClickEdit) && !gos.get(\"suppressClickEdit\");\n if (editOnSingleClick && !(mouseEvent.shiftKey && rangeSvc?.getCellRanges().length != 0)) {\n editSvc?.startRowOrCellEdit(this.cellCtrl, void 0, mouseEvent);\n }\n }\n onCellDoubleClicked(mouseEvent) {\n const { column, beans, cellCtrl } = this;\n const { eventSvc, frameworkOverrides, gos, editSvc } = beans;\n const colDef = column.getColDef();\n const cellDoubleClickedEvent = cellCtrl.createEvent(mouseEvent, \"cellDoubleClicked\");\n eventSvc.dispatchEvent(cellDoubleClickedEvent);\n if (typeof colDef.onCellDoubleClicked === \"function\") {\n window.setTimeout(() => {\n frameworkOverrides.wrapOutgoing(() => {\n colDef.onCellDoubleClicked(cellDoubleClickedEvent);\n });\n }, 0);\n }\n const editOnDoubleClick = !gos.get(\"singleClickEdit\") && !gos.get(\"suppressClickEdit\");\n if (editOnDoubleClick) {\n editSvc?.startRowOrCellEdit(cellCtrl, null, mouseEvent);\n }\n }\n onMouseDown(mouseEvent) {\n const { ctrlKey, metaKey, shiftKey } = mouseEvent;\n const target = mouseEvent.target;\n const { cellCtrl, beans } = this;\n const { eventSvc, rangeSvc, rowNumbersSvc, focusSvc, gos } = beans;\n if (this.isRightClickInExistingRange(mouseEvent)) {\n return;\n }\n const hasRanges = rangeSvc && !rangeSvc.isEmpty();\n const containsWidget = this.containsWidget(target);\n const { cellPosition } = cellCtrl;\n const isRowNumberColumn = isRowNumberCol(cellPosition.column);\n if (rowNumbersSvc && isRowNumberColumn && !rowNumbersSvc.handleMouseDownOnCell(cellPosition, mouseEvent)) {\n if (rangeSvc) {\n mouseEvent.preventDefault();\n }\n mouseEvent.stopImmediatePropagation();\n return;\n }\n if (!shiftKey || !hasRanges) {\n const isEnableCellTextSelection = gos.get(\"enableCellTextSelection\");\n const shouldFocus = isEnableCellTextSelection && mouseEvent.defaultPrevented;\n const forceBrowserFocus = (_isBrowserSafari() || shouldFocus) && !cellCtrl.editing && !_isFocusableFormField(target) && !containsWidget;\n cellCtrl.focusCell(forceBrowserFocus);\n }\n if (shiftKey && hasRanges && !focusSvc.isCellFocused(cellPosition)) {\n mouseEvent.preventDefault();\n const focusedCellPosition = focusSvc.getFocusedCell();\n if (focusedCellPosition) {\n const { column, rowIndex, rowPinned } = focusedCellPosition;\n const focusedRowCtrl = beans.rowRenderer.getRowByPosition({ rowIndex, rowPinned });\n const focusedCellCtrl = focusedRowCtrl?.getCellCtrl(column);\n if (focusedCellCtrl?.editing) {\n focusedCellCtrl.stopEditing();\n }\n focusSvc.setFocusedCell({\n column,\n rowIndex,\n rowPinned,\n forceBrowserFocus: true,\n preventScrollOnBrowserFocus: true\n });\n }\n }\n if (containsWidget) {\n return;\n }\n if (rangeSvc) {\n if (isRowNumberColumn) {\n mouseEvent.preventDefault();\n }\n if (shiftKey) {\n rangeSvc.extendLatestRangeToCell(cellPosition);\n } else {\n const isMultiKey = ctrlKey || metaKey;\n rangeSvc.setRangeToCell(cellPosition, isMultiKey);\n }\n }\n eventSvc.dispatchEvent(this.cellCtrl.createEvent(mouseEvent, \"cellMouseDown\"));\n }\n isRightClickInExistingRange(mouseEvent) {\n const { rangeSvc } = this.beans;\n if (rangeSvc) {\n const cellInRange = rangeSvc.isCellInAnyRange(this.cellCtrl.cellPosition);\n const isRightClick = mouseEvent.button === 2 || mouseEvent.ctrlKey && this.beans.gos.get(\"allowContextMenuWithControlKey\");\n if (cellInRange && isRightClick) {\n return true;\n }\n }\n return false;\n }\n containsWidget(target) {\n return _isElementChildOfClass(target, \"ag-selection-checkbox\", 3) || _isElementChildOfClass(target, \"ag-drag-handle\", 3);\n }\n onMouseOut(mouseEvent) {\n if (this.mouseStayingInsideCell(mouseEvent)) {\n return;\n }\n const { eventSvc, colHover } = this.beans;\n eventSvc.dispatchEvent(this.cellCtrl.createEvent(mouseEvent, \"cellMouseOut\"));\n colHover?.clearMouseOver();\n }\n onMouseOver(mouseEvent) {\n if (this.mouseStayingInsideCell(mouseEvent)) {\n return;\n }\n const { eventSvc, colHover } = this.beans;\n eventSvc.dispatchEvent(this.cellCtrl.createEvent(mouseEvent, \"cellMouseOver\"));\n colHover?.setMouseOver([this.column]);\n }\n mouseStayingInsideCell(e) {\n if (!e.target || !e.relatedTarget) {\n return false;\n }\n const eCell = this.cellCtrl.eGui;\n const cellContainsTarget = eCell.contains(e.target);\n const cellContainsRelatedTarget = eCell.contains(e.relatedTarget);\n return cellContainsTarget && cellContainsRelatedTarget;\n }\n destroy() {\n super.destroy();\n }\n};\n\n// packages/ag-grid-community/src/rendering/cell/cellPositionFeature.ts\nvar CellPositionFeature = class extends BeanStub {\n constructor(cellCtrl, beans) {\n super();\n this.cellCtrl = cellCtrl;\n this.beans = beans;\n this.column = cellCtrl.column;\n this.rowNode = cellCtrl.rowNode;\n }\n setupRowSpan() {\n this.rowSpan = this.column.getRowSpan(this.rowNode);\n this.addManagedListeners(this.beans.eventSvc, { newColumnsLoaded: () => this.onNewColumnsLoaded() });\n }\n init() {\n this.eSetLeft = this.cellCtrl.getRootElement();\n this.eContent = this.cellCtrl.eGui;\n const cellSpan = this.cellCtrl.getCellSpan();\n if (!cellSpan) {\n this.setupColSpan();\n this.setupRowSpan();\n }\n this.onLeftChanged();\n this.onWidthChanged();\n if (!cellSpan) {\n this._legacyApplyRowSpan();\n }\n if (cellSpan) {\n this.refreshSpanHeight(cellSpan);\n this.addManagedListeners(this.beans.eventSvc, {\n modelUpdated: this.refreshSpanHeight.bind(this, cellSpan),\n recalculateRowBounds: this.refreshSpanHeight.bind(this, cellSpan)\n });\n }\n }\n refreshSpanHeight(cellSpan) {\n const spanHeight = cellSpan.getCellHeight();\n if (spanHeight != null) {\n this.eContent.style.height = `${spanHeight}px`;\n }\n }\n onNewColumnsLoaded() {\n const rowSpan = this.column.getRowSpan(this.rowNode);\n if (this.rowSpan === rowSpan) {\n return;\n }\n this.rowSpan = rowSpan;\n this._legacyApplyRowSpan(true);\n }\n onDisplayColumnsChanged() {\n const colsSpanning = this.getColSpanningList();\n if (!_areEqual(this.colsSpanning, colsSpanning)) {\n this.colsSpanning = colsSpanning;\n this.onWidthChanged();\n this.onLeftChanged();\n }\n }\n setupColSpan() {\n if (this.column.getColDef().colSpan == null) {\n return;\n }\n this.colsSpanning = this.getColSpanningList();\n this.addManagedListeners(this.beans.eventSvc, {\n // because we are col spanning, a reorder of the cols can change what cols we are spanning over\n displayedColumnsChanged: this.onDisplayColumnsChanged.bind(this),\n // because we are spanning over multiple cols, we check for width any time any cols width changes.\n // this is expensive - really we should be explicitly checking only the cols we are spanning over\n // instead of every col, however it would be tricky code to track the cols we are spanning over, so\n // because hardly anyone will be using colSpan, am favouring this easier way for more maintainable code.\n displayedColumnsWidthChanged: this.onWidthChanged.bind(this)\n });\n }\n onWidthChanged() {\n if (!this.eContent) {\n return;\n }\n const width = this.getCellWidth();\n this.eContent.style.width = `${width}px`;\n }\n getCellWidth() {\n if (!this.colsSpanning) {\n return this.column.getActualWidth();\n }\n return this.colsSpanning.reduce((width, col) => width + col.getActualWidth(), 0);\n }\n getColSpanningList() {\n const { column, rowNode } = this;\n const colSpan = column.getColSpan(rowNode);\n const colsSpanning = [];\n if (colSpan === 1) {\n colsSpanning.push(column);\n } else {\n let pointer = column;\n const pinned = column.getPinned();\n for (let i = 0; pointer && i < colSpan; i++) {\n colsSpanning.push(pointer);\n pointer = this.beans.visibleCols.getColAfter(pointer);\n if (!pointer || _missing(pointer)) {\n break;\n }\n if (pinned !== pointer.getPinned()) {\n break;\n }\n }\n }\n return colsSpanning;\n }\n onLeftChanged() {\n if (!this.eSetLeft) {\n return;\n }\n const left = this.modifyLeftForPrintLayout(this.getCellLeft());\n this.eSetLeft.style.left = left + \"px\";\n }\n getCellLeft() {\n let mostLeftCol;\n if (this.beans.gos.get(\"enableRtl\") && this.colsSpanning) {\n mostLeftCol = _last(this.colsSpanning);\n } else {\n mostLeftCol = this.column;\n }\n return mostLeftCol.getLeft();\n }\n modifyLeftForPrintLayout(leftPosition) {\n if (!this.cellCtrl.printLayout || this.column.getPinned() === \"left\") {\n return leftPosition;\n }\n const { visibleCols } = this.beans;\n const leftWidth = visibleCols.getColsLeftWidth();\n if (this.column.getPinned() === \"right\") {\n const bodyWidth = visibleCols.bodyWidth;\n return leftWidth + bodyWidth + (leftPosition || 0);\n }\n return leftWidth + (leftPosition || 0);\n }\n _legacyApplyRowSpan(force) {\n if (this.rowSpan === 1 && !force) {\n return;\n }\n const singleRowHeight = _getRowHeightAsNumber(this.beans);\n const totalRowHeight = singleRowHeight * this.rowSpan;\n this.eContent.style.height = `${totalRowHeight}px`;\n this.eContent.style.zIndex = \"1\";\n }\n // overriding to make public, as we don't dispose this bean via context\n destroy() {\n super.destroy();\n }\n};\n\n// packages/ag-grid-community/src/rendering/cell/cellCtrl.ts\nvar CSS_CELL = \"ag-cell\";\nvar CSS_AUTO_HEIGHT = \"ag-cell-auto-height\";\nvar CSS_NORMAL_HEIGHT = \"ag-cell-normal-height\";\nvar CSS_CELL_FOCUS = \"ag-cell-focus\";\nvar CSS_CELL_FIRST_RIGHT_PINNED = \"ag-cell-first-right-pinned\";\nvar CSS_CELL_LAST_LEFT_PINNED = \"ag-cell-last-left-pinned\";\nvar CSS_CELL_NOT_INLINE_EDITING = \"ag-cell-not-inline-editing\";\nvar CSS_CELL_WRAP_TEXT = \"ag-cell-wrap-text\";\nvar DOM_DATA_KEY_CELL_CTRL = \"cellCtrl\";\nfunction _getCellCtrlForEventTarget(gos, eventTarget) {\n return _getCtrlForEventTarget(gos, eventTarget, DOM_DATA_KEY_CELL_CTRL);\n}\nvar instanceIdSequence2 = 0;\nvar CellCtrl = class extends BeanStub {\n constructor(column, rowNode, beans, rowCtrl) {\n super();\n this.column = column;\n this.rowNode = rowNode;\n this.rowCtrl = rowCtrl;\n this.rangeFeature = void 0;\n this.positionFeature = void 0;\n this.customStyleFeature = void 0;\n this.tooltipFeature = void 0;\n this.mouseListener = void 0;\n this.keyboardListener = void 0;\n this.suppressRefreshCell = false;\n this.onCompAttachedFuncs = [];\n this.onEditorAttachedFuncs = [];\n this.beans = beans;\n const { colId, colIdSanitised } = column;\n this.instanceId = colId + \"-\" + instanceIdSequence2++;\n this.colIdSanitised = colIdSanitised;\n this.createCellPosition();\n this.updateAndFormatValue(false);\n }\n shouldRestoreFocus() {\n return this.beans.focusSvc.shouldRestoreFocus(this.cellPosition);\n }\n onFocusOut() {\n this.beans.focusSvc.clearRestoreFocus();\n }\n addFeatures() {\n const { beans } = this;\n this.positionFeature = new CellPositionFeature(this, beans);\n this.customStyleFeature = beans.cellStyles?.createCellCustomStyleFeature(this, beans);\n this.mouseListener = new CellMouseListenerFeature(this, beans, this.column);\n this.keyboardListener = new CellKeyboardListenerFeature(this, beans, this.rowNode, this.rowCtrl);\n if (this.column.isTooltipEnabled()) {\n this.enableTooltipFeature();\n }\n const { rangeSvc } = beans;\n const cellSelectionEnabled = rangeSvc && _isCellSelectionEnabled(beans.gos);\n if (cellSelectionEnabled) {\n this.rangeFeature = rangeSvc.createCellRangeFeature(beans, this);\n }\n }\n isCellSpanning() {\n return false;\n }\n getCellSpan() {\n return void 0;\n }\n removeFeatures() {\n const context = this.beans.context;\n this.positionFeature = context.destroyBean(this.positionFeature);\n this.customStyleFeature = context.destroyBean(this.customStyleFeature);\n this.mouseListener = context.destroyBean(this.mouseListener);\n this.keyboardListener = context.destroyBean(this.keyboardListener);\n this.rangeFeature = context.destroyBean(this.rangeFeature);\n this.disableTooltipFeature();\n }\n enableTooltipFeature(value, shouldDisplayTooltip) {\n this.tooltipFeature = this.beans.tooltipSvc?.enableCellTooltipFeature(this, value, shouldDisplayTooltip);\n }\n disableTooltipFeature() {\n this.tooltipFeature = this.beans.context.destroyBean(this.tooltipFeature);\n }\n setComp(comp, eCell, _eWrapper, eCellWrapper, printLayout, startEditing, compBean) {\n this.comp = comp;\n this.eGui = eCell;\n this.printLayout = printLayout;\n compBean ?? (compBean = this);\n this.addDomData(compBean);\n this.addFeatures();\n compBean.addDestroyFunc(() => this.removeFeatures());\n this.onSuppressCellFocusChanged(this.beans.gos.get(\"suppressCellFocus\"));\n this.onCellFocused(this.focusEventToRestore);\n this.applyStaticCssClasses();\n this.setWrapText();\n this.onFirstRightPinnedChanged();\n this.onLastLeftPinnedChanged();\n this.onColumnHover();\n this.setupControlComps();\n this.setupAutoHeight(eCellWrapper, compBean);\n this.refreshFirstAndLastStyles();\n this.refreshAriaColIndex();\n this.positionFeature?.init();\n this.customStyleFeature?.setComp(comp);\n this.tooltipFeature?.refreshTooltip();\n this.keyboardListener?.init();\n this.rangeFeature?.setComp(comp);\n if (startEditing && this.isCellEditable()) {\n this.beans.editSvc?.startEditing(this);\n } else {\n this.showValue(false, true);\n }\n if (this.onCompAttachedFuncs.length) {\n this.onCompAttachedFuncs.forEach((func) => func());\n this.onCompAttachedFuncs = [];\n }\n }\n setupAutoHeight(eCellWrapper, compBean) {\n this.isAutoHeight = this.beans.rowAutoHeight?.setupCellAutoHeight(this, eCellWrapper, compBean) ?? false;\n }\n getCellAriaRole() {\n return this.column.getColDef().cellAriaRole ?? \"gridcell\";\n }\n isCellRenderer() {\n const colDef = this.column.getColDef();\n return colDef.cellRenderer != null || colDef.cellRendererSelector != null;\n }\n getValueToDisplay() {\n return this.valueFormatted ?? this.value;\n }\n showValue(forceNewCellRendererInstance, skipRangeHandleRefresh) {\n const { beans, column, rowNode, rangeFeature } = this;\n const { userCompFactory } = beans;\n const valueToDisplay = this.getValueToDisplay();\n let compDetails;\n const isSsrmLoading = rowNode.stub && rowNode.groupData?.[column.getId()] == null;\n if (isSsrmLoading) {\n const params = this.createCellRendererParams();\n compDetails = _getLoadingCellRendererDetails(userCompFactory, column.getColDef(), params);\n } else if (this.isCellRenderer()) {\n const params = this.createCellRendererParams();\n compDetails = _getCellRendererDetails(userCompFactory, column.getColDef(), params);\n }\n this.comp.setRenderDetails(compDetails, valueToDisplay, forceNewCellRendererInstance);\n if (!skipRangeHandleRefresh && rangeFeature) {\n _requestAnimationFrame(beans, () => rangeFeature?.refreshHandle());\n }\n }\n setupControlComps() {\n const colDef = this.column.getColDef();\n this.includeSelection = this.isIncludeControl(this.isCheckboxSelection(colDef));\n this.includeRowDrag = this.isIncludeControl(colDef.rowDrag);\n this.includeDndSource = this.isIncludeControl(colDef.dndSource);\n this.comp.setIncludeSelection(this.includeSelection);\n this.comp.setIncludeDndSource(this.includeDndSource);\n this.comp.setIncludeRowDrag(this.includeRowDrag);\n }\n isForceWrapper() {\n const forceWrapper = this.beans.gos.get(\"enableCellTextSelection\") || this.column.isAutoHeight();\n return forceWrapper;\n }\n // eslint-disable-next-line @typescript-eslint/ban-types\n isIncludeControl(value) {\n const rowNodePinned = this.rowNode.rowPinned != null;\n const isFunc = typeof value === \"function\";\n const res = rowNodePinned ? false : isFunc || value === true;\n return res;\n }\n isCheckboxSelection(colDef) {\n const { rowSelection } = this.beans.gridOptions;\n return colDef.checkboxSelection || isColumnSelectionCol(this.column) && rowSelection && typeof rowSelection !== \"string\" && _getCheckboxes(rowSelection);\n }\n refreshShouldDestroy() {\n const colDef = this.column.getColDef();\n const selectionChanged = this.includeSelection != this.isIncludeControl(this.isCheckboxSelection(colDef));\n const rowDragChanged = this.includeRowDrag != this.isIncludeControl(colDef.rowDrag);\n const dndSourceChanged = this.includeDndSource != this.isIncludeControl(colDef.dndSource);\n const autoHeightChanged = this.isAutoHeight != this.column.isAutoHeight();\n return selectionChanged || rowDragChanged || dndSourceChanged || autoHeightChanged;\n }\n onPopupEditorClosed() {\n if (!this.editing) {\n return;\n }\n this.stopEditingAndFocus();\n }\n /**\n * Ends the Cell Editing\n * @param cancel `True` if the edit process is being canceled.\n * @returns `True` if the value of the `GridCell` has been updated, otherwise `False`.\n */\n stopEditing(cancel = false) {\n return this.beans.editSvc?.stopEditing(this, cancel) ?? false;\n }\n createCellRendererParams() {\n const {\n value,\n valueFormatted,\n column,\n rowNode,\n comp,\n eGui,\n beans: { valueSvc, gos }\n } = this;\n const res = _addGridCommonParams(gos, {\n value,\n valueFormatted,\n getValue: () => valueSvc.getValueForDisplay(column, rowNode),\n setValue: (value2) => valueSvc.setValue(rowNode, column, value2),\n formatValue: this.formatValue.bind(this),\n data: rowNode.data,\n node: rowNode,\n pinned: column.getPinned(),\n colDef: column.getColDef(),\n column,\n refreshCell: this.refreshCell.bind(this),\n eGridCell: eGui,\n eParentOfValue: comp.getParentOfValue(),\n registerRowDragger: (rowDraggerElement, dragStartPixels, value2, suppressVisibilityChange) => this.registerRowDragger(rowDraggerElement, dragStartPixels, suppressVisibilityChange),\n setTooltip: (value2, shouldDisplayTooltip) => {\n gos.assertModuleRegistered(\"Tooltip\", 3);\n if (this.tooltipFeature) {\n this.disableTooltipFeature();\n }\n this.enableTooltipFeature(value2, shouldDisplayTooltip);\n this.tooltipFeature?.refreshTooltip();\n }\n });\n return res;\n }\n onCellChanged(event) {\n const eventImpactsThisCell = event.column === this.column;\n if (eventImpactsThisCell) {\n this.refreshCell({});\n }\n }\n refreshOrDestroyCell(params) {\n if (this.refreshShouldDestroy()) {\n this.rowCtrl?.recreateCell(this);\n } else {\n this.refreshCell(params);\n }\n }\n // + stop editing {forceRefresh: true, suppressFlash: true}\n // + event cellChanged {}\n // + cellRenderer.params.refresh() {} -> method passes 'as is' to the cellRenderer, so params could be anything\n // + rowCtrl: event dataChanged {suppressFlash: !update, newData: !update}\n // + rowCtrl: api refreshCells() {animate: true/false}\n // + rowRenderer: api softRefreshView() {}\n refreshCell(params) {\n if (this.suppressRefreshCell || this.editing) {\n return;\n }\n const colDef = this.column.getColDef();\n const newData = params != null && !!params.newData;\n const suppressFlash = params != null && !!params.suppressFlash;\n const noValueProvided = colDef.field == null && colDef.valueGetter == null && colDef.showRowGroup == null;\n const forceRefresh = params && params.forceRefresh || noValueProvided || newData;\n const isCellCompReady = !!this.comp;\n const valuesDifferent = this.updateAndFormatValue(isCellCompReady);\n const dataNeedsUpdating = forceRefresh || valuesDifferent;\n if (!isCellCompReady) {\n return;\n }\n if (dataNeedsUpdating) {\n this.showValue(newData, false);\n const processingFilterChange = this.beans.filterManager?.isSuppressFlashingCellsBecauseFiltering();\n const flashCell = !suppressFlash && !processingFilterChange && colDef.enableCellChangeFlash;\n if (flashCell) {\n this.beans.cellFlashSvc?.flashCell(this);\n }\n this.customStyleFeature?.applyUserStyles();\n this.customStyleFeature?.applyClassesFromColDef();\n }\n this.tooltipFeature?.refreshTooltip();\n this.customStyleFeature?.applyCellClassRules();\n }\n // cell editors call this, when they want to stop for reasons other\n // than what we pick up on. eg selecting from a dropdown ends editing.\n stopEditingAndFocus(suppressNavigateAfterEdit = false, shiftKey = false) {\n this.beans.editSvc?.stopEditingAndFocus(this, suppressNavigateAfterEdit, shiftKey);\n }\n isCellEditable() {\n return this.column.isCellEditable(this.rowNode);\n }\n formatValue(value) {\n return this.callValueFormatter(value) ?? value;\n }\n callValueFormatter(value) {\n return this.beans.valueSvc.formatValue(this.column, this.rowNode, value);\n }\n updateAndFormatValue(compareValues) {\n const oldValue = this.value;\n const oldValueFormatted = this.valueFormatted;\n this.value = this.beans.valueSvc.getValueForDisplay(this.column, this.rowNode);\n this.valueFormatted = this.callValueFormatter(this.value);\n if (compareValues) {\n return !this.valuesAreEqual(oldValue, this.value) || this.valueFormatted != oldValueFormatted;\n }\n return true;\n }\n valuesAreEqual(val1, val2) {\n const colDef = this.column.getColDef();\n return colDef.equals ? colDef.equals(val1, val2) : val1 === val2;\n }\n addDomData(compBean) {\n const element = this.eGui;\n _setDomData(this.beans.gos, element, DOM_DATA_KEY_CELL_CTRL, this);\n compBean.addDestroyFunc(() => _setDomData(this.beans.gos, element, DOM_DATA_KEY_CELL_CTRL, null));\n }\n createEvent(domEvent, eventType) {\n const { rowNode, column, value, beans } = this;\n const event = _addGridCommonParams(beans.gos, {\n type: eventType,\n node: rowNode,\n data: rowNode.data,\n value,\n column,\n colDef: column.getColDef(),\n rowPinned: rowNode.rowPinned,\n event: domEvent,\n rowIndex: rowNode.rowIndex\n });\n return event;\n }\n processCharacter(event) {\n this.keyboardListener?.processCharacter(event);\n }\n onKeyDown(event) {\n this.keyboardListener?.onKeyDown(event);\n }\n onMouseEvent(eventName, mouseEvent) {\n this.mouseListener?.onMouseEvent(eventName, mouseEvent);\n }\n getColSpanningList() {\n return this.positionFeature.getColSpanningList();\n }\n onLeftChanged() {\n if (!this.comp) {\n return;\n }\n this.positionFeature?.onLeftChanged();\n }\n onDisplayedColumnsChanged() {\n if (!this.eGui) {\n return;\n }\n this.refreshAriaColIndex();\n this.refreshFirstAndLastStyles();\n }\n refreshFirstAndLastStyles() {\n const { comp, column, beans } = this;\n refreshFirstAndLastStyles(comp, column, beans.visibleCols);\n }\n refreshAriaColIndex() {\n const colIdx = this.beans.visibleCols.getAriaColIndex(this.column);\n _setAriaColIndex(this.eGui, colIdx);\n }\n onWidthChanged() {\n return this.positionFeature?.onWidthChanged();\n }\n getRowPosition() {\n const { rowIndex, rowPinned } = this.cellPosition;\n return {\n rowIndex,\n rowPinned\n };\n }\n updateRangeBordersIfRangeCount() {\n if (!this.comp) {\n return;\n }\n this.rangeFeature?.updateRangeBordersIfRangeCount();\n }\n onCellSelectionChanged() {\n if (!this.comp) {\n return;\n }\n this.rangeFeature?.onCellSelectionChanged();\n }\n isRangeSelectionEnabled() {\n return this.rangeFeature != null;\n }\n focusCell(forceBrowserFocus = false) {\n this.beans.focusSvc.setFocusedCell({\n ...this.getFocusedCellPosition(),\n forceBrowserFocus\n });\n }\n onRowIndexChanged() {\n this.createCellPosition();\n this.onCellFocused();\n this.rangeFeature?.onCellSelectionChanged();\n }\n onSuppressCellFocusChanged(suppressCellFocus) {\n const element = this.eGui;\n if (!element) {\n return;\n }\n if (isRowNumberCol(this.column)) {\n suppressCellFocus = true;\n }\n _addOrRemoveAttribute(element, \"tabindex\", suppressCellFocus ? void 0 : -1);\n }\n onFirstRightPinnedChanged() {\n if (!this.comp) {\n return;\n }\n const firstRightPinned = this.column.isFirstRightPinned();\n this.comp.addOrRemoveCssClass(CSS_CELL_FIRST_RIGHT_PINNED, firstRightPinned);\n }\n onLastLeftPinnedChanged() {\n if (!this.comp) {\n return;\n }\n const lastLeftPinned = this.column.isLastLeftPinned();\n this.comp.addOrRemoveCssClass(CSS_CELL_LAST_LEFT_PINNED, lastLeftPinned);\n }\n isCellFocused() {\n return this.beans.focusSvc.isCellFocused(this.cellPosition);\n }\n onCellFocused(event) {\n const { beans } = this;\n if (_isCellFocusSuppressed(beans)) {\n return;\n }\n const cellFocused = this.isCellFocused();\n if (!this.comp) {\n if (cellFocused && event?.forceBrowserFocus) {\n this.focusEventToRestore = event;\n }\n return;\n }\n this.focusEventToRestore = void 0;\n this.comp.addOrRemoveCssClass(CSS_CELL_FOCUS, cellFocused);\n if (cellFocused && event && event.forceBrowserFocus) {\n let focusEl = this.comp.getFocusableElement();\n if (this.editing) {\n const focusableEls = _findFocusableElements(focusEl, null, true);\n if (focusableEls.length) {\n focusEl = focusableEls[0];\n }\n }\n focusEl.focus({ preventScroll: !!event.preventScrollOnBrowserFocus });\n }\n const fullRowEdit = beans.gos.get(\"editType\") === \"fullRow\";\n if (!cellFocused && !fullRowEdit && this.editing) {\n beans.editSvc?.stopRowOrCellEdit(this);\n }\n if (cellFocused) {\n this.rowCtrl.announceDescription();\n }\n }\n createCellPosition() {\n const { rowIndex, rowPinned } = this.rowNode;\n this.cellPosition = {\n rowIndex,\n rowPinned: _makeNull(rowPinned),\n column: this.column\n };\n }\n setInlineEditingCss() {\n this.beans.editSvc?.setInlineEditingCss(this.rowCtrl);\n }\n // CSS Classes that only get applied once, they never change\n applyStaticCssClasses() {\n const { comp } = this;\n comp.addOrRemoveCssClass(CSS_CELL, true);\n comp.addOrRemoveCssClass(CSS_CELL_NOT_INLINE_EDITING, true);\n const autoHeight = this.column.isAutoHeight() == true;\n comp.addOrRemoveCssClass(CSS_AUTO_HEIGHT, autoHeight);\n comp.addOrRemoveCssClass(CSS_NORMAL_HEIGHT, !autoHeight);\n }\n onColumnHover() {\n this.beans.colHover?.onCellColumnHover(this.column, this.comp);\n }\n onColDefChanged() {\n if (!this.comp) {\n return;\n }\n if (this.column.isTooltipEnabled()) {\n this.disableTooltipFeature();\n this.enableTooltipFeature();\n } else {\n this.disableTooltipFeature();\n }\n this.setWrapText();\n if (!this.editing) {\n this.refreshOrDestroyCell({ forceRefresh: true, suppressFlash: true });\n } else {\n this.beans.editSvc?.handleColDefChanged(this);\n }\n }\n setWrapText() {\n const value = this.column.getColDef().wrapText == true;\n this.comp.addOrRemoveCssClass(CSS_CELL_WRAP_TEXT, value);\n }\n dispatchCellContextMenuEvent(event) {\n const colDef = this.column.getColDef();\n const cellContextMenuEvent = this.createEvent(event, \"cellContextMenu\");\n const { beans } = this;\n beans.eventSvc.dispatchEvent(cellContextMenuEvent);\n if (colDef.onCellContextMenu) {\n window.setTimeout(() => {\n beans.frameworkOverrides.wrapOutgoing(() => {\n colDef.onCellContextMenu(cellContextMenuEvent);\n });\n }, 0);\n }\n }\n getCellRenderer() {\n return this.comp?.getCellRenderer() ?? null;\n }\n destroy() {\n this.onCompAttachedFuncs = [];\n this.onEditorAttachedFuncs = [];\n super.destroy();\n }\n createSelectionCheckbox() {\n const cbSelectionComponent = this.beans.selectionSvc?.createCheckboxSelectionComponent();\n if (!cbSelectionComponent) {\n return void 0;\n }\n this.beans.context.createBean(cbSelectionComponent);\n cbSelectionComponent.init({ rowNode: this.rowNode, column: this.column });\n return cbSelectionComponent;\n }\n createDndSource() {\n const dndSourceComp = this.beans.registry.createDynamicBean(\n \"dndSourceComp\",\n false,\n this.rowNode,\n this.column,\n this.eGui\n );\n if (dndSourceComp) {\n this.beans.context.createBean(dndSourceComp);\n }\n return dndSourceComp;\n }\n registerRowDragger(customElement, dragStartPixels, suppressVisibilityChange) {\n if (this.customRowDragComp) {\n this.customRowDragComp.setDragElement(customElement, dragStartPixels);\n return;\n }\n const newComp = this.createRowDragComp(customElement, dragStartPixels, suppressVisibilityChange);\n if (newComp) {\n this.customRowDragComp = newComp;\n this.addDestroyFunc(() => {\n this.beans.context.destroyBean(newComp);\n this.customRowDragComp = null;\n });\n }\n }\n createRowDragComp(customElement, dragStartPixels, suppressVisibilityChange) {\n const rowDragComp = this.beans.rowDragSvc?.createRowDragCompForCell(\n this.rowNode,\n this.column,\n () => this.value,\n customElement,\n dragStartPixels,\n suppressVisibilityChange\n );\n if (!rowDragComp) {\n return void 0;\n }\n this.beans.context.createBean(rowDragComp);\n return rowDragComp;\n }\n cellEditorAttached() {\n this.onEditorAttachedFuncs.forEach((func) => func());\n this.onEditorAttachedFuncs = [];\n }\n setFocusedCellPosition(_cellPosition) {\n }\n getFocusedCellPosition() {\n return this.cellPosition;\n }\n // used by spannedCellCtrl\n refreshAriaRowIndex() {\n }\n /**\n * Returns the root element of the cell, could be a span container rather than the cell element.\n * @returns The root element of the cell.\n */\n getRootElement() {\n return this.eGui;\n }\n};\n\n// packages/ag-grid-community/src/gridBodyComp/mouseEventUtils.ts\nvar GRID_DOM_KEY = \"__ag_grid_instance\";\nfunction _stampTopLevelGridCompWithGridInstance(gos, eGridDiv) {\n eGridDiv[GRID_DOM_KEY] = gos.gridInstanceId;\n}\nfunction _isEventFromThisGrid(gos, event) {\n const res = _isElementInThisGrid(gos, event.target);\n return res;\n}\nfunction _isElementInThisGrid(gos, element) {\n let pointer = element;\n while (pointer) {\n const instanceId = pointer[GRID_DOM_KEY];\n if (_exists(instanceId)) {\n const eventFromThisGrid = instanceId === gos.gridInstanceId;\n return eventFromThisGrid;\n }\n pointer = pointer.parentElement;\n }\n return false;\n}\nfunction _getCellPositionForEvent(gos, event) {\n return _getCellCtrlForEventTarget(gos, event.target)?.getFocusedCellPosition() ?? null;\n}\nfunction _getNormalisedMousePosition(beans, event) {\n const gridPanelHasScrolls = _isDomLayout(beans.gos, \"normal\");\n const e = event;\n let x;\n let y;\n if (e.clientX != null || e.clientY != null) {\n x = e.clientX;\n y = e.clientY;\n } else {\n x = e.x;\n y = e.y;\n }\n if (gridPanelHasScrolls) {\n const scrollFeature = beans.ctrlsSvc.getScrollFeature();\n const vRange = scrollFeature.getVScrollPosition();\n const hRange = scrollFeature.getHScrollPosition();\n x += hRange.left;\n y += vRange.top;\n }\n return { x, y };\n}\n\n// packages/ag-grid-community/src/dragAndDrop/dragAndDropService.ts\nvar DragSourceType = /* @__PURE__ */ ((DragSourceType2) => {\n DragSourceType2[DragSourceType2[\"ToolPanel\"] = 0] = \"ToolPanel\";\n DragSourceType2[DragSourceType2[\"HeaderCell\"] = 1] = \"HeaderCell\";\n DragSourceType2[DragSourceType2[\"RowDrag\"] = 2] = \"RowDrag\";\n DragSourceType2[DragSourceType2[\"ChartPanel\"] = 3] = \"ChartPanel\";\n DragSourceType2[DragSourceType2[\"AdvancedFilterBuilder\"] = 4] = \"AdvancedFilterBuilder\";\n return DragSourceType2;\n})(DragSourceType || {});\nvar DragAndDropService = class extends BeanStub {\n constructor() {\n super(...arguments);\n this.beanName = \"dragAndDrop\";\n this.dragSourceAndParamsList = [];\n this.dropTargets = [];\n }\n wireBeans(beans) {\n this.ctrlsSvc = beans.ctrlsSvc;\n this.dragSvc = beans.dragSvc;\n this.environment = beans.environment;\n this.userCompFactory = beans.userCompFactory;\n }\n addDragSource(dragSource, allowTouch = false) {\n const params = {\n eElement: dragSource.eElement,\n dragStartPixels: dragSource.dragStartPixels,\n onDragStart: this.onDragStart.bind(this, dragSource),\n onDragStop: this.onDragStop.bind(this),\n onDragging: this.onDragging.bind(this),\n onDragCancel: this.onDragCancel.bind(this),\n includeTouch: allowTouch\n };\n this.dragSourceAndParamsList.push({ params, dragSource });\n this.dragSvc.addDragSource(params);\n }\n getDragAndDropImageComponent() {\n const { dragAndDropImageComp } = this;\n if (!dragAndDropImageComp || !dragAndDropImageComp.comp) {\n return null;\n }\n return dragAndDropImageComp.comp;\n }\n removeDragSource(dragSource) {\n const { dragSourceAndParamsList, dragSvc } = this;\n const sourceAndParams = dragSourceAndParamsList.find((item) => item.dragSource === dragSource);\n if (sourceAndParams) {\n dragSvc.removeDragSource(sourceAndParams.params);\n _removeFromArray(dragSourceAndParamsList, sourceAndParams);\n }\n }\n destroy() {\n const { dragSourceAndParamsList, dragSvc, dropTargets } = this;\n dragSourceAndParamsList.forEach((sourceAndParams) => dragSvc.removeDragSource(sourceAndParams.params));\n dragSourceAndParamsList.length = 0;\n dropTargets.length = 0;\n this.clearDragAndDropProperties();\n super.destroy();\n }\n nudge() {\n if (this.dragging) {\n this.onDragging(this.eventLastTime, true);\n }\n }\n onDragStart(dragSource, mouseEvent) {\n this.dragging = true;\n this.dragSource = dragSource;\n this.eventLastTime = mouseEvent;\n this.dragItem = dragSource.getDragItem();\n dragSource.onDragStarted?.();\n this.createDragAndDropImageComponent();\n }\n onDragStop(mouseEvent) {\n this.dragSource?.onDragStopped?.();\n const { lastDropTarget } = this;\n if (lastDropTarget?.onDragStop) {\n const draggingEvent = this.createDropTargetEvent(lastDropTarget, mouseEvent, null, null, false);\n lastDropTarget.onDragStop(draggingEvent);\n }\n this.clearDragAndDropProperties();\n }\n onDragCancel() {\n const { dragSource, lastDropTarget } = this;\n dragSource?.onDragCancelled?.();\n if (lastDropTarget?.onDragCancel) {\n lastDropTarget.onDragCancel(\n this.createDropTargetEvent(lastDropTarget, this.eventLastTime, null, null, false)\n );\n }\n this.clearDragAndDropProperties();\n }\n clearDragAndDropProperties() {\n this.eventLastTime = null;\n this.dragging = false;\n this.lastDropTarget = void 0;\n this.dragItem = null;\n this.dragSource = null;\n this.removeDragAndDropImageComponent();\n }\n onDragging(mouseEvent, fromNudge = false) {\n const hDirection = this.getHorizontalDirection(mouseEvent);\n const vDirection = this.getVerticalDirection(mouseEvent);\n this.eventLastTime = mouseEvent;\n this.positionDragAndDropImageComp(mouseEvent);\n const validDropTargets = this.dropTargets.filter((target) => this.isMouseOnDropTarget(mouseEvent, target));\n const dropTarget = this.findCurrentDropTarget(mouseEvent, validDropTargets);\n const { lastDropTarget, dragSource, dragAndDropImageComp, dragItem } = this;\n if (dropTarget !== lastDropTarget) {\n this.leaveLastTargetIfExists(mouseEvent, hDirection, vDirection, fromNudge);\n if (lastDropTarget !== null && dropTarget === null) {\n dragSource?.onGridExit?.(dragItem);\n }\n if (lastDropTarget === null && dropTarget !== null) {\n dragSource?.onGridEnter?.(dragItem);\n }\n this.enterDragTargetIfExists(dropTarget, mouseEvent, hDirection, vDirection, fromNudge);\n if (dropTarget && dragAndDropImageComp) {\n const { comp, promise } = dragAndDropImageComp;\n if (comp) {\n comp.setIcon(dropTarget.getIconName ? dropTarget.getIconName() : null, false);\n } else {\n promise.then((resolvedComponent) => {\n if (resolvedComponent) {\n resolvedComponent.setIcon(dropTarget.getIconName ? dropTarget.getIconName() : null, false);\n }\n });\n }\n }\n this.lastDropTarget = dropTarget;\n } else if (dropTarget && dropTarget.onDragging) {\n const draggingEvent = this.createDropTargetEvent(dropTarget, mouseEvent, hDirection, vDirection, fromNudge);\n dropTarget.onDragging(draggingEvent);\n }\n }\n getAllContainersFromDropTarget(dropTarget) {\n const secondaryContainers = dropTarget.getSecondaryContainers ? dropTarget.getSecondaryContainers() : null;\n const containers = [[dropTarget.getContainer()]];\n return secondaryContainers ? containers.concat(secondaryContainers) : containers;\n }\n // checks if the mouse is on the drop target. it checks eContainer and eSecondaryContainers\n isMouseOnDropTarget(mouseEvent, dropTarget) {\n const allContainersFromDropTarget = this.getAllContainersFromDropTarget(dropTarget);\n let mouseOverTarget = false;\n const allContainersIntersect = (mouseEvent2, containers) => {\n for (const container of containers) {\n const { width, height, left, right, top, bottom } = container.getBoundingClientRect();\n if (width === 0 || height === 0) {\n return false;\n }\n const horizontalFit = mouseEvent2.clientX >= left && mouseEvent2.clientX < right;\n const verticalFit = mouseEvent2.clientY >= top && mouseEvent2.clientY < bottom;\n if (!horizontalFit || !verticalFit) {\n return false;\n }\n }\n return true;\n };\n for (const currentContainers of allContainersFromDropTarget) {\n if (allContainersIntersect(mouseEvent, currentContainers)) {\n mouseOverTarget = true;\n break;\n }\n }\n const { eElement, type } = this.dragSource;\n if (dropTarget.targetContainsSource && !dropTarget.getContainer().contains(eElement)) {\n return false;\n }\n return mouseOverTarget && dropTarget.isInterestedIn(type, eElement);\n }\n findCurrentDropTarget(mouseEvent, validDropTargets) {\n const len = validDropTargets.length;\n if (len === 0) {\n return null;\n }\n if (len === 1) {\n return validDropTargets[0];\n }\n const rootNode = _getRootNode(this.beans);\n const elementStack = rootNode.elementsFromPoint(mouseEvent.clientX, mouseEvent.clientY);\n for (const el of elementStack) {\n for (const dropTarget of validDropTargets) {\n const containers = this.getAllContainersFromDropTarget(dropTarget).flatMap((a) => a);\n if (containers.indexOf(el) !== -1) {\n return dropTarget;\n }\n }\n }\n return null;\n }\n enterDragTargetIfExists(dropTarget, mouseEvent, hDirection, vDirection, fromNudge) {\n if (!dropTarget) {\n return;\n }\n if (dropTarget.onDragEnter) {\n const dragEnterEvent = this.createDropTargetEvent(\n dropTarget,\n mouseEvent,\n hDirection,\n vDirection,\n fromNudge\n );\n dropTarget.onDragEnter(dragEnterEvent);\n }\n }\n leaveLastTargetIfExists(mouseEvent, hDirection, vDirection, fromNudge) {\n const { lastDropTarget } = this;\n if (!lastDropTarget) {\n return;\n }\n if (lastDropTarget.onDragLeave) {\n const dragLeaveEvent = this.createDropTargetEvent(\n lastDropTarget,\n mouseEvent,\n hDirection,\n vDirection,\n fromNudge\n );\n lastDropTarget.onDragLeave(dragLeaveEvent);\n }\n const dragAndDropImageComponent = this.getDragAndDropImageComponent();\n if (dragAndDropImageComponent) {\n dragAndDropImageComponent.setIcon(null, false);\n }\n }\n addDropTarget(dropTarget) {\n this.dropTargets.push(dropTarget);\n }\n removeDropTarget(dropTarget) {\n this.dropTargets = this.dropTargets.filter((target) => target.getContainer() !== dropTarget.getContainer());\n }\n hasExternalDropZones() {\n return this.dropTargets.some((zones) => zones.external);\n }\n findExternalZone(params) {\n const externalTargets = this.dropTargets.filter((target) => target.external);\n return externalTargets.find((zone) => zone.getContainer() === params.getContainer()) || null;\n }\n isDropZoneWithinThisGrid(draggingEvent) {\n const gridBodyCon = this.ctrlsSvc.getGridBodyCtrl();\n const gridGui = gridBodyCon.eGridBody;\n const { dropZoneTarget } = draggingEvent;\n return gridGui.contains(dropZoneTarget);\n }\n getHorizontalDirection(event) {\n const clientX = this.eventLastTime?.clientX;\n const eClientX = event.clientX;\n if (clientX === eClientX) {\n return null;\n }\n return clientX > eClientX ? \"left\" : \"right\";\n }\n getVerticalDirection(event) {\n const clientY = this.eventLastTime?.clientY;\n const eClientY = event.clientY;\n if (clientY === eClientY) {\n return null;\n }\n return clientY > eClientY ? \"up\" : \"down\";\n }\n createDropTargetEvent(dropTarget, event, hDirection, vDirection, fromNudge) {\n const dropZoneTarget = dropTarget.getContainer();\n const rect = dropZoneTarget.getBoundingClientRect();\n const { dragItem, dragSource, gos } = this;\n const x = event.clientX - rect.left;\n const y = event.clientY - rect.top;\n return _addGridCommonParams(gos, {\n event,\n x,\n y,\n vDirection,\n hDirection,\n dragSource,\n fromNudge,\n dragItem,\n dropZoneTarget\n });\n }\n positionDragAndDropImageComp(event) {\n const dragAndDropImageComponent = this.getDragAndDropImageComponent();\n if (!dragAndDropImageComponent) {\n return;\n }\n _anchorElementToMouseMoveEvent(dragAndDropImageComponent.getGui(), event, this.beans);\n }\n removeDragAndDropImageComponent() {\n const { dragAndDropImageComp } = this;\n if (dragAndDropImageComp) {\n const { comp } = dragAndDropImageComp;\n if (comp) {\n const eGui = comp.getGui();\n this.dragAndDropImageParent?.removeChild(eGui);\n this.destroyBean(comp);\n }\n }\n this.dragAndDropImageComp = null;\n }\n createDragAndDropImageComponent() {\n const { dragSource, gos, userCompFactory } = this;\n if (!dragSource) {\n return;\n }\n const userCompDetails = _getDragAndDropImageCompDetails(\n userCompFactory,\n _addGridCommonParams(gos, {\n dragSource\n })\n );\n if (!userCompDetails) {\n return;\n }\n const promise = userCompDetails.newAgStackInstance();\n this.dragAndDropImageComp = {\n promise\n };\n promise.then((comp) => {\n if (!comp || !this.isAlive()) {\n return;\n }\n this.processDragAndDropImageComponent(comp);\n this.dragAndDropImageComp.comp = comp;\n });\n }\n processDragAndDropImageComponent(dragAndDropImageComponent) {\n const { dragSource, environment } = this;\n if (!dragSource) {\n return;\n }\n const eGui = dragAndDropImageComponent.getGui();\n eGui.style.setProperty(\"position\", \"absolute\");\n eGui.style.setProperty(\"z-index\", \"9999\");\n _stampTopLevelGridCompWithGridInstance(this.gos, eGui);\n environment.applyThemeClasses(eGui);\n dragAndDropImageComponent.setIcon(null, false);\n let { dragItemName } = dragSource;\n if (typeof dragItemName === \"function\") {\n dragItemName = dragItemName();\n }\n dragAndDropImageComponent.setLabel(dragItemName || \"\");\n eGui.style.top = \"20px\";\n eGui.style.left = \"20px\";\n const targetEl = _getPageBody(this.beans);\n this.dragAndDropImageParent = targetEl;\n if (!targetEl) {\n _warn(54);\n } else {\n targetEl.appendChild(eGui);\n }\n }\n registerGridDropTarget(elementFn, ctrl) {\n const dropTarget = {\n getContainer: elementFn,\n isInterestedIn: (type) => type === 1 /* HeaderCell */ || type === 0 /* ToolPanel */,\n getIconName: () => \"notAllowed\"\n };\n this.addDropTarget(dropTarget);\n ctrl.addDestroyFunc(() => this.removeDropTarget(dropTarget));\n }\n};\n\n// packages/ag-grid-community/src/autoScrollService.ts\nvar AutoScrollService = class {\n constructor(params) {\n this.tickingInterval = null;\n this.onScrollCallback = null;\n this.scrollContainer = params.scrollContainer;\n this.scrollHorizontally = params.scrollAxis.indexOf(\"x\") !== -1;\n this.scrollVertically = params.scrollAxis.indexOf(\"y\") !== -1;\n this.scrollByTick = params.scrollByTick != null ? params.scrollByTick : 20;\n if (params.onScrollCallback) {\n this.onScrollCallback = params.onScrollCallback;\n }\n if (this.scrollVertically) {\n this.getVerticalPosition = params.getVerticalPosition;\n this.setVerticalPosition = params.setVerticalPosition;\n }\n if (this.scrollHorizontally) {\n this.getHorizontalPosition = params.getHorizontalPosition;\n this.setHorizontalPosition = params.setHorizontalPosition;\n }\n this.shouldSkipVerticalScroll = params.shouldSkipVerticalScroll || (() => false);\n this.shouldSkipHorizontalScroll = params.shouldSkipHorizontalScroll || (() => false);\n }\n check(mouseEvent, forceSkipVerticalScroll = false) {\n const skipVerticalScroll = forceSkipVerticalScroll || this.shouldSkipVerticalScroll();\n if (skipVerticalScroll && this.shouldSkipHorizontalScroll()) {\n return;\n }\n const rect = this.scrollContainer.getBoundingClientRect();\n const scrollTick = this.scrollByTick;\n this.tickLeft = mouseEvent.clientX < rect.left + scrollTick;\n this.tickRight = mouseEvent.clientX > rect.right - scrollTick;\n this.tickUp = mouseEvent.clientY < rect.top + scrollTick && !skipVerticalScroll;\n this.tickDown = mouseEvent.clientY > rect.bottom - scrollTick && !skipVerticalScroll;\n if (this.tickLeft || this.tickRight || this.tickUp || this.tickDown) {\n this.ensureTickingStarted();\n } else {\n this.ensureCleared();\n }\n }\n ensureTickingStarted() {\n if (this.tickingInterval === null) {\n this.tickingInterval = window.setInterval(this.doTick.bind(this), 100);\n this.tickCount = 0;\n }\n }\n doTick() {\n this.tickCount++;\n const tickAmount = this.tickCount > 20 ? 200 : this.tickCount > 10 ? 80 : 40;\n if (this.scrollVertically) {\n const vScrollPosition = this.getVerticalPosition();\n if (this.tickUp) {\n this.setVerticalPosition(vScrollPosition - tickAmount);\n }\n if (this.tickDown) {\n this.setVerticalPosition(vScrollPosition + tickAmount);\n }\n }\n if (this.scrollHorizontally) {\n const hScrollPosition = this.getHorizontalPosition();\n if (this.tickLeft) {\n this.setHorizontalPosition(hScrollPosition - tickAmount);\n }\n if (this.tickRight) {\n this.setHorizontalPosition(hScrollPosition + tickAmount);\n }\n }\n if (this.onScrollCallback) {\n this.onScrollCallback();\n }\n }\n ensureCleared() {\n if (this.tickingInterval) {\n window.clearInterval(this.tickingInterval);\n this.tickingInterval = null;\n }\n }\n};\n\n// packages/ag-grid-community/src/entities/positionUtils.ts\nfunction _createCellId(cellPosition) {\n const { rowIndex, rowPinned, column } = cellPosition;\n return `${rowIndex}.${rowPinned == null ? \"null\" : rowPinned}.${column.getId()}`;\n}\nfunction _areCellsEqual(cellA, cellB) {\n const colsMatch = cellA.column === cellB.column;\n const floatingMatch = cellA.rowPinned === cellB.rowPinned;\n const indexMatch = cellA.rowIndex === cellB.rowIndex;\n return colsMatch && floatingMatch && indexMatch;\n}\nfunction _isRowBefore(rowA, rowB) {\n switch (rowA.rowPinned) {\n case \"top\":\n if (rowB.rowPinned !== \"top\") {\n return true;\n }\n break;\n case \"bottom\":\n if (rowB.rowPinned !== \"bottom\") {\n return false;\n }\n break;\n default:\n if (_exists(rowB.rowPinned)) {\n return rowB.rowPinned !== \"top\";\n }\n break;\n }\n return rowA.rowIndex < rowB.rowIndex;\n}\nfunction _isSameRow(rowA, rowB) {\n if (!rowA && !rowB) {\n return true;\n }\n if (rowA && !rowB || !rowA && rowB) {\n return false;\n }\n return rowA.rowIndex === rowB.rowIndex && rowA.rowPinned == rowB.rowPinned;\n}\nfunction _getFirstRow(beans) {\n let rowIndex = 0;\n let rowPinned;\n const { pinnedRowModel, rowModel, pageBounds } = beans;\n if (pinnedRowModel?.getPinnedTopRowCount()) {\n rowPinned = \"top\";\n } else if (rowModel.getRowCount()) {\n rowPinned = null;\n rowIndex = pageBounds.getFirstRow();\n } else if (pinnedRowModel?.getPinnedBottomRowCount()) {\n rowPinned = \"bottom\";\n }\n return rowPinned === void 0 ? null : { rowIndex, rowPinned };\n}\nfunction _getLastRow(beans) {\n let rowIndex;\n let rowPinned = null;\n const { pinnedRowModel, pageBounds } = beans;\n const pinnedBottomCount = pinnedRowModel?.getPinnedBottomRowCount();\n const pinnedTopCount = pinnedRowModel?.getPinnedTopRowCount();\n if (pinnedBottomCount) {\n rowPinned = \"bottom\";\n rowIndex = pinnedBottomCount - 1;\n } else if (beans.rowModel.getRowCount()) {\n rowPinned = null;\n rowIndex = pageBounds.getLastRow();\n } else if (pinnedTopCount) {\n rowPinned = \"top\";\n rowIndex = pinnedTopCount - 1;\n }\n return rowIndex === void 0 ? null : { rowIndex, rowPinned };\n}\nfunction _getRowNode(beans, gridRow) {\n switch (gridRow.rowPinned) {\n case \"top\":\n return beans.pinnedRowModel?.getPinnedTopRow(gridRow.rowIndex);\n case \"bottom\":\n return beans.pinnedRowModel?.getPinnedBottomRow(gridRow.rowIndex);\n default:\n return beans.rowModel.getRow(gridRow.rowIndex);\n }\n}\nfunction _getCellByPosition(beans, cellPosition) {\n const spannedCellCtrl = beans.spannedRowRenderer?.getCellByPosition(cellPosition);\n if (spannedCellCtrl) {\n return spannedCellCtrl;\n }\n const rowCtrl = beans.rowRenderer.getRowByPosition(cellPosition);\n if (!rowCtrl) {\n return null;\n }\n return rowCtrl.getCellCtrl(cellPosition.column);\n}\n\n// packages/ag-grid-community/src/dragAndDrop/rowDragFeature.ts\nvar RowDragFeature = class extends BeanStub {\n constructor(eContainer) {\n super();\n this.eContainer = eContainer;\n }\n postConstruct() {\n const { rowModel, gos, ctrlsSvc } = this.beans;\n if (_isClientSideRowModel(gos, rowModel)) {\n this.clientSideRowModel = rowModel;\n }\n ctrlsSvc.whenReady(this, (p) => {\n const gridBodyCon = p.gridBodyCtrl;\n this.autoScrollService = new AutoScrollService({\n scrollContainer: gridBodyCon.eBodyViewport,\n scrollAxis: \"y\",\n getVerticalPosition: () => gridBodyCon.scrollFeature.getVScrollPosition().top,\n setVerticalPosition: (position) => gridBodyCon.scrollFeature.setVerticalScrollPosition(position),\n onScrollCallback: () => {\n this.onDragging(this.lastDraggingEvent);\n }\n });\n });\n }\n getContainer() {\n return this.eContainer;\n }\n isInterestedIn(type) {\n return type === 2 /* RowDrag */;\n }\n getIconName() {\n const managedDrag = this.gos.get(\"rowDragManaged\");\n if (managedDrag && this.shouldPreventRowMove()) {\n return \"notAllowed\";\n }\n return \"move\";\n }\n shouldPreventRowMove() {\n const { rowGroupColsSvc, filterManager, sortSvc } = this.beans;\n const rowGroupCols = rowGroupColsSvc?.columns ?? [];\n if (rowGroupCols.length) {\n return true;\n }\n const isFilterPresent = filterManager?.isAnyFilterPresent();\n if (isFilterPresent) {\n return true;\n }\n const isSortActive = sortSvc?.isSortActive();\n if (isSortActive) {\n return true;\n }\n return false;\n }\n getRowNodes(draggingEvent) {\n if (!this.isFromThisGrid(draggingEvent)) {\n return draggingEvent.dragItem.rowNodes || [];\n }\n const currentNode = draggingEvent.dragItem.rowNode;\n const isRowDragMultiRow = this.gos.get(\"rowDragMultiRow\");\n if (isRowDragMultiRow) {\n const selectedNodes = [...this.beans.selectionSvc?.getSelectedNodes() ?? []].sort((a, b) => {\n if (a.rowIndex == null || b.rowIndex == null) {\n return 0;\n }\n return this.getRowIndexNumber(a) - this.getRowIndexNumber(b);\n });\n if (selectedNodes.indexOf(currentNode) !== -1) {\n return selectedNodes;\n }\n }\n return [currentNode];\n }\n onDragEnter(draggingEvent) {\n draggingEvent.dragItem.rowNodes = this.getRowNodes(draggingEvent);\n this.dispatchGridEvent(\"rowDragEnter\", draggingEvent);\n this.getRowNodes(draggingEvent).forEach((rowNode) => {\n this.setRowNodeDragging(rowNode, true);\n });\n this.onEnterOrDragging(draggingEvent);\n }\n onDragging(draggingEvent) {\n this.onEnterOrDragging(draggingEvent);\n }\n isFromThisGrid(draggingEvent) {\n const { dragSourceDomDataKey } = draggingEvent.dragSource;\n return dragSourceDomDataKey === this.gos.getDomDataKey();\n }\n onEnterOrDragging(draggingEvent) {\n this.dispatchGridEvent(\"rowDragMove\", draggingEvent);\n this.lastDraggingEvent = draggingEvent;\n const pixel = _getNormalisedMousePosition(this.beans, draggingEvent).y;\n const managedDrag = this.gos.get(\"rowDragManaged\");\n if (managedDrag) {\n this.doManagedDrag(draggingEvent, pixel);\n }\n this.autoScrollService.check(draggingEvent.event);\n }\n doManagedDrag(draggingEvent, pixel) {\n const { dragAndDrop, gos } = this.beans;\n const isFromThisGrid = this.isFromThisGrid(draggingEvent);\n const managedDrag = gos.get(\"rowDragManaged\");\n const rowNodes = draggingEvent.dragItem.rowNodes;\n if (managedDrag && this.shouldPreventRowMove()) {\n return;\n }\n if (gos.get(\"suppressMoveWhenRowDragging\") || !isFromThisGrid) {\n if (dragAndDrop.isDropZoneWithinThisGrid(draggingEvent)) {\n this.clientSideRowModel.highlightRowAtPixel(rowNodes[0], pixel);\n }\n } else {\n this.moveRows(rowNodes, pixel);\n }\n }\n getRowIndexNumber(rowNode) {\n const rowIndexStr = rowNode.getRowIndexString();\n return parseInt(_last(rowIndexStr.split(\"-\")), 10);\n }\n moveRowAndClearHighlight(draggingEvent) {\n const clientSideRowModel = this.clientSideRowModel;\n const lastHighlightedRowNode = clientSideRowModel.getLastHighlightedRowNode();\n const isBelow = lastHighlightedRowNode && lastHighlightedRowNode.highlighted === \"Below\";\n const pixel = _getNormalisedMousePosition(this.beans, draggingEvent).y;\n const rowNodes = draggingEvent.dragItem.rowNodes;\n let increment = isBelow ? 1 : 0;\n if (this.isFromThisGrid(draggingEvent)) {\n rowNodes.forEach((rowNode) => {\n if (rowNode.rowTop < pixel) {\n increment -= 1;\n }\n });\n this.moveRows(rowNodes, pixel, increment);\n } else {\n const getRowIdFunc = _getRowIdCallback(this.gos);\n let addIndex = clientSideRowModel.getRowIndexAtPixel(pixel) + 1;\n if (clientSideRowModel.getHighlightPosition(pixel) === \"Above\") {\n addIndex--;\n }\n clientSideRowModel.updateRowData({\n add: rowNodes.filter(\n (node) => !clientSideRowModel.getRowNode(\n getRowIdFunc?.({ data: node.data, level: 0, rowPinned: node.rowPinned }) ?? node.data.id\n )\n ).map((node) => node.data),\n addIndex\n });\n }\n this.clearRowHighlight();\n }\n clearRowHighlight() {\n this.clientSideRowModel.highlightRowAtPixel(null);\n }\n moveRows(rowNodes, pixel, increment = 0) {\n const focusSvc = this.beans.focusSvc;\n const cellPosition = focusSvc.getFocusedCell();\n const cellCtrl = cellPosition && _getCellByPosition(this.beans, cellPosition);\n const rowWasMoved = this.clientSideRowModel.ensureRowsAtPixel(rowNodes, pixel, increment);\n if (rowWasMoved) {\n if (cellCtrl) {\n cellCtrl.focusCell();\n } else {\n focusSvc.clearFocusedCell();\n }\n }\n }\n addRowDropZone(params) {\n if (!params.getContainer()) {\n _warn(55);\n return;\n }\n const dragAndDrop = this.beans.dragAndDrop;\n if (dragAndDrop.findExternalZone(params)) {\n _warn(56);\n return;\n }\n let processedParams = {\n getContainer: params.getContainer\n };\n if (params.fromGrid) {\n processedParams = params;\n } else {\n if (params.onDragEnter) {\n processedParams.onDragEnter = (e) => {\n params.onDragEnter(this.draggingToRowDragEvent(\"rowDragEnter\", e));\n };\n }\n if (params.onDragLeave) {\n processedParams.onDragLeave = (e) => {\n params.onDragLeave(this.draggingToRowDragEvent(\"rowDragLeave\", e));\n };\n }\n if (params.onDragging) {\n processedParams.onDragging = (e) => {\n params.onDragging(this.draggingToRowDragEvent(\"rowDragMove\", e));\n };\n }\n if (params.onDragStop) {\n processedParams.onDragStop = (e) => {\n params.onDragStop(this.draggingToRowDragEvent(\"rowDragEnd\", e));\n };\n }\n if (params.onDragCancel) {\n processedParams.onDragCancel = (e) => {\n params.onDragCancel(this.draggingToRowDragEvent(\"rowDragCancel\", e));\n };\n }\n }\n const dropTarget = {\n isInterestedIn: (type) => type === 2 /* RowDrag */,\n getIconName: () => \"move\",\n external: true,\n ...processedParams\n };\n dragAndDrop.addDropTarget(dropTarget);\n this.addDestroyFunc(() => dragAndDrop.removeDropTarget(dropTarget));\n }\n getRowDropZone(events) {\n const getContainer = this.getContainer.bind(this);\n const onDragEnter = this.onDragEnter.bind(this);\n const onDragLeave = this.onDragLeave.bind(this);\n const onDragging = this.onDragging.bind(this);\n const onDragStop = this.onDragStop.bind(this);\n const onDragCancel = this.onDragCancel.bind(this);\n let params;\n if (!events) {\n params = {\n getContainer,\n onDragEnter,\n onDragLeave,\n onDragging,\n onDragStop,\n onDragCancel,\n /* @private */\n fromGrid: true\n };\n } else {\n params = {\n getContainer,\n onDragEnter: events.onDragEnter ? (e) => {\n onDragEnter(e);\n events.onDragEnter(this.draggingToRowDragEvent(\"rowDragEnter\", e));\n } : onDragEnter,\n onDragLeave: events.onDragLeave ? (e) => {\n onDragLeave(e);\n events.onDragLeave(this.draggingToRowDragEvent(\"rowDragLeave\", e));\n } : onDragLeave,\n onDragging: events.onDragging ? (e) => {\n onDragging(e);\n events.onDragging(this.draggingToRowDragEvent(\"rowDragMove\", e));\n } : onDragging,\n onDragStop: events.onDragStop ? (e) => {\n onDragStop(e);\n events.onDragStop(this.draggingToRowDragEvent(\"rowDragEnd\", e));\n } : onDragStop,\n onDragCancel: events.onDragCancel ? (e) => {\n onDragCancel(e);\n events.onDragCancel(this.draggingToRowDragEvent(\"rowDragCancel\", e));\n } : onDragCancel,\n fromGrid: true\n };\n }\n return params;\n }\n draggingToRowDragEvent(type, draggingEvent) {\n const beans = this.beans;\n const { pageBounds, rowModel, gos } = beans;\n const yNormalised = _getNormalisedMousePosition(beans, draggingEvent).y;\n const mouseIsPastLastRow = yNormalised > pageBounds.getCurrentPageHeight();\n let overIndex = -1;\n let overNode;\n if (!mouseIsPastLastRow) {\n overIndex = rowModel.getRowIndexAtPixel(yNormalised);\n overNode = rowModel.getRow(overIndex);\n }\n const event = _addGridCommonParams(gos, {\n type,\n event: draggingEvent.event,\n node: draggingEvent.dragItem.rowNode,\n nodes: draggingEvent.dragItem.rowNodes,\n overIndex,\n overNode,\n y: yNormalised,\n vDirection: draggingEvent.vDirection\n });\n return event;\n }\n dispatchGridEvent(type, draggingEvent) {\n const event = this.draggingToRowDragEvent(type, draggingEvent);\n this.eventSvc.dispatchEvent(event);\n }\n onDragLeave(draggingEvent) {\n this.dispatchGridEvent(\"rowDragLeave\", draggingEvent);\n this.stopDragging(draggingEvent);\n if (this.gos.get(\"rowDragManaged\")) {\n this.clearRowHighlight();\n }\n }\n onDragStop(draggingEvent) {\n this.dispatchGridEvent(\"rowDragEnd\", draggingEvent);\n this.stopDragging(draggingEvent);\n const { dragAndDrop, gos } = this.beans;\n if (gos.get(\"rowDragManaged\") && (gos.get(\"suppressMoveWhenRowDragging\") || !this.isFromThisGrid(draggingEvent)) && dragAndDrop.isDropZoneWithinThisGrid(draggingEvent)) {\n this.moveRowAndClearHighlight(draggingEvent);\n }\n }\n onDragCancel(draggingEvent) {\n this.dispatchGridEvent(\"rowDragCancel\", draggingEvent);\n this.stopDragging(draggingEvent);\n const { dragAndDrop, gos } = this.beans;\n if (gos.get(\"rowDragManaged\") && (gos.get(\"suppressMoveWhenRowDragging\") || !this.isFromThisGrid(draggingEvent)) && dragAndDrop.isDropZoneWithinThisGrid(draggingEvent)) {\n this.clearRowHighlight();\n }\n }\n stopDragging(draggingEvent) {\n this.autoScrollService.ensureCleared();\n this.getRowNodes(draggingEvent).forEach((rowNode) => {\n this.setRowNodeDragging(rowNode, false);\n });\n }\n setRowNodeDragging(rowNode, dragging) {\n if (rowNode.dragging !== dragging) {\n rowNode.dragging = dragging;\n rowNode.dispatchRowEvent(\"draggingChanged\");\n }\n }\n};\n\n// packages/ag-grid-community/src/utils/mouse.ts\nfunction _areEventsNear(e1, e2, pixelCount) {\n if (pixelCount === 0) {\n return false;\n }\n const diffX = Math.abs(e1.clientX - e2.clientX);\n const diffY = Math.abs(e1.clientY - e2.clientY);\n return Math.max(diffX, diffY) <= pixelCount;\n}\n\n// packages/ag-grid-community/src/dragAndDrop/dragService.ts\nvar DragService = class extends BeanStub {\n constructor() {\n super(...arguments);\n this.beanName = \"dragSvc\";\n this.dragEndFunctions = [];\n this.dragSources = [];\n }\n destroy() {\n const { dragSources } = this;\n dragSources.forEach(this.removeListener.bind(this));\n dragSources.length = 0;\n super.destroy();\n }\n removeListener(dragSourceAndListener) {\n const element = dragSourceAndListener.dragSource.eElement;\n const mouseDownListener = dragSourceAndListener.mouseDownListener;\n element.removeEventListener(\"mousedown\", mouseDownListener);\n if (dragSourceAndListener.touchEnabled) {\n const touchStartListener = dragSourceAndListener.touchStartListener;\n element.removeEventListener(\"touchstart\", touchStartListener, { passive: true });\n }\n }\n removeDragSource(params) {\n const { dragSources } = this;\n const dragSourceAndListener = dragSources.find((item) => item.dragSource === params);\n if (!dragSourceAndListener) {\n return;\n }\n this.removeListener(dragSourceAndListener);\n _removeFromArray(dragSources, dragSourceAndListener);\n }\n addDragSource(params) {\n const mouseListener = this.onMouseDown.bind(this, params);\n const { eElement, includeTouch, stopPropagationForTouch } = params;\n eElement.addEventListener(\"mousedown\", mouseListener);\n let touchListener = null;\n const suppressTouch = this.gos.get(\"suppressTouch\");\n if (includeTouch && !suppressTouch) {\n touchListener = (touchEvent) => {\n if (_isFocusableFormField(touchEvent.target)) {\n return;\n }\n if (stopPropagationForTouch) {\n touchEvent.stopPropagation();\n }\n this.onTouchStart(params, touchEvent);\n };\n eElement.addEventListener(\"touchstart\", touchListener, { passive: false });\n }\n this.dragSources.push({\n dragSource: params,\n mouseDownListener: mouseListener,\n touchStartListener: touchListener,\n touchEnabled: !!includeTouch\n });\n }\n // gets called whenever mouse down on any drag source\n onTouchStart(params, touchEvent) {\n this.currentDragParams = params;\n this.dragging = false;\n const touch = touchEvent.touches[0];\n this.touchLastTime = touch;\n this.touchStart = touch;\n const touchMoveEvent = (e) => this.onTouchMove(e, params.eElement);\n const touchEndEvent = (e) => this.onTouchUp(e, params.eElement);\n const documentTouchMove = (e) => {\n if (e.cancelable) {\n e.preventDefault();\n }\n };\n const target = touchEvent.target;\n const events = [\n // Prevents the page document from moving while we are dragging items around.\n // preventDefault needs to be called in the touchmove listener and never inside the\n // touchstart, because using touchstart causes the click event to be cancelled on touch devices.\n {\n target: _getRootNode(this.beans),\n type: \"touchmove\",\n listener: documentTouchMove,\n options: { passive: false }\n },\n { target, type: \"touchmove\", listener: touchMoveEvent, options: { passive: true } },\n { target, type: \"touchend\", listener: touchEndEvent, options: { passive: true } },\n { target, type: \"touchcancel\", listener: touchEndEvent, options: { passive: true } }\n ];\n this.addTemporaryEvents(events);\n if (params.dragStartPixels === 0) {\n this.onCommonMove(touch, this.touchStart, params.eElement);\n }\n }\n // gets called whenever mouse down on any drag source\n onMouseDown(params, mouseEvent) {\n const e = mouseEvent;\n if (params.skipMouseEvent && params.skipMouseEvent(mouseEvent)) {\n return;\n }\n if (e._alreadyProcessedByDragService) {\n return;\n }\n e._alreadyProcessedByDragService = true;\n if (mouseEvent.button !== 0) {\n return;\n }\n if (this.shouldPreventMouseEvent(mouseEvent)) {\n mouseEvent.preventDefault();\n }\n this.currentDragParams = params;\n this.dragging = false;\n this.mouseStartEvent = mouseEvent;\n this.startTarget = mouseEvent.target;\n const mouseMoveEvent = (event) => this.onMouseMove(event, params.eElement);\n const mouseUpEvent = (event) => this.onMouseUp(event, params.eElement);\n const contextEvent = (event) => event.preventDefault();\n const keydownEvent = (event) => {\n if (event.key === KeyCode.ESCAPE) {\n this.cancelDrag(params.eElement);\n }\n };\n const target = _getRootNode(this.beans);\n const events = [\n { target, type: \"mousemove\", listener: mouseMoveEvent },\n { target, type: \"mouseup\", listener: mouseUpEvent },\n { target, type: \"contextmenu\", listener: contextEvent },\n { target, type: \"keydown\", listener: keydownEvent }\n ];\n this.addTemporaryEvents(events);\n if (params.dragStartPixels === 0) {\n this.onMouseMove(mouseEvent, params.eElement);\n }\n }\n addTemporaryEvents(events) {\n events.forEach((currentEvent) => {\n const { target, type, listener, options } = currentEvent;\n target.addEventListener(type, listener, options);\n });\n this.dragEndFunctions.push(() => {\n events.forEach((currentEvent) => {\n const { target, type, listener, options } = currentEvent;\n target.removeEventListener(type, listener, options);\n });\n });\n }\n // returns true if the event is close to the original event by X pixels either vertically or horizontally.\n // we only start dragging after X pixels so this allows us to know if we should start dragging yet.\n isEventNearStartEvent(currentEvent, startEvent) {\n const { dragStartPixels } = this.currentDragParams;\n const requiredPixelDiff = _exists(dragStartPixels) ? dragStartPixels : 4;\n return _areEventsNear(currentEvent, startEvent, requiredPixelDiff);\n }\n getFirstActiveTouch(touchList) {\n for (let i = 0; i < touchList.length; i++) {\n if (touchList[i].identifier === this.touchStart.identifier) {\n return touchList[i];\n }\n }\n return null;\n }\n onCommonMove(currentEvent, startEvent, el) {\n if (!this.dragging) {\n if (this.isEventNearStartEvent(currentEvent, startEvent)) {\n return;\n }\n this.dragging = true;\n this.eventSvc.dispatchEvent({\n type: \"dragStarted\",\n target: el\n });\n this.currentDragParams.onDragStart(startEvent);\n if (!this.currentDragParams) {\n this.dragging = false;\n return;\n }\n this.currentDragParams.onDragging(startEvent);\n }\n this.currentDragParams?.onDragging(currentEvent);\n }\n onTouchMove(touchEvent, el) {\n const touch = this.getFirstActiveTouch(touchEvent.touches);\n if (!touch) {\n return;\n }\n this.onCommonMove(touch, this.touchStart, el);\n }\n // only gets called after a mouse down - as this is only added after mouseDown\n // and is removed when mouseUp happens\n onMouseMove(mouseEvent, el) {\n if (_isBrowserSafari()) {\n const eDocument = _getDocument(this.beans);\n eDocument.getSelection()?.removeAllRanges();\n }\n if (this.shouldPreventMouseEvent(mouseEvent)) {\n mouseEvent.preventDefault();\n }\n this.onCommonMove(mouseEvent, this.mouseStartEvent, el);\n }\n shouldPreventMouseEvent(mouseEvent) {\n const { gos } = this;\n const isEnableCellTextSelect = gos.get(\"enableCellTextSelection\");\n const isMouseMove = mouseEvent.type === \"mousemove\";\n const isOverFormFieldElement = (mouseEvent2) => {\n const el = mouseEvent2.target;\n const tagName = el?.tagName.toLocaleLowerCase();\n return !!tagName?.match(\"^a$|textarea|input|select|button\");\n };\n return (\n // when `isEnableCellTextSelect` is `true`, we need to preventDefault on mouseMove\n // to avoid the grid text being selected while dragging components.\n isEnableCellTextSelect && isMouseMove && mouseEvent.cancelable && _isEventFromThisGrid(gos, mouseEvent) && !isOverFormFieldElement(mouseEvent)\n );\n }\n onTouchUp(touchEvent, el) {\n let touch = this.getFirstActiveTouch(touchEvent.changedTouches);\n if (!touch) {\n touch = this.touchLastTime;\n }\n this.onUpCommon(touch, el);\n }\n onMouseUp(mouseEvent, el) {\n this.onUpCommon(mouseEvent, el);\n }\n onUpCommon(eventOrTouch, el) {\n if (this.dragging) {\n this.dragging = false;\n this.currentDragParams.onDragStop(eventOrTouch);\n this.eventSvc.dispatchEvent({\n type: \"dragStopped\",\n target: el\n });\n }\n this.resetDragProperties();\n }\n cancelDrag(el) {\n this.eventSvc.dispatchEvent({\n type: \"dragCancelled\",\n target: el\n });\n this.currentDragParams?.onDragCancel?.();\n this.resetDragProperties();\n }\n resetDragProperties() {\n this.mouseStartEvent = null;\n this.startTarget = null;\n this.touchStart = null;\n this.touchLastTime = null;\n this.currentDragParams = null;\n const { dragEndFunctions } = this;\n dragEndFunctions.forEach((func) => func());\n dragEndFunctions.length = 0;\n }\n};\n\n// packages/ag-grid-community/src/entities/agColumnGroup.ts\nfunction createUniqueColumnGroupId(groupId, instanceId) {\n return groupId + \"_\" + instanceId;\n}\nfunction isColumnGroup2(col) {\n return col instanceof AgColumnGroup;\n}\nvar AgColumnGroup = class extends BeanStub {\n constructor(providedColumnGroup, groupId, partId, pinned) {\n super();\n this.providedColumnGroup = providedColumnGroup;\n this.groupId = groupId;\n this.partId = partId;\n this.pinned = pinned;\n this.isColumn = false;\n // depends on the open/closed state of the group, only displaying columns are stored here\n this.displayedChildren = [];\n // The measured height of this column's header when autoHeaderHeight is enabled\n this.autoHeaderHeight = null;\n this.parent = null;\n }\n // as the user is adding and removing columns, the groups are recalculated.\n // this reset clears out all children, ready for children to be added again\n reset() {\n this.parent = null;\n this.children = null;\n this.displayedChildren = null;\n }\n getParent() {\n return this.parent;\n }\n getUniqueId() {\n return createUniqueColumnGroupId(this.groupId, this.partId);\n }\n isEmptyGroup() {\n return this.displayedChildren.length === 0;\n }\n isMoving() {\n const allLeafColumns = this.getProvidedColumnGroup().getLeafColumns();\n if (!allLeafColumns || allLeafColumns.length === 0) {\n return false;\n }\n return allLeafColumns.every((col) => col.isMoving());\n }\n checkLeft() {\n this.displayedChildren.forEach((child) => {\n if (isColumnGroup2(child)) {\n child.checkLeft();\n }\n });\n if (this.displayedChildren.length > 0) {\n if (this.gos.get(\"enableRtl\")) {\n const lastChild = _last(this.displayedChildren);\n const lastChildLeft = lastChild.getLeft();\n this.setLeft(lastChildLeft);\n } else {\n const firstChildLeft = this.displayedChildren[0].getLeft();\n this.setLeft(firstChildLeft);\n }\n } else {\n this.setLeft(null);\n }\n }\n getLeft() {\n return this.left;\n }\n getOldLeft() {\n return this.oldLeft;\n }\n setLeft(left) {\n this.oldLeft = this.left;\n if (this.left !== left) {\n this.left = left;\n this.dispatchLocalEvent({ type: \"leftChanged\" });\n }\n }\n getPinned() {\n return this.pinned;\n }\n getGroupId() {\n return this.groupId;\n }\n getPartId() {\n return this.partId;\n }\n getActualWidth() {\n let groupActualWidth = 0;\n this.displayedChildren?.forEach((child) => {\n groupActualWidth += child.getActualWidth();\n });\n return groupActualWidth;\n }\n isResizable() {\n if (!this.displayedChildren) {\n return false;\n }\n let result = false;\n this.displayedChildren.forEach((child) => {\n if (child.isResizable()) {\n result = true;\n }\n });\n return result;\n }\n getMinWidth() {\n let result = 0;\n this.displayedChildren.forEach((groupChild) => {\n result += groupChild.getMinWidth();\n });\n return result;\n }\n addChild(child) {\n if (!this.children) {\n this.children = [];\n }\n this.children.push(child);\n }\n getDisplayedChildren() {\n return this.displayedChildren;\n }\n getLeafColumns() {\n const result = [];\n this.addLeafColumns(result);\n return result;\n }\n getDisplayedLeafColumns() {\n const result = [];\n this.addDisplayedLeafColumns(result);\n return result;\n }\n getDefinition() {\n return this.providedColumnGroup.getColGroupDef();\n }\n getColGroupDef() {\n return this.providedColumnGroup.getColGroupDef();\n }\n isPadding() {\n return this.providedColumnGroup.isPadding();\n }\n isExpandable() {\n return this.providedColumnGroup.isExpandable();\n }\n isExpanded() {\n return this.providedColumnGroup.isExpanded();\n }\n setExpanded(expanded) {\n this.providedColumnGroup.setExpanded(expanded);\n }\n isAutoHeaderHeight() {\n return !!this.getColGroupDef()?.autoHeaderHeight;\n }\n getAutoHeaderHeight() {\n return this.autoHeaderHeight;\n }\n /** Returns true if the header height has changed */\n setAutoHeaderHeight(height) {\n const changed = height !== this.autoHeaderHeight;\n this.autoHeaderHeight = height;\n return changed;\n }\n addDisplayedLeafColumns(leafColumns) {\n this.displayedChildren.forEach((child) => {\n if (isColumn(child)) {\n leafColumns.push(child);\n } else if (isColumnGroup2(child)) {\n child.addDisplayedLeafColumns(leafColumns);\n }\n });\n }\n addLeafColumns(leafColumns) {\n this.children.forEach((child) => {\n if (isColumn(child)) {\n leafColumns.push(child);\n } else if (isColumnGroup2(child)) {\n child.addLeafColumns(leafColumns);\n }\n });\n }\n getChildren() {\n return this.children;\n }\n getColumnGroupShow() {\n return this.providedColumnGroup.getColumnGroupShow();\n }\n getProvidedColumnGroup() {\n return this.providedColumnGroup;\n }\n getPaddingLevel() {\n const parent = this.getParent();\n if (!this.isPadding() || !parent || !parent.isPadding()) {\n return 0;\n }\n return 1 + parent.getPaddingLevel();\n }\n calculateDisplayedColumns() {\n this.displayedChildren = [];\n let parentWithExpansion = this;\n while (parentWithExpansion != null && parentWithExpansion.isPadding()) {\n parentWithExpansion = parentWithExpansion.getParent();\n }\n const isExpandable = parentWithExpansion ? parentWithExpansion.getProvidedColumnGroup().isExpandable() : false;\n if (!isExpandable) {\n this.displayedChildren = this.children;\n this.dispatchLocalEvent({ type: \"displayedChildrenChanged\" });\n return;\n }\n this.children.forEach((child) => {\n const emptyGroup = isColumnGroup2(child) && (!child.displayedChildren || !child.displayedChildren.length);\n if (emptyGroup) {\n return;\n }\n const headerGroupShow = child.getColumnGroupShow();\n switch (headerGroupShow) {\n case \"open\":\n if (parentWithExpansion.getProvidedColumnGroup().isExpanded()) {\n this.displayedChildren.push(child);\n }\n break;\n case \"closed\":\n if (!parentWithExpansion.getProvidedColumnGroup().isExpanded()) {\n this.displayedChildren.push(child);\n }\n break;\n default:\n this.displayedChildren.push(child);\n break;\n }\n });\n this.dispatchLocalEvent({ type: \"displayedChildrenChanged\" });\n }\n};\n\n// packages/ag-grid-community/src/entities/rowNode.ts\nvar ROW_ID_PREFIX_ROW_GROUP = \"row-group-\";\nvar ROW_ID_PREFIX_TOP_PINNED = \"t-\";\nvar ROW_ID_PREFIX_BOTTOM_PINNED = \"b-\";\nvar OBJECT_ID_SEQUENCE = 0;\nvar RowNode = class {\n constructor(beans) {\n /** `true` if this row is a master row, part of master / detail (ie row can be expanded to show detail) */\n this.master = false;\n /** `true` if this row is a detail row, part of master / detail (ie child row of an expanded master row)*/\n this.detail = void 0;\n /** The current row index. If the row is filtered out or in a collapsed group, this value will be `null`. */\n this.rowIndex = null;\n /** The key for the group eg Ireland, UK, USA */\n this.key = null;\n /**\n * The index of the row in the source rowData array including any updates via transactions.\n * It does not change when sorting, filtering, grouping, pivoting or any other UI related operations.\n * If this is a filler node (a visual row created by AG Grid in tree data or grouping) the value will be `-1`.\n *\n * Generally readonly. It is modified only by:\n * - ClientSideNodeManager, cast to ClientSideNodeManagerRowNode\n * - ClientSideRowModel, cast to ClientSideRowModelRowNode\n */\n this.sourceRowIndex = -1;\n /**\n * Children mapped by the pivot columns.\n *\n * TODO: this field is currently used only by the GroupStrategy and Pivot.\n * TreeStrategy does not use it, and pivot cannot be enabled with tree data.\n * Creating a new object for every row when not pivoting and not grouping\n * consumes memory unnecessarily. Setting it to null however currently breaks\n * transactional updates in groups so this requires a deeper investigation on GroupStrategy.\n */\n this.childrenMapped = {};\n /** The TreeNode associated to this row. Used only with tree data. */\n this.treeNode = null;\n /** The flags associated to this node. Used only with tree data. */\n this.treeNodeFlags = 0;\n /**\n * This will be `true` if it has a rowIndex assigned, otherwise `false`.\n */\n this.displayed = false;\n /** The row top position in pixels. */\n this.rowTop = null;\n /** The top pixel for this row last time, makes sense if data set was ordered or filtered,\n * it is used so new rows can animate in from their old position. */\n this.oldRowTop = null;\n /** `true` by default - can be overridden via gridOptions.isRowSelectable(rowNode) */\n this.selectable = true;\n /**\n * Used by sorting service - to give deterministic sort to groups. Previously we\n * just id for this, however id is a string and had slower sorting compared to numbers.\n * If re-naming this property, you must also update `IGNORED_SIBLING_PROPERTIES`\n */\n this.__objectId = OBJECT_ID_SEQUENCE++;\n /** `true` when nodes with the same id are being removed and added as part of the same batch transaction */\n this.alreadyRendered = false;\n this.highlighted = null;\n this.hovered = false;\n this.__selected = false;\n this.beans = beans;\n }\n /**\n * Replaces the data on the `rowNode`. When this method is called, the grid will refresh the entire rendered row if it is displayed.\n */\n setData(data) {\n this.setDataCommon(data, false);\n }\n // similar to setRowData, however it is expected that the data is the same data item. this\n // is intended to be used with Redux type stores, where the whole data can be changed. we are\n // guaranteed that the data is the same entity (so grid doesn't need to worry about the id of the\n // underlying data changing, hence doesn't need to worry about selection). the grid, upon receiving\n // dataChanged event, will refresh the cells rather than rip them all out (so user can show transitions).\n /**\n * Updates the data on the `rowNode`. When this method is called, the grid will refresh the entire rendered row if it is displayed.\n */\n updateData(data) {\n this.setDataCommon(data, true);\n }\n setDataCommon(data, update) {\n const { valueCache, selectionSvc, rowSpanSvc } = this.beans;\n const oldData = this.data;\n this.data = data;\n valueCache?.onDataChanged();\n this.updateDataOnDetailNode();\n selectionSvc?.updateRowSelectable(this);\n this.resetQuickFilterAggregateText();\n const event = this.createDataChangedEvent(data, oldData, update);\n this.__localEventService?.dispatchEvent(event);\n rowSpanSvc?.onRowDataUpdated(this);\n }\n // when we are doing master / detail, the detail node is lazy created, but then kept around.\n // so if we show / hide the detail, the same detail rowNode is used. so we need to keep the data\n // in sync, otherwise expand/collapse of the detail would still show the old values.\n updateDataOnDetailNode() {\n if (this.detailNode) {\n this.detailNode.data = this.data;\n }\n }\n createDataChangedEvent(newData, oldData, update) {\n return {\n type: \"dataChanged\",\n node: this,\n oldData,\n newData,\n update\n };\n }\n getRowIndexString() {\n if (this.rowIndex == null) {\n _error(13);\n return null;\n }\n if (this.rowPinned === \"top\") {\n return ROW_ID_PREFIX_TOP_PINNED + this.rowIndex;\n }\n if (this.rowPinned === \"bottom\") {\n return ROW_ID_PREFIX_BOTTOM_PINNED + this.rowIndex;\n }\n return this.rowIndex.toString();\n }\n setDataAndId(data, id) {\n const { selectionSvc } = this.beans;\n const oldNode = selectionSvc?.createDaemonNode?.(this);\n const oldData = this.data;\n this.data = data;\n this.updateDataOnDetailNode();\n this.setId(id);\n if (selectionSvc) {\n selectionSvc.updateRowSelectable(this);\n selectionSvc.syncInRowNode(this, oldNode);\n }\n const event = this.createDataChangedEvent(data, oldData, false);\n this.__localEventService?.dispatchEvent(event);\n }\n setId(id) {\n const getRowIdFunc = _getRowIdCallback(this.beans.gos);\n if (getRowIdFunc) {\n if (this.data) {\n const parentKeys = this.parent?.getRoute() ?? [];\n this.id = getRowIdFunc({\n data: this.data,\n parentKeys: parentKeys.length > 0 ? parentKeys : void 0,\n level: this.level,\n rowPinned: this.rowPinned\n });\n if (this.id.startsWith(ROW_ID_PREFIX_ROW_GROUP)) {\n _error(14, {\n groupPrefix: ROW_ID_PREFIX_ROW_GROUP\n });\n }\n } else {\n this.id = void 0;\n }\n } else {\n this.id = id;\n }\n }\n setRowTop(rowTop) {\n this.oldRowTop = this.rowTop;\n if (this.rowTop === rowTop) {\n return;\n }\n this.rowTop = rowTop;\n this.dispatchRowEvent(\"topChanged\");\n this.setDisplayed(rowTop !== null);\n }\n clearRowTopAndRowIndex() {\n this.oldRowTop = null;\n this.setRowTop(null);\n this.setRowIndex(null);\n }\n setHovered(hovered) {\n this.hovered = hovered;\n }\n isHovered() {\n return this.hovered;\n }\n /**\n * Sets the row height.\n * Call if you want to change the height initially assigned to the row.\n * After calling, you must call `api.onRowHeightChanged()` so the grid knows it needs to work out the placement of the rows. */\n setRowHeight(rowHeight, estimated = false) {\n this.rowHeight = rowHeight;\n this.rowHeightEstimated = estimated;\n this.dispatchRowEvent(\"heightChanged\");\n }\n setExpanded(expanded, e, forceSync) {\n this.beans.expansionSvc?.setExpanded(this, expanded, e, forceSync);\n }\n /**\n * Replaces the value on the `rowNode` for the specified column. When complete,\n * the grid will refresh the rendered cell on the required row only.\n * **Note**: This method only fires `onCellEditRequest` when the Grid is in **Read Only** mode.\n *\n * @param colKey The column where the value should be updated\n * @param newValue The new value\n * @param eventSource The source of the event\n * @returns `true` if the value was changed, otherwise `false`.\n */\n setDataValue(colKey, newValue, eventSource) {\n const { colModel, valueSvc, gos, selectionSvc, rowSpanSvc } = this.beans;\n const column = typeof colKey !== \"string\" ? colKey : colModel.getCol(colKey) ?? colModel.getColDefCol(colKey);\n if (!column) {\n return false;\n }\n const oldValue = valueSvc.getValueForDisplay(column, this);\n if (gos.get(\"readOnlyEdit\")) {\n const {\n beans: { eventSvc },\n data,\n rowIndex,\n rowPinned\n } = this;\n eventSvc.dispatchEvent({\n type: \"cellEditRequest\",\n event: null,\n rowIndex,\n rowPinned,\n column,\n colDef: column.colDef,\n data,\n node: this,\n oldValue,\n newValue,\n value: newValue,\n source: eventSource\n });\n return false;\n }\n const valueChanged = valueSvc.setValue(this, column, newValue, eventSource);\n this.dispatchCellChangedEvent(column, newValue, oldValue);\n selectionSvc?.updateRowSelectable(this);\n rowSpanSvc?.onRowDataUpdated(this);\n return valueChanged;\n }\n updateHasChildren() {\n let newValue = this.group && !this.footer || this.childrenAfterGroup && this.childrenAfterGroup.length > 0;\n const { rowChildrenSvc } = this.beans;\n if (rowChildrenSvc) {\n newValue = rowChildrenSvc.getHasChildrenValue(this);\n }\n if (newValue !== this.__hasChildren) {\n this.__hasChildren = !!newValue;\n this.dispatchRowEvent(\"hasChildrenChanged\");\n }\n }\n hasChildren() {\n if (this.__hasChildren == null) {\n this.updateHasChildren();\n }\n return this.__hasChildren;\n }\n dispatchCellChangedEvent(column, newValue, oldValue) {\n const cellChangedEvent = {\n type: \"cellChanged\",\n node: this,\n column,\n newValue,\n oldValue\n };\n this.__localEventService?.dispatchEvent(cellChangedEvent);\n }\n /**\n * The first time `quickFilter` runs, the grid creates a one-off string representation of the row.\n * This string is then used for the quick filter instead of hitting each column separately.\n * When you edit, using grid editing, this string gets cleared down.\n * However if you edit without using grid editing, you will need to clear this string down for the row to be updated with the new values.\n * Otherwise new values will not work with the `quickFilter`. */\n resetQuickFilterAggregateText() {\n this.quickFilterAggregateText = null;\n }\n /** Returns:\n * - `true` if the node can be expanded, i.e it is a group or master row.\n * - `false` if the node cannot be expanded\n */\n isExpandable() {\n return this.beans.expansionSvc?.isExpandable(this) ?? false;\n }\n /** Returns:\n * - `true` if node is selected,\n * - `false` if the node isn't selected\n * - `undefined` if it's partially selected (group where not all children are selected). */\n isSelected() {\n if (this.footer) {\n return this.sibling.isSelected();\n }\n return this.__selected;\n }\n /** Perform a depth-first search of this node and its children. */\n depthFirstSearch(callback) {\n this.childrenAfterGroup?.forEach((child) => child.depthFirstSearch(callback));\n callback(this);\n }\n dispatchRowEvent(type) {\n this.__localEventService?.dispatchEvent({\n type,\n node: this\n });\n }\n /**\n * Select (or deselect) the node.\n * @param newValue -`true` for selection, `false` for deselection.\n * @param clearSelection - If selecting, then passing `true` will select the node exclusively (i.e. NOT do multi select). If doing deselection, `clearSelection` has no impact.\n * @param source - Source property that will appear in the `selectionChanged` event.\n */\n setSelected(newValue, clearSelection = false, source = \"api\") {\n this.beans.selectionSvc?.setNodesSelected({\n nodes: [this],\n newValue,\n clearSelection,\n source\n });\n }\n /**\n * Returns:\n * - `true` if node is either pinned to the `top` or `bottom`\n * - `false` if the node isn't pinned\n */\n isRowPinned() {\n return !!this.rowPinned;\n }\n __addEventListener(eventType, listener) {\n if (!this.__localEventService) {\n this.__localEventService = new LocalEventService();\n }\n this.__localEventService.addEventListener(eventType, listener);\n }\n __removeEventListener(eventType, listener) {\n this.removeLocalListener(eventType, listener);\n }\n /**\n * PUBLIC USE ONLY: for internal use within AG Grid use the `__addEventListener` and `__removeEventListener` methods.\n */\n addEventListener(eventType, userListener) {\n this.beans.validation?.checkRowEvents(eventType);\n if (!this.__localEventService) {\n this.__localEventService = new LocalEventService();\n }\n this.frameworkEventListenerService = this.beans.frameworkOverrides.createLocalEventListenerWrapper?.(\n this.frameworkEventListenerService,\n this.__localEventService\n );\n const listener = this.frameworkEventListenerService?.wrap(userListener) ?? userListener;\n this.__localEventService.addEventListener(eventType, listener);\n }\n /**\n * PUBLIC USE ONLY: for internal use within AG Grid use the `__addEventListener` and `__removeEventListener` methods.\n */\n removeEventListener(eventType, userListener) {\n const listener = this.frameworkEventListenerService?.unwrap(userListener) ?? userListener;\n this.removeLocalListener(eventType, listener);\n }\n removeLocalListener(eventType, listener) {\n this.__localEventService?.removeEventListener(eventType, listener);\n if (this.__localEventService?.noRegisteredListenersExist()) {\n this.__localEventService = null;\n }\n }\n /**\n * @deprecated v32.2.0 Check `node.detail` then user provided callback `isFullWidthRow` instead.\n *\n * Returns:\n * - `true` if the node is a full width cell\n * - `false` if the node is not a full width cell\n */\n isFullWidthCell() {\n _warn(61);\n if (this.detail) {\n return true;\n }\n const isFullWidthCellFunc = this.beans.gos.getCallback(\"isFullWidthRow\");\n return isFullWidthCellFunc ? isFullWidthCellFunc({ rowNode: this }) : false;\n }\n /**\n * Returns the route of keys to the row node. Returns undefined if the node has no key.\n */\n getRoute() {\n if (this.level === -1) {\n return [];\n }\n if (this.key == null) {\n return void 0;\n }\n const res = [];\n let pointer = this;\n while (pointer && pointer.key != null) {\n res.push(pointer.key);\n pointer = pointer.parent;\n }\n return res.reverse();\n }\n setFirstChild(firstChild) {\n if (this.firstChild !== firstChild) {\n this.firstChild = firstChild;\n this.dispatchRowEvent(\"firstChildChanged\");\n }\n }\n setDisplayed(displayed) {\n if (this.displayed !== displayed) {\n this.displayed = displayed;\n this.dispatchRowEvent(\"displayedChanged\");\n }\n }\n setRowIndex(rowIndex) {\n if (this.rowIndex !== rowIndex) {\n this.rowIndex = rowIndex;\n this.dispatchRowEvent(\"rowIndexChanged\");\n }\n }\n setAllChildrenCount(allChildrenCount) {\n if (this.allChildrenCount !== allChildrenCount) {\n this.allChildrenCount = allChildrenCount;\n this.dispatchRowEvent(\"allChildrenCountChanged\");\n }\n }\n setUiLevel(uiLevel) {\n if (this.uiLevel !== uiLevel) {\n this.uiLevel = uiLevel;\n this.dispatchRowEvent(\"uiLevelChanged\");\n }\n }\n};\n\n// packages/ag-grid-community/src/entities/rowNodeUtils.ts\nfunction _createGlobalRowEvent(rowNode, gos, type) {\n return _addGridCommonParams(gos, {\n type,\n node: rowNode,\n data: rowNode.data,\n rowIndex: rowNode.rowIndex,\n rowPinned: rowNode.rowPinned\n });\n}\n\n// packages/ag-grid-community/src/filter/filterWrapperComp.ts\nvar FilterWrapperComp = class extends Component {\n constructor(column, source) {\n super(\n /* html */\n ``\n );\n this.column = column;\n this.source = source;\n this.filterWrapper = null;\n }\n postConstruct() {\n this.createFilter(true);\n this.addManagedEventListeners({ filterDestroyed: this.onFilterDestroyed.bind(this) });\n }\n hasFilter() {\n return !!this.filterWrapper;\n }\n getFilter() {\n return this.filterWrapper?.filterPromise ?? null;\n }\n afterInit() {\n return this.filterWrapper?.filterPromise?.then(() => {\n }) ?? AgPromise.resolve();\n }\n afterGuiAttached(params) {\n this.filterWrapper?.filterPromise?.then((filter) => {\n filter?.afterGuiAttached?.(params);\n });\n }\n afterGuiDetached() {\n this.filterWrapper?.filterPromise?.then((filter) => {\n filter?.afterGuiDetached?.();\n });\n }\n createFilter(init) {\n const { column, source } = this;\n this.filterWrapper = this.beans.filterManager?.getOrCreateFilterWrapper(column) ?? null;\n if (!this.filterWrapper?.filterPromise) {\n return;\n }\n this.filterWrapper.filterPromise.then((filter) => {\n const guiFromFilter = filter.getGui();\n if (!_exists(guiFromFilter)) {\n _warn(69, { guiFromFilter });\n }\n this.appendChild(guiFromFilter);\n if (init) {\n this.eventSvc.dispatchEvent({\n type: \"filterOpened\",\n column,\n source,\n eGui: this.getGui()\n });\n }\n });\n }\n onFilterDestroyed(event) {\n if ((event.source === \"api\" || event.source === \"paramsUpdated\") && event.column.getId() === this.column.getId() && this.beans.colModel.getColDefCol(this.column)) {\n _clearElement(this.getGui());\n this.createFilter();\n }\n }\n destroy() {\n this.filterWrapper = null;\n super.destroy();\n }\n};\n\n// packages/ag-grid-community/src/rendering/features/positionableFeature.ts\nvar RESIZE_CONTAINER_STYLE = \"ag-resizer-wrapper\";\nvar makeDiv = (dataRefPrefix, classSuffix) => ``;\nvar RESIZE_TEMPLATE = (\n /* html */\n `\n ${makeDiv(\"eTopLeft\", \"topLeft\")}\n ${makeDiv(\"eTop\", \"top\")}\n ${makeDiv(\"eTopRight\", \"topRight\")}\n ${makeDiv(\"eRight\", \"right\")}\n ${makeDiv(\"eBottomRight\", \"bottomRight\")}\n ${makeDiv(\"eBottom\", \"bottom\")}\n ${makeDiv(\"eBottomLeft\", \"bottomLeft\")}\n ${makeDiv(\"eLeft\", \"left\")}\n
`\n);\nvar PositionableFeature = class extends BeanStub {\n constructor(element, config) {\n super();\n this.element = element;\n this.dragStartPosition = {\n x: 0,\n y: 0\n };\n this.position = {\n x: 0,\n y: 0\n };\n this.lastSize = {\n width: -1,\n height: -1\n };\n this.positioned = false;\n this.resizersAdded = false;\n this.resizeListeners = [];\n this.boundaryEl = null;\n this.isResizing = false;\n this.isMoving = false;\n this.resizable = {};\n this.movable = false;\n this.currentResizer = null;\n this.config = Object.assign({}, { popup: false }, config);\n }\n wireBeans(beans) {\n this.popupSvc = beans.popupSvc;\n this.dragSvc = beans.dragSvc;\n }\n center() {\n const { clientHeight, clientWidth } = this.offsetParent;\n const x = clientWidth / 2 - this.getWidth() / 2;\n const y = clientHeight / 2 - this.getHeight() / 2;\n this.offsetElement(x, y);\n }\n initialisePosition() {\n if (this.positioned) {\n return;\n }\n const { centered, forcePopupParentAsOffsetParent, minWidth, width, minHeight, height, x, y } = this.config;\n if (!this.offsetParent) {\n this.setOffsetParent();\n }\n let computedMinHeight = 0;\n let computedMinWidth = 0;\n const isElementVisible = _isVisible(this.element);\n if (isElementVisible) {\n const boundaryEl = this.findBoundaryElement();\n const offsetParentComputedStyles = window.getComputedStyle(boundaryEl);\n if (offsetParentComputedStyles.minWidth != null) {\n const paddingWidth = boundaryEl.offsetWidth - this.element.offsetWidth;\n computedMinWidth = parseInt(offsetParentComputedStyles.minWidth, 10) - paddingWidth;\n }\n if (offsetParentComputedStyles.minHeight != null) {\n const paddingHeight = boundaryEl.offsetHeight - this.element.offsetHeight;\n computedMinHeight = parseInt(offsetParentComputedStyles.minHeight, 10) - paddingHeight;\n }\n }\n this.minHeight = minHeight || computedMinHeight;\n this.minWidth = minWidth || computedMinWidth;\n if (width) {\n this.setWidth(width);\n }\n if (height) {\n this.setHeight(height);\n }\n if (!width || !height) {\n this.refreshSize();\n }\n if (centered) {\n this.center();\n } else if (x || y) {\n this.offsetElement(x, y);\n } else if (isElementVisible && forcePopupParentAsOffsetParent) {\n let boundaryEl = this.boundaryEl;\n let initialisedDuringPositioning = true;\n if (!boundaryEl) {\n boundaryEl = this.findBoundaryElement();\n initialisedDuringPositioning = false;\n }\n if (boundaryEl) {\n const top = parseFloat(boundaryEl.style.top);\n const left = parseFloat(boundaryEl.style.left);\n if (initialisedDuringPositioning) {\n this.offsetElement(isNaN(left) ? 0 : left, isNaN(top) ? 0 : top);\n } else {\n this.setPosition(left, top);\n }\n }\n }\n this.positioned = !!this.offsetParent;\n }\n isPositioned() {\n return this.positioned;\n }\n getPosition() {\n return this.position;\n }\n setMovable(movable, moveElement) {\n if (!this.config.popup || movable === this.movable) {\n return;\n }\n this.movable = movable;\n const params = this.moveElementDragListener || {\n eElement: moveElement,\n onDragStart: this.onMoveStart.bind(this),\n onDragging: this.onMove.bind(this),\n onDragStop: this.onMoveEnd.bind(this)\n };\n if (movable) {\n this.dragSvc?.addDragSource(params);\n this.moveElementDragListener = params;\n } else {\n this.dragSvc?.removeDragSource(params);\n this.moveElementDragListener = void 0;\n }\n }\n setResizable(resizable) {\n this.clearResizeListeners();\n if (resizable) {\n this.addResizers();\n } else {\n this.removeResizers();\n }\n if (typeof resizable === \"boolean\") {\n if (resizable === false) {\n return;\n }\n resizable = {\n topLeft: resizable,\n top: resizable,\n topRight: resizable,\n right: resizable,\n bottomRight: resizable,\n bottom: resizable,\n bottomLeft: resizable,\n left: resizable\n };\n }\n Object.keys(resizable).forEach((side) => {\n const resizableStructure = resizable;\n const isSideResizable = !!resizableStructure[side];\n const resizerEl = this.getResizerElement(side);\n const params = {\n dragStartPixels: 0,\n eElement: resizerEl,\n onDragStart: (e) => this.onResizeStart(e, side),\n onDragging: this.onResize.bind(this),\n onDragStop: (e) => this.onResizeEnd(e, side)\n };\n if (isSideResizable || !this.isAlive() && !isSideResizable) {\n if (isSideResizable) {\n this.dragSvc?.addDragSource(params);\n this.resizeListeners.push(params);\n resizerEl.style.pointerEvents = \"all\";\n } else {\n resizerEl.style.pointerEvents = \"none\";\n }\n this.resizable[side] = isSideResizable;\n }\n });\n }\n removeSizeFromEl() {\n this.element.style.removeProperty(\"height\");\n this.element.style.removeProperty(\"width\");\n this.element.style.removeProperty(\"flex\");\n }\n restoreLastSize() {\n this.element.style.flex = \"0 0 auto\";\n const { height, width } = this.lastSize;\n if (width !== -1) {\n this.element.style.width = `${width}px`;\n }\n if (height !== -1) {\n this.element.style.height = `${height}px`;\n }\n }\n getHeight() {\n return this.element.offsetHeight;\n }\n setHeight(height) {\n const { popup } = this.config;\n const eGui = this.element;\n let isPercent = false;\n if (typeof height === \"string\" && height.indexOf(\"%\") !== -1) {\n _setFixedHeight(eGui, height);\n height = _getAbsoluteHeight(eGui);\n isPercent = true;\n } else {\n height = Math.max(this.minHeight, height);\n if (this.positioned) {\n const availableHeight = this.getAvailableHeight();\n if (availableHeight && height > availableHeight) {\n height = availableHeight;\n }\n }\n }\n if (this.getHeight() === height) {\n return;\n }\n if (!isPercent) {\n if (popup) {\n _setFixedHeight(eGui, height);\n } else {\n eGui.style.height = `${height}px`;\n eGui.style.flex = \"0 0 auto\";\n this.lastSize.height = typeof height === \"number\" ? height : parseFloat(height);\n }\n } else {\n eGui.style.maxHeight = \"unset\";\n eGui.style.minHeight = \"unset\";\n }\n }\n getAvailableHeight() {\n const { popup, forcePopupParentAsOffsetParent } = this.config;\n if (!this.positioned) {\n this.initialisePosition();\n }\n const { clientHeight } = this.offsetParent;\n if (!clientHeight) {\n return null;\n }\n const elRect = this.element.getBoundingClientRect();\n const offsetParentRect = this.offsetParent.getBoundingClientRect();\n const yPosition = popup ? this.position.y : elRect.top;\n const parentTop = popup ? 0 : offsetParentRect.top;\n let additionalHeight = 0;\n if (forcePopupParentAsOffsetParent) {\n const parentEl = this.element.parentElement;\n if (parentEl) {\n const { bottom } = parentEl.getBoundingClientRect();\n additionalHeight = bottom - elRect.bottom;\n }\n }\n const availableHeight = clientHeight + parentTop - yPosition - additionalHeight;\n return availableHeight;\n }\n getWidth() {\n return this.element.offsetWidth;\n }\n setWidth(width) {\n const eGui = this.element;\n const { popup } = this.config;\n let isPercent = false;\n if (typeof width === \"string\" && width.indexOf(\"%\") !== -1) {\n _setFixedWidth(eGui, width);\n width = _getAbsoluteWidth(eGui);\n isPercent = true;\n } else if (this.positioned) {\n width = Math.max(this.minWidth, width);\n const { clientWidth } = this.offsetParent;\n const xPosition = popup ? this.position.x : this.element.getBoundingClientRect().left;\n if (clientWidth && width + xPosition > clientWidth) {\n width = clientWidth - xPosition;\n }\n }\n if (this.getWidth() === width) {\n return;\n }\n if (!isPercent) {\n if (this.config.popup) {\n _setFixedWidth(eGui, width);\n } else {\n eGui.style.width = `${width}px`;\n eGui.style.flex = \" unset\";\n this.lastSize.width = typeof width === \"number\" ? width : parseFloat(width);\n }\n } else {\n eGui.style.maxWidth = \"unset\";\n eGui.style.minWidth = \"unset\";\n }\n }\n offsetElement(x = 0, y = 0) {\n const { forcePopupParentAsOffsetParent } = this.config;\n const ePopup = forcePopupParentAsOffsetParent ? this.boundaryEl : this.element;\n if (!ePopup) {\n return;\n }\n this.popupSvc?.positionPopup({\n ePopup,\n keepWithinBounds: true,\n skipObserver: this.movable || this.isResizable(),\n updatePosition: () => ({ x, y })\n });\n this.setPosition(parseFloat(ePopup.style.left), parseFloat(ePopup.style.top));\n }\n constrainSizeToAvailableHeight(constrain) {\n if (!this.config.forcePopupParentAsOffsetParent) {\n return;\n }\n const applyMaxHeightToElement = () => {\n const availableHeight = this.getAvailableHeight();\n this.element.style.setProperty(\"max-height\", `${availableHeight}px`);\n };\n if (constrain && this.popupSvc) {\n this.resizeObserverSubscriber = _observeResize(\n this.beans,\n this.popupSvc?.getPopupParent(),\n applyMaxHeightToElement\n );\n } else {\n this.element.style.removeProperty(\"max-height\");\n if (this.resizeObserverSubscriber) {\n this.resizeObserverSubscriber();\n this.resizeObserverSubscriber = void 0;\n }\n }\n }\n setPosition(x, y) {\n this.position.x = x;\n this.position.y = y;\n }\n updateDragStartPosition(x, y) {\n this.dragStartPosition = { x, y };\n }\n calculateMouseMovement(params) {\n const { e, isLeft, isTop, anywhereWithin, topBuffer } = params;\n const xDiff = e.clientX - this.dragStartPosition.x;\n const yDiff = e.clientY - this.dragStartPosition.y;\n const movementX = this.shouldSkipX(e, !!isLeft, !!anywhereWithin, xDiff) ? 0 : xDiff;\n const movementY = this.shouldSkipY(e, !!isTop, topBuffer, yDiff) ? 0 : yDiff;\n return { movementX, movementY };\n }\n shouldSkipX(e, isLeft, anywhereWithin, diff) {\n const elRect = this.element.getBoundingClientRect();\n const parentRect = this.offsetParent.getBoundingClientRect();\n const boundaryElRect = this.boundaryEl.getBoundingClientRect();\n const xPosition = this.config.popup ? this.position.x : elRect.left;\n let skipX = xPosition <= 0 && parentRect.left >= e.clientX || parentRect.right <= e.clientX && parentRect.right <= boundaryElRect.right;\n if (skipX) {\n return true;\n }\n if (isLeft) {\n skipX = // skip if we are moving to the left and the cursor\n // is positioned to the right of the left side anchor\n diff < 0 && e.clientX > xPosition + parentRect.left || // skip if we are moving to the right and the cursor\n // is positioned to the left of the dialog\n diff > 0 && e.clientX < xPosition + parentRect.left;\n } else {\n if (anywhereWithin) {\n skipX = diff < 0 && e.clientX > boundaryElRect.right || diff > 0 && e.clientX < xPosition + parentRect.left;\n } else {\n skipX = // if the movement is bound to the right side of the dialog\n // we skip if we are moving to the left and the cursor\n // is to the right of the dialog\n diff < 0 && e.clientX > boundaryElRect.right || // or skip if we are moving to the right and the cursor\n // is to the left of the right side anchor\n diff > 0 && e.clientX < boundaryElRect.right;\n }\n }\n return skipX;\n }\n shouldSkipY(e, isTop, topBuffer = 0, diff) {\n const elRect = this.element.getBoundingClientRect();\n const parentRect = this.offsetParent.getBoundingClientRect();\n const boundaryElRect = this.boundaryEl.getBoundingClientRect();\n const yPosition = this.config.popup ? this.position.y : elRect.top;\n let skipY = yPosition <= 0 && parentRect.top >= e.clientY || parentRect.bottom <= e.clientY && parentRect.bottom <= boundaryElRect.bottom;\n if (skipY) {\n return true;\n }\n if (isTop) {\n skipY = // skip if we are moving to towards top and the cursor is\n // below the top anchor + topBuffer\n // note: topBuffer is used when moving the dialog using the title bar\n diff < 0 && e.clientY > yPosition + parentRect.top + topBuffer || // skip if we are moving to the bottom and the cursor is\n // above the top anchor\n diff > 0 && e.clientY < yPosition + parentRect.top;\n } else {\n skipY = // skip if we are moving towards the top and the cursor\n // is below the bottom anchor\n diff < 0 && e.clientY > boundaryElRect.bottom || // skip if we are moving towards the bottom and the cursor\n // is above the bottom anchor\n diff > 0 && e.clientY < boundaryElRect.bottom;\n }\n return skipY;\n }\n createResizeMap() {\n const eGui = this.element;\n this.resizerMap = {\n topLeft: { element: eGui.querySelector(\"[data-ref=eTopLeftResizer]\") },\n top: { element: eGui.querySelector(\"[data-ref=eTopResizer]\") },\n topRight: { element: eGui.querySelector(\"[data-ref=eTopRightResizer]\") },\n right: { element: eGui.querySelector(\"[data-ref=eRightResizer]\") },\n bottomRight: { element: eGui.querySelector(\"[data-ref=eBottomRightResizer]\") },\n bottom: { element: eGui.querySelector(\"[data-ref=eBottomResizer]\") },\n bottomLeft: { element: eGui.querySelector(\"[data-ref=eBottomLeftResizer]\") },\n left: { element: eGui.querySelector(\"[data-ref=eLeftResizer]\") }\n };\n }\n addResizers() {\n if (this.resizersAdded) {\n return;\n }\n const eGui = this.element;\n if (!eGui) {\n return;\n }\n const parser = new DOMParser();\n const resizers = parser.parseFromString(RESIZE_TEMPLATE, \"text/html\").body;\n eGui.appendChild(resizers.firstChild);\n this.createResizeMap();\n this.resizersAdded = true;\n }\n removeResizers() {\n this.resizerMap = void 0;\n const resizerEl = this.element.querySelector(`.${RESIZE_CONTAINER_STYLE}`);\n if (resizerEl) {\n this.element.removeChild(resizerEl);\n }\n this.resizersAdded = false;\n }\n getResizerElement(side) {\n return this.resizerMap[side].element;\n }\n onResizeStart(e, side) {\n this.boundaryEl = this.findBoundaryElement();\n if (!this.positioned) {\n this.initialisePosition();\n }\n this.currentResizer = {\n isTop: !!side.match(/top/i),\n isRight: !!side.match(/right/i),\n isBottom: !!side.match(/bottom/i),\n isLeft: !!side.match(/left/i)\n };\n this.element.classList.add(\"ag-resizing\");\n this.resizerMap[side].element.classList.add(\"ag-active\");\n const { popup, forcePopupParentAsOffsetParent } = this.config;\n if (!popup && !forcePopupParentAsOffsetParent) {\n this.applySizeToSiblings(this.currentResizer.isBottom || this.currentResizer.isTop);\n }\n this.isResizing = true;\n this.updateDragStartPosition(e.clientX, e.clientY);\n }\n getSiblings() {\n const element = this.element;\n const parent = element.parentElement;\n if (!parent) {\n return null;\n }\n return Array.prototype.slice.call(parent.children).filter((el) => !el.classList.contains(\"ag-hidden\"));\n }\n getMinSizeOfSiblings() {\n const siblings = this.getSiblings() || [];\n let height = 0;\n let width = 0;\n for (let i = 0; i < siblings.length; i++) {\n const currentEl = siblings[i];\n const isFlex = !!currentEl.style.flex && currentEl.style.flex !== \"0 0 auto\";\n if (currentEl === this.element) {\n continue;\n }\n let nextHeight = this.minHeight || 0;\n let nextWidth = this.minWidth || 0;\n if (isFlex) {\n const computedStyle = window.getComputedStyle(currentEl);\n if (computedStyle.minHeight) {\n nextHeight = parseInt(computedStyle.minHeight, 10);\n }\n if (computedStyle.minWidth) {\n nextWidth = parseInt(computedStyle.minWidth, 10);\n }\n } else {\n nextHeight = currentEl.offsetHeight;\n nextWidth = currentEl.offsetWidth;\n }\n height += nextHeight;\n width += nextWidth;\n }\n return { height, width };\n }\n applySizeToSiblings(vertical) {\n let containerToFlex = null;\n const siblings = this.getSiblings();\n if (!siblings) {\n return;\n }\n for (let i = 0; i < siblings.length; i++) {\n const el = siblings[i];\n if (el === containerToFlex) {\n continue;\n }\n if (vertical) {\n el.style.height = `${el.offsetHeight}px`;\n } else {\n el.style.width = `${el.offsetWidth}px`;\n }\n el.style.flex = \"0 0 auto\";\n if (el === this.element) {\n containerToFlex = siblings[i + 1];\n }\n }\n if (containerToFlex) {\n containerToFlex.style.removeProperty(\"height\");\n containerToFlex.style.removeProperty(\"min-height\");\n containerToFlex.style.removeProperty(\"max-height\");\n containerToFlex.style.flex = \"1 1 auto\";\n }\n }\n isResizable() {\n return Object.values(this.resizable).some((value) => value);\n }\n onResize(e) {\n if (!this.isResizing || !this.currentResizer) {\n return;\n }\n const { popup, forcePopupParentAsOffsetParent } = this.config;\n const { isTop, isRight, isBottom, isLeft } = this.currentResizer;\n const isHorizontal = isRight || isLeft;\n const isVertical = isBottom || isTop;\n const { movementX, movementY } = this.calculateMouseMovement({ e, isLeft, isTop });\n const xPosition = this.position.x;\n const yPosition = this.position.y;\n let offsetLeft = 0;\n let offsetTop = 0;\n if (isHorizontal && movementX) {\n const direction = isLeft ? -1 : 1;\n const oldWidth = this.getWidth();\n const newWidth = oldWidth + movementX * direction;\n let skipWidth = false;\n if (isLeft) {\n offsetLeft = oldWidth - newWidth;\n if (xPosition + offsetLeft <= 0 || newWidth <= this.minWidth) {\n skipWidth = true;\n offsetLeft = 0;\n }\n }\n if (!skipWidth) {\n this.setWidth(newWidth);\n }\n }\n if (isVertical && movementY) {\n const direction = isTop ? -1 : 1;\n const oldHeight = this.getHeight();\n const newHeight = oldHeight + movementY * direction;\n let skipHeight = false;\n if (isTop) {\n offsetTop = oldHeight - newHeight;\n if (yPosition + offsetTop <= 0 || newHeight <= this.minHeight) {\n skipHeight = true;\n offsetTop = 0;\n }\n } else {\n if (!this.config.popup && !this.config.forcePopupParentAsOffsetParent && oldHeight < newHeight && this.getMinSizeOfSiblings().height + newHeight > this.element.parentElement.offsetHeight) {\n skipHeight = true;\n }\n }\n if (!skipHeight) {\n this.setHeight(newHeight);\n }\n }\n this.updateDragStartPosition(e.clientX, e.clientY);\n if ((popup || forcePopupParentAsOffsetParent) && offsetLeft || offsetTop) {\n this.offsetElement(xPosition + offsetLeft, yPosition + offsetTop);\n }\n }\n onResizeEnd(e, side) {\n this.isResizing = false;\n this.currentResizer = null;\n this.boundaryEl = null;\n this.element.classList.remove(\"ag-resizing\");\n this.resizerMap[side].element.classList.remove(\"ag-active\");\n this.dispatchLocalEvent({ type: \"resize\" });\n }\n refreshSize() {\n const eGui = this.element;\n if (this.config.popup) {\n if (!this.config.width) {\n this.setWidth(eGui.offsetWidth);\n }\n if (!this.config.height) {\n this.setHeight(eGui.offsetHeight);\n }\n }\n }\n onMoveStart(e) {\n this.boundaryEl = this.findBoundaryElement();\n if (!this.positioned) {\n this.initialisePosition();\n }\n this.isMoving = true;\n this.element.classList.add(\"ag-moving\");\n this.updateDragStartPosition(e.clientX, e.clientY);\n }\n onMove(e) {\n if (!this.isMoving) {\n return;\n }\n const { x, y } = this.position;\n let topBuffer;\n if (this.config.calculateTopBuffer) {\n topBuffer = this.config.calculateTopBuffer();\n }\n const { movementX, movementY } = this.calculateMouseMovement({\n e,\n isTop: true,\n anywhereWithin: true,\n topBuffer\n });\n this.offsetElement(x + movementX, y + movementY);\n this.updateDragStartPosition(e.clientX, e.clientY);\n }\n onMoveEnd() {\n this.isMoving = false;\n this.boundaryEl = null;\n this.element.classList.remove(\"ag-moving\");\n }\n setOffsetParent() {\n if (this.config.forcePopupParentAsOffsetParent && this.popupSvc) {\n this.offsetParent = this.popupSvc.getPopupParent();\n } else {\n this.offsetParent = this.element.offsetParent;\n }\n }\n findBoundaryElement() {\n let el = this.element;\n while (el) {\n if (window.getComputedStyle(el).position !== \"static\") {\n return el;\n }\n el = el.parentElement;\n }\n return this.element;\n }\n clearResizeListeners() {\n while (this.resizeListeners.length) {\n const params = this.resizeListeners.pop();\n this.dragSvc?.removeDragSource(params);\n }\n }\n destroy() {\n super.destroy();\n if (this.moveElementDragListener) {\n this.dragSvc?.removeDragSource(this.moveElementDragListener);\n }\n this.constrainSizeToAvailableHeight(false);\n this.clearResizeListeners();\n this.removeResizers();\n }\n};\n\n// packages/ag-grid-community/src/widgets/managedFocusFeature.ts\nvar FOCUS_MANAGED_CLASS = \"ag-focus-managed\";\nvar ManagedFocusFeature = class extends BeanStub {\n constructor(eFocusable, callbacks = {}) {\n super();\n this.eFocusable = eFocusable;\n this.callbacks = callbacks;\n this.callbacks = {\n shouldStopEventPropagation: () => false,\n onTabKeyDown: (e) => {\n if (e.defaultPrevented) {\n return;\n }\n const nextRoot = _findNextFocusableElement(this.beans, this.eFocusable, false, e.shiftKey);\n if (!nextRoot) {\n return;\n }\n nextRoot.focus();\n e.preventDefault();\n },\n ...callbacks\n };\n }\n postConstruct() {\n const {\n eFocusable,\n callbacks: { onFocusIn, onFocusOut }\n } = this;\n eFocusable.classList.add(FOCUS_MANAGED_CLASS);\n this.addKeyDownListeners(eFocusable);\n if (onFocusIn) {\n this.addManagedElementListeners(eFocusable, { focusin: onFocusIn });\n }\n if (onFocusOut) {\n this.addManagedElementListeners(eFocusable, { focusout: onFocusOut });\n }\n }\n addKeyDownListeners(eGui) {\n this.addManagedElementListeners(eGui, {\n keydown: (e) => {\n if (e.defaultPrevented || _isStopPropagationForAgGrid(e)) {\n return;\n }\n const { callbacks } = this;\n if (callbacks.shouldStopEventPropagation(e)) {\n _stopPropagationForAgGrid(e);\n return;\n }\n if (e.key === KeyCode.TAB) {\n callbacks.onTabKeyDown(e);\n } else if (callbacks.handleKeyDown) {\n callbacks.handleKeyDown(e);\n }\n }\n });\n }\n};\n\n// packages/ag-grid-community/src/filter/filterLocaleText.ts\nvar FILTER_LOCALE_TEXT = {\n applyFilter: \"Apply\",\n clearFilter: \"Clear\",\n resetFilter: \"Reset\",\n cancelFilter: \"Cancel\",\n textFilter: \"Text Filter\",\n numberFilter: \"Number Filter\",\n dateFilter: \"Date Filter\",\n setFilter: \"Set Filter\",\n filterOoo: \"Filter...\",\n empty: \"Choose one\",\n equals: \"Equals\",\n notEqual: \"Does not equal\",\n lessThan: \"Less than\",\n greaterThan: \"Greater than\",\n inRange: \"Between\",\n inRangeStart: \"From\",\n inRangeEnd: \"To\",\n lessThanOrEqual: \"Less than or equal to\",\n greaterThanOrEqual: \"Greater than or equal to\",\n contains: \"Contains\",\n notContains: \"Does not contain\",\n startsWith: \"Begins with\",\n endsWith: \"Ends with\",\n blank: \"Blank\",\n notBlank: \"Not blank\",\n before: \"Before\",\n after: \"After\",\n andCondition: \"AND\",\n orCondition: \"OR\",\n dateFormatOoo: \"yyyy-mm-dd\"\n};\n\n// packages/ag-grid-community/src/filter/floating/provided/providedFilterUtils.ts\nfunction getDebounceMs(params, debounceDefault) {\n const { debounceMs } = params;\n if (isUseApplyButton(params)) {\n if (debounceMs != null) {\n _warn(71);\n }\n return 0;\n }\n return debounceMs ?? debounceDefault;\n}\nfunction isUseApplyButton(params) {\n return (params.buttons?.indexOf(\"apply\") ?? -1) >= 0;\n}\n\n// packages/ag-grid-community/src/filter/provided/providedFilter.ts\nvar ProvidedFilter = class extends Component {\n constructor(filterNameKey) {\n super();\n this.filterNameKey = filterNameKey;\n this.applyActive = false;\n this.hidePopup = null;\n this.debouncePending = false;\n // after the user hits 'apply' the model gets copied to here. this is then the model that we use for\n // all filtering. so if user changes UI but doesn't hit apply, then the UI will be out of sync with this model.\n // this is what we want, as the UI should only become the 'active' filter once it's applied. when apply is\n // inactive, this model will be in sync (following the debounce ms). if the UI is not a valid filter\n // (eg the value is missing so nothing to filter on, or for set filter all checkboxes are checked so filter\n // not active) then this appliedModel will be null/undefined.\n this.appliedModel = null;\n this.eFilterBody = RefPlaceholder;\n this.buttonListeners = [];\n // subclasses can override this to provide alternative debounce defaults\n this.defaultDebounceMs = 0;\n }\n postConstruct() {\n this.resetTemplate();\n this.createManagedBean(\n new ManagedFocusFeature(this.getFocusableElement(), {\n handleKeyDown: this.handleKeyDown.bind(this)\n })\n );\n this.positionableFeature = new PositionableFeature(this.getPositionableElement(), {\n forcePopupParentAsOffsetParent: true\n });\n this.createBean(this.positionableFeature);\n }\n // override\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n handleKeyDown(e) {\n }\n getFilterTitle() {\n return this.translate(this.filterNameKey);\n }\n isFilterActive() {\n return !!this.appliedModel;\n }\n resetTemplate(paramsMap) {\n let eGui = this.getGui();\n if (eGui) {\n eGui.removeEventListener(\"submit\", this.onFormSubmit);\n }\n const templateString = (\n /* html */\n `\n `\n );\n this.setTemplate(templateString, this.getAgComponents(), paramsMap);\n eGui = this.getGui();\n eGui?.addEventListener(\"submit\", this.onFormSubmit);\n }\n isReadOnly() {\n return !!this.params.readOnly;\n }\n init(params) {\n this.setParams(params);\n this.resetUiToDefaults(true).then(() => {\n this.updateUiVisibility();\n this.setupOnBtApplyDebounce();\n });\n }\n setParams(params) {\n this.params = params;\n this.applyActive = isUseApplyButton(params);\n this.resetButtonsPanel(params);\n }\n updateParams(params) {\n this.params = params;\n this.applyActive = isUseApplyButton(params);\n this.resetUiToActiveModel(this.getModel(), () => {\n this.updateUiVisibility();\n this.setupOnBtApplyDebounce();\n });\n }\n resetButtonsPanel(newParams, oldParams) {\n const { buttons: oldButtons, readOnly: oldReadOnly } = oldParams ?? {};\n const { buttons, readOnly } = newParams;\n if (oldReadOnly === readOnly && _jsonEquals(oldButtons, buttons)) {\n return;\n }\n const hasButtons = buttons && buttons.length > 0 && !this.isReadOnly();\n if (!this.eButtonsPanel) {\n if (hasButtons) {\n this.eButtonsPanel = document.createElement(\"div\");\n this.eButtonsPanel.classList.add(\"ag-filter-apply-panel\");\n }\n } else {\n _clearElement(this.eButtonsPanel);\n this.buttonListeners.forEach((destroyFunc) => destroyFunc());\n this.buttonListeners = [];\n }\n if (!hasButtons) {\n if (this.eButtonsPanel) {\n _removeFromParent(this.eButtonsPanel);\n }\n return;\n }\n const fragment = document.createDocumentFragment();\n const addButton = (type) => {\n let clickListener;\n const text = type ? this.translate(`${type}Filter`) : void 0;\n switch (type) {\n case \"apply\":\n clickListener = (e) => this.onBtApply(false, false, e);\n break;\n case \"clear\":\n clickListener = () => this.onBtClear();\n break;\n case \"reset\":\n clickListener = () => this.onBtReset();\n break;\n case \"cancel\":\n clickListener = (e) => {\n this.onBtCancel(e);\n };\n break;\n default:\n _warn(75);\n return;\n }\n const buttonType = type === \"apply\" ? \"submit\" : \"button\";\n const button = _loadTemplate(\n /* html */\n `${text}\n `\n );\n this.buttonListeners.push(...this.addManagedElementListeners(button, { click: clickListener }));\n fragment.append(button);\n };\n buttons.forEach((type) => addButton(type));\n this.eButtonsPanel.append(fragment);\n this.getGui().appendChild(this.eButtonsPanel);\n }\n setupOnBtApplyDebounce() {\n const debounceMs = getDebounceMs(this.params, this.defaultDebounceMs);\n const debounceFunc = _debounce(this, this.checkApplyDebounce.bind(this), debounceMs);\n this.onBtApplyDebounce = () => {\n this.debouncePending = true;\n debounceFunc();\n };\n }\n checkApplyDebounce() {\n if (this.debouncePending) {\n this.debouncePending = false;\n this.onBtApply();\n }\n }\n getModel() {\n return this.appliedModel ?? null;\n }\n setModel(model) {\n const promise = model != null ? this.setModelIntoUi(model) : this.resetUiToDefaults();\n return promise.then(() => {\n this.updateUiVisibility();\n this.applyModel(\"api\");\n });\n }\n onBtCancel(e) {\n this.resetUiToActiveModel(this.getModel(), () => {\n this.handleCancelEnd(e);\n });\n }\n handleCancelEnd(e) {\n if (this.params.closeOnApply) {\n this.close(e);\n }\n }\n resetUiToActiveModel(currentModel, afterUiUpdatedFunc) {\n const afterAppliedFunc = () => {\n this.onUiChanged(false, \"prevent\");\n afterUiUpdatedFunc?.();\n };\n if (currentModel != null) {\n this.setModelIntoUi(currentModel).then(afterAppliedFunc);\n } else {\n this.resetUiToDefaults().then(afterAppliedFunc);\n }\n }\n onBtClear() {\n this.resetUiToDefaults().then(() => this.onUiChanged());\n }\n onBtReset() {\n this.onBtClear();\n this.onBtApply();\n }\n /**\n * Applies changes made in the UI to the filter, and returns true if the model has changed.\n */\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n applyModel(source = \"api\") {\n const newModel = this.getModelFromUi();\n if (!this.isModelValid(newModel)) {\n return false;\n }\n const previousModel = this.appliedModel;\n this.appliedModel = newModel;\n return !this.areModelsEqual(previousModel, newModel);\n }\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n isModelValid(model) {\n return true;\n }\n onFormSubmit(e) {\n e.preventDefault();\n }\n onBtApply(afterFloatingFilter = false, afterDataChange = false, e) {\n if (e) {\n e.preventDefault();\n }\n if (this.applyModel(afterDataChange ? \"rowDataUpdated\" : \"ui\")) {\n const source = \"columnFilter\";\n this.params.filterChangedCallback({ afterFloatingFilter, afterDataChange, source });\n }\n const { closeOnApply } = this.params;\n if (closeOnApply && this.applyActive && !afterFloatingFilter && !afterDataChange) {\n this.close(e);\n }\n }\n onNewRowsLoaded() {\n }\n close(e) {\n if (!this.hidePopup) {\n return;\n }\n const keyboardEvent = e;\n const key = keyboardEvent && keyboardEvent.key;\n let params;\n if (key === \"Enter\" || key === \"Space\") {\n params = { keyboardEvent };\n }\n this.hidePopup(params);\n this.hidePopup = null;\n }\n /**\n * By default, if the change came from a floating filter it will be applied immediately, otherwise if there is no\n * apply button it will be applied after a debounce, otherwise it will not be applied at all. This behaviour can\n * be adjusted by using the apply parameter.\n */\n onUiChanged(fromFloatingFilter = false, apply) {\n this.updateUiVisibility();\n this.params.filterModifiedCallback();\n if (this.applyActive && !this.isReadOnly()) {\n const isValid = this.isModelValid(this.getModelFromUi());\n const applyFilterButton = this.queryForHtmlElement(`[data-ref=\"applyFilterButton\"]`);\n if (applyFilterButton) {\n _setDisabled(applyFilterButton, !isValid);\n }\n }\n if (fromFloatingFilter && !apply || apply === \"immediately\") {\n this.onBtApply(fromFloatingFilter);\n } else if (!this.applyActive && !apply || apply === \"debounce\") {\n this.onBtApplyDebounce();\n }\n }\n afterGuiAttached(params) {\n if (params) {\n this.hidePopup = params.hidePopup;\n }\n this.refreshFilterResizer(params?.container);\n }\n refreshFilterResizer(containerType) {\n const { positionableFeature, gos } = this;\n if (!positionableFeature || containerType === \"toolPanel\") {\n return;\n }\n const isResizable = containerType === \"floatingFilter\" || containerType === \"columnFilter\";\n if (isResizable) {\n positionableFeature.restoreLastSize();\n positionableFeature.setResizable(\n gos.get(\"enableRtl\") ? { bottom: true, bottomLeft: true, left: true } : { bottom: true, bottomRight: true, right: true }\n );\n } else {\n positionableFeature.removeSizeFromEl();\n positionableFeature.setResizable(false);\n }\n positionableFeature.constrainSizeToAvailableHeight(true);\n }\n afterGuiDetached() {\n this.checkApplyDebounce();\n this.positionableFeature?.constrainSizeToAvailableHeight(false);\n }\n refresh(newParams) {\n const oldParams = this.params;\n this.params = newParams;\n this.resetButtonsPanel(newParams, oldParams);\n return true;\n }\n destroy() {\n const eGui = this.getGui();\n if (eGui) {\n eGui.removeEventListener(\"submit\", this.onFormSubmit);\n }\n this.hidePopup = null;\n if (this.positionableFeature) {\n this.positionableFeature = this.destroyBean(this.positionableFeature);\n }\n this.appliedModel = null;\n super.destroy();\n }\n translate(key) {\n return this.getLocaleTextFunc()(key, FILTER_LOCALE_TEXT[key]);\n }\n getCellValue(rowNode) {\n return this.params.getValue(rowNode);\n }\n // override to control positionable feature\n getPositionableElement() {\n return this.eFilterBody;\n }\n};\n\n// packages/ag-grid-community/src/filter/floating/floatingFilterMapper.ts\nfunction _getDefaultFloatingFilterType(frameworkOverrides, def, getFromDefault) {\n if (def == null) {\n return null;\n }\n let defaultFloatingFilterType = null;\n const { compName, jsComp, fwComp } = _getFilterCompKeys(frameworkOverrides, def);\n if (compName) {\n const floatingFilterTypeMap = {\n agSetColumnFilter: \"agSetColumnFloatingFilter\",\n agMultiColumnFilter: \"agMultiColumnFloatingFilter\",\n agGroupColumnFilter: \"agGroupColumnFloatingFilter\",\n agNumberColumnFilter: \"agNumberColumnFloatingFilter\",\n agDateColumnFilter: \"agDateColumnFloatingFilter\",\n agTextColumnFilter: \"agTextColumnFloatingFilter\"\n };\n defaultFloatingFilterType = floatingFilterTypeMap[compName];\n } else {\n const usingDefaultFilter = jsComp == null && fwComp == null && def.filter === true;\n if (usingDefaultFilter) {\n defaultFloatingFilterType = getFromDefault();\n }\n }\n return defaultFloatingFilterType;\n}\n\n// packages/ag-grid-community/src/styling/layoutFeature.ts\nvar LayoutCssClasses = {\n AUTO_HEIGHT: \"ag-layout-auto-height\",\n NORMAL: \"ag-layout-normal\",\n PRINT: \"ag-layout-print\"\n};\nvar LayoutFeature = class extends BeanStub {\n constructor(view) {\n super();\n this.view = view;\n }\n postConstruct() {\n this.addManagedPropertyListener(\"domLayout\", this.updateLayoutClasses.bind(this));\n this.updateLayoutClasses();\n }\n updateLayoutClasses() {\n const domLayout = this.gos.get(\"domLayout\");\n const params = {\n autoHeight: domLayout === \"autoHeight\",\n normal: domLayout === \"normal\",\n print: domLayout === \"print\"\n };\n const cssClass = params.autoHeight ? LayoutCssClasses.AUTO_HEIGHT : params.print ? LayoutCssClasses.PRINT : LayoutCssClasses.NORMAL;\n this.view.updateLayoutClasses(cssClass, params);\n }\n};\n\n// packages/ag-grid-community/src/gridBodyComp/gridBodyScrollFeature.ts\nvar VIEWPORT = \"Viewport\";\nvar FAKE_V_SCROLLBAR = \"fakeVScrollComp\";\nvar HORIZONTAL_SOURCES = [\n \"fakeHScrollComp\",\n \"centerHeader\",\n \"topCenter\",\n \"bottomCenter\",\n \"stickyTopCenter\",\n \"stickyBottomCenter\"\n];\nvar SCROLL_DEBOUNCE_TIMEOUT = 100;\nvar SCROLL_END_TIMEOUT = 150;\nvar GridBodyScrollFeature = class extends BeanStub {\n constructor(eBodyViewport) {\n super();\n this.lastScrollSource = [null, null];\n this.scrollLeft = -1;\n this.nextScrollTop = -1;\n this.scrollTop = -1;\n // Used to provide approximate values of scrollTop and offsetHeight\n // without forcing the browser to recalculate styles.\n this.lastOffsetHeight = -1;\n this.lastScrollTop = -1;\n this.scrollTimer = 0;\n this.needsRefreshedScrollPosition = true;\n this.eBodyViewport = eBodyViewport;\n this.resetLastHScrollDebounced = _debounce(\n this,\n () => this.lastScrollSource[1 /* Horizontal */] = null,\n SCROLL_END_TIMEOUT\n );\n this.resetLastVScrollDebounced = _debounce(\n this,\n () => this.lastScrollSource[0 /* Vertical */] = null,\n SCROLL_END_TIMEOUT\n );\n }\n wireBeans(beans) {\n this.ctrlsSvc = beans.ctrlsSvc;\n this.animationFrameSvc = beans.animationFrameSvc;\n this.visibleCols = beans.visibleCols;\n }\n destroy() {\n super.destroy();\n window.clearTimeout(this.scrollTimer);\n }\n postConstruct() {\n this.enableRtl = this.gos.get(\"enableRtl\");\n const requireUpdatedScrollPosition = this.requireUpdatedScrollPosition.bind(this);\n this.addManagedEventListeners({\n displayedColumnsWidthChanged: this.onDisplayedColumnsWidthChanged.bind(this),\n gridSizeChanged: requireUpdatedScrollPosition\n });\n this.addManagedElementListeners(this.eBodyViewport, {\n scroll: requireUpdatedScrollPosition\n });\n this.ctrlsSvc.whenReady(this, (p) => {\n this.centerRowsCtrl = p.center;\n this.onDisplayedColumnsWidthChanged();\n this.addScrollListener();\n });\n }\n requireUpdatedScrollPosition() {\n this.needsRefreshedScrollPosition = true;\n }\n addScrollListener() {\n this.addHorizontalScrollListeners();\n this.addVerticalScrollListeners();\n }\n addHorizontalScrollListeners() {\n this.addManagedElementListeners(this.centerRowsCtrl.eViewport, {\n scroll: this.onHScroll.bind(this, VIEWPORT)\n });\n for (const source of HORIZONTAL_SOURCES) {\n const scrollPartner = this.ctrlsSvc.get(source);\n this.registerScrollPartner(scrollPartner, this.onHScroll.bind(this, source));\n }\n }\n addVerticalScrollListeners() {\n const fakeVScrollComp = this.ctrlsSvc.get(\"fakeVScrollComp\");\n const isDebounce = this.gos.get(\"debounceVerticalScrollbar\");\n const onVScroll = isDebounce ? _debounce(this, this.onVScroll.bind(this, VIEWPORT), SCROLL_DEBOUNCE_TIMEOUT) : this.onVScroll.bind(this, VIEWPORT);\n const onFakeVScroll = isDebounce ? _debounce(this, this.onVScroll.bind(this, FAKE_V_SCROLLBAR), SCROLL_DEBOUNCE_TIMEOUT) : this.onVScroll.bind(this, FAKE_V_SCROLLBAR);\n this.addManagedElementListeners(this.eBodyViewport, { scroll: onVScroll });\n this.registerScrollPartner(fakeVScrollComp, onFakeVScroll);\n }\n registerScrollPartner(comp, callback) {\n comp.onScrollCallback(callback);\n }\n onDisplayedColumnsWidthChanged() {\n if (this.enableRtl) {\n this.horizontallyScrollHeaderCenterAndFloatingCenter();\n }\n }\n horizontallyScrollHeaderCenterAndFloatingCenter(scrollLeft) {\n const notYetInitialised = this.centerRowsCtrl == null;\n if (notYetInitialised) {\n return;\n }\n if (scrollLeft === void 0) {\n scrollLeft = this.centerRowsCtrl.getCenterViewportScrollLeft();\n }\n this.setScrollLeftForAllContainersExceptCurrent(Math.abs(scrollLeft));\n }\n setScrollLeftForAllContainersExceptCurrent(scrollLeft) {\n for (const container of [...HORIZONTAL_SOURCES, VIEWPORT]) {\n if (this.lastScrollSource[1 /* Horizontal */] === container) {\n continue;\n }\n const viewport = this.getViewportForSource(container);\n _setScrollLeft(viewport, scrollLeft, this.enableRtl);\n }\n }\n getViewportForSource(source) {\n if (source === VIEWPORT) {\n return this.centerRowsCtrl.eViewport;\n }\n return this.ctrlsSvc.get(source).eViewport;\n }\n isControllingScroll(source, direction) {\n if (this.lastScrollSource[direction] == null) {\n if (direction === 0 /* Vertical */) {\n this.lastScrollSource[0] = source;\n } else {\n this.lastScrollSource[1] = source;\n }\n return true;\n }\n return this.lastScrollSource[direction] === source;\n }\n onHScroll(source) {\n if (!this.isControllingScroll(source, 1 /* Horizontal */)) {\n return;\n }\n const centerContainerViewport = this.centerRowsCtrl.eViewport;\n const { scrollLeft } = centerContainerViewport;\n if (this.shouldBlockScrollUpdate(1 /* Horizontal */, scrollLeft, true)) {\n return;\n }\n const newScrollLeft = _getScrollLeft(this.getViewportForSource(source), this.enableRtl);\n this.doHorizontalScroll(newScrollLeft);\n this.resetLastHScrollDebounced();\n }\n onVScroll(source) {\n if (!this.isControllingScroll(source, 0 /* Vertical */)) {\n return;\n }\n let scrollTop;\n if (source === VIEWPORT) {\n scrollTop = this.eBodyViewport.scrollTop;\n } else {\n scrollTop = this.ctrlsSvc.get(\"fakeVScrollComp\").getScrollPosition();\n }\n if (this.shouldBlockScrollUpdate(0 /* Vertical */, scrollTop, true)) {\n return;\n }\n const { animationFrameSvc } = this;\n animationFrameSvc?.setScrollTop(scrollTop);\n this.nextScrollTop = scrollTop;\n if (source === VIEWPORT) {\n this.ctrlsSvc.get(\"fakeVScrollComp\").setScrollPosition(scrollTop);\n } else {\n this.eBodyViewport.scrollTop = scrollTop;\n }\n if (!animationFrameSvc || this.gos.get(\"suppressAnimationFrame\")) {\n this.scrollGridIfNeeded(true);\n } else {\n animationFrameSvc.schedule();\n }\n this.resetLastVScrollDebounced();\n }\n doHorizontalScroll(scrollLeft) {\n const fakeScrollLeft = this.ctrlsSvc.get(\"fakeHScrollComp\").getScrollPosition();\n if (this.scrollLeft === scrollLeft && scrollLeft === fakeScrollLeft) {\n return;\n }\n this.scrollLeft = scrollLeft;\n this.fireScrollEvent(1 /* Horizontal */);\n this.horizontallyScrollHeaderCenterAndFloatingCenter(scrollLeft);\n this.centerRowsCtrl.onHorizontalViewportChanged(true);\n }\n fireScrollEvent(direction) {\n const bodyScrollEvent = {\n type: \"bodyScroll\",\n direction: direction === 1 /* Horizontal */ ? \"horizontal\" : \"vertical\",\n left: this.scrollLeft,\n top: this.scrollTop\n };\n this.eventSvc.dispatchEvent(bodyScrollEvent);\n window.clearTimeout(this.scrollTimer);\n this.scrollTimer = window.setTimeout(() => {\n this.scrollTimer = 0;\n this.eventSvc.dispatchEvent({\n ...bodyScrollEvent,\n type: \"bodyScrollEnd\"\n });\n }, SCROLL_END_TIMEOUT);\n }\n shouldBlockScrollUpdate(direction, scrollTo, touchOnly = false) {\n if (touchOnly && !_isIOSUserAgent()) {\n return false;\n }\n if (direction === 0 /* Vertical */) {\n return this.shouldBlockVerticalScroll(scrollTo);\n }\n return this.shouldBlockHorizontalScroll(scrollTo);\n }\n shouldBlockVerticalScroll(scrollTo) {\n const clientHeight = _getInnerHeight(this.eBodyViewport);\n const { scrollHeight } = this.eBodyViewport;\n if (scrollTo < 0 || scrollTo + clientHeight > scrollHeight) {\n return true;\n }\n return false;\n }\n shouldBlockHorizontalScroll(scrollTo) {\n const clientWidth = this.centerRowsCtrl.getCenterWidth();\n const { scrollWidth } = this.centerRowsCtrl.eViewport;\n if (this.enableRtl && _isRtlNegativeScroll()) {\n if (scrollTo > 0) {\n return true;\n }\n } else if (scrollTo < 0) {\n return true;\n }\n if (Math.abs(scrollTo) + clientWidth > scrollWidth) {\n return true;\n }\n return false;\n }\n redrawRowsAfterScroll() {\n this.fireScrollEvent(0 /* Vertical */);\n }\n // this is to cater for AG-3274, where grid is removed from the dom and then inserted back in again.\n // (which happens with some implementations of tabbing). this can result in horizontal scroll getting\n // reset back to the left, however no scroll event is fired. so we need to get header to also scroll\n // back to the left to be kept in sync.\n // adding and removing the grid from the DOM both resets the scroll position and\n // triggers a resize event, so notify listeners if the scroll position has changed\n checkScrollLeft() {\n if (this.scrollLeft !== this.centerRowsCtrl.getCenterViewportScrollLeft()) {\n this.onHScroll(VIEWPORT);\n }\n }\n scrollGridIfNeeded(suppressedAnimationFrame = false) {\n const frameNeeded = this.scrollTop != this.nextScrollTop;\n if (frameNeeded) {\n this.scrollTop = this.nextScrollTop;\n if (suppressedAnimationFrame) {\n this.requireUpdatedScrollPosition();\n }\n this.redrawRowsAfterScroll();\n }\n return frameNeeded;\n }\n // called by scrollHorizontally method and alignedGridsService\n setHorizontalScrollPosition(hScrollPosition, fromAlignedGridsService = false) {\n const minScrollLeft = 0;\n const maxScrollLeft = this.centerRowsCtrl.eViewport.scrollWidth - this.centerRowsCtrl.getCenterWidth();\n if (!fromAlignedGridsService && this.shouldBlockScrollUpdate(1 /* Horizontal */, hScrollPosition)) {\n if (this.enableRtl && _isRtlNegativeScroll()) {\n hScrollPosition = hScrollPosition > 0 ? 0 : maxScrollLeft;\n } else {\n hScrollPosition = Math.min(Math.max(hScrollPosition, minScrollLeft), maxScrollLeft);\n }\n }\n _setScrollLeft(this.centerRowsCtrl.eViewport, Math.abs(hScrollPosition), this.enableRtl);\n this.doHorizontalScroll(hScrollPosition);\n }\n setVerticalScrollPosition(vScrollPosition) {\n this.requireUpdatedScrollPosition();\n this.eBodyViewport.scrollTop = vScrollPosition;\n }\n getVScrollPosition() {\n if (!this.needsRefreshedScrollPosition) {\n const { lastOffsetHeight, lastScrollTop } = this;\n return {\n top: lastScrollTop,\n bottom: lastScrollTop + lastOffsetHeight\n };\n }\n this.needsRefreshedScrollPosition = false;\n const { scrollTop, offsetHeight } = this.eBodyViewport;\n this.lastScrollTop = scrollTop;\n this.lastOffsetHeight = offsetHeight;\n return {\n top: scrollTop,\n bottom: scrollTop + offsetHeight\n };\n }\n /** Get an approximate scroll position that returns the last real value read.\n * This is useful for avoiding repeated DOM reads that force the browser to recalculate styles.\n * This can have big performance improvements but may not be 100% accurate so only use if this is acceptable.\n */\n getApproximateVScollPosition() {\n if (this.lastScrollTop >= 0 && this.lastOffsetHeight >= 0) {\n return {\n top: this.scrollTop,\n bottom: this.scrollTop + this.lastOffsetHeight\n };\n }\n return this.getVScrollPosition();\n }\n getHScrollPosition() {\n return this.centerRowsCtrl.getHScrollPosition();\n }\n isHorizontalScrollShowing() {\n return this.centerRowsCtrl.isHorizontalScrollShowing();\n }\n // called by the headerRootComp and moveColumnController\n scrollHorizontally(pixels) {\n const oldScrollPosition = this.centerRowsCtrl.eViewport.scrollLeft;\n this.setHorizontalScrollPosition(oldScrollPosition + pixels);\n return this.centerRowsCtrl.eViewport.scrollLeft - oldScrollPosition;\n }\n // gets called by rowRenderer when new data loaded, as it will want to scroll to the top\n scrollToTop() {\n this.eBodyViewport.scrollTop = 0;\n }\n // Valid values for position are bottom, middle and top\n ensureNodeVisible(comparator, position = null) {\n const { rowModel } = this.beans;\n const rowCount = rowModel.getRowCount();\n let indexToSelect = -1;\n for (let i = 0; i < rowCount; i++) {\n const node = rowModel.getRow(i);\n if (typeof comparator === \"function\") {\n const predicate = comparator;\n if (node && predicate(node)) {\n indexToSelect = i;\n break;\n }\n } else {\n if (comparator === node || comparator === node.data) {\n indexToSelect = i;\n break;\n }\n }\n }\n if (indexToSelect >= 0) {\n this.ensureIndexVisible(indexToSelect, position);\n }\n }\n // Valid values for position are bottom, middle and top\n // position should be {'top','middle','bottom', or undefined/null}.\n // if undefined/null, then the grid will to the minimal amount of scrolling,\n // eg if grid needs to scroll up, it scrolls until row is on top,\n // if grid needs to scroll down, it scrolls until row is on bottom,\n // if row is already in view, grid does not scroll\n ensureIndexVisible(index, position) {\n if (_isDomLayout(this.gos, \"print\")) {\n return;\n }\n const { rowModel } = this.beans;\n const rowCount = rowModel.getRowCount();\n if (typeof index !== \"number\" || index < 0 || index >= rowCount) {\n _warn(88, { index });\n return;\n }\n const isPaging = this.gos.get(\"pagination\");\n const paginationPanelEnabled = isPaging && !this.gos.get(\"suppressPaginationPanel\");\n const {\n frameworkOverrides,\n pagination,\n pageBounds,\n rowContainerHeight: heightScaler,\n rowRenderer\n } = this.beans;\n frameworkOverrides.wrapIncoming(() => {\n if (!paginationPanelEnabled) {\n pagination?.goToPageWithIndex(index);\n }\n const gridBodyCtrl = this.ctrlsSvc.getGridBodyCtrl();\n const stickyTopHeight = gridBodyCtrl.stickyTopHeight;\n const stickyBottomHeight = gridBodyCtrl.stickyBottomHeight;\n const rowNode = rowModel.getRow(index);\n let rowGotShiftedDuringOperation;\n do {\n const startingRowTop = rowNode.rowTop;\n const startingRowHeight = rowNode.rowHeight;\n const paginationOffset = pageBounds.getPixelOffset();\n const rowTopPixel = rowNode.rowTop - paginationOffset;\n const rowBottomPixel = rowTopPixel + rowNode.rowHeight;\n const scrollPosition = this.getVScrollPosition();\n const heightOffset = heightScaler.divStretchOffset;\n const vScrollTop = scrollPosition.top + heightOffset;\n const vScrollBottom = scrollPosition.bottom + heightOffset;\n const viewportHeight = vScrollBottom - vScrollTop;\n const pxTop = heightScaler.getScrollPositionForPixel(rowTopPixel);\n const pxBottom = heightScaler.getScrollPositionForPixel(rowBottomPixel - viewportHeight);\n const pxMiddle = Math.min((pxTop + pxBottom) / 2, rowTopPixel);\n const rowAboveViewport = vScrollTop + stickyTopHeight > rowTopPixel;\n const rowBelowViewport = vScrollBottom - stickyBottomHeight < rowBottomPixel;\n let newScrollPosition = null;\n if (position === \"top\") {\n newScrollPosition = pxTop;\n } else if (position === \"bottom\") {\n newScrollPosition = pxBottom;\n } else if (position === \"middle\") {\n newScrollPosition = pxMiddle;\n } else if (rowAboveViewport) {\n newScrollPosition = pxTop - stickyTopHeight;\n } else if (rowBelowViewport) {\n newScrollPosition = pxBottom + stickyBottomHeight;\n }\n if (newScrollPosition !== null) {\n this.setVerticalScrollPosition(newScrollPosition);\n rowRenderer.redraw({ afterScroll: true });\n }\n rowGotShiftedDuringOperation = startingRowTop !== rowNode.rowTop || startingRowHeight !== rowNode.rowHeight;\n } while (rowGotShiftedDuringOperation);\n this.animationFrameSvc?.flushAllFrames();\n });\n }\n ensureColumnVisible(key, position = \"auto\") {\n const { colModel, frameworkOverrides } = this.beans;\n const column = colModel.getCol(key);\n if (!column) {\n return;\n }\n if (column.isPinned()) {\n return;\n }\n if (!this.visibleCols.isColDisplayed(column)) {\n return;\n }\n const newHorizontalScroll = this.getPositionedHorizontalScroll(column, position);\n frameworkOverrides.wrapIncoming(() => {\n if (newHorizontalScroll !== null) {\n this.centerRowsCtrl.setCenterViewportScrollLeft(newHorizontalScroll);\n }\n this.centerRowsCtrl.onHorizontalViewportChanged();\n this.animationFrameSvc?.flushAllFrames();\n });\n }\n getPositionedHorizontalScroll(column, position) {\n const { columnBeforeStart, columnAfterEnd } = this.isColumnOutsideViewport(column);\n const viewportTooSmallForColumn = this.centerRowsCtrl.getCenterWidth() < column.getActualWidth();\n const viewportWidth = this.centerRowsCtrl.getCenterWidth();\n const isRtl = this.enableRtl;\n let alignColToStart = (isRtl ? columnBeforeStart : columnAfterEnd) || viewportTooSmallForColumn;\n let alignColToEnd = isRtl ? columnAfterEnd : columnBeforeStart;\n if (position !== \"auto\") {\n alignColToStart = position === \"start\";\n alignColToEnd = position === \"end\";\n }\n const isMiddle = position === \"middle\";\n if (alignColToStart || alignColToEnd || isMiddle) {\n const { colLeft, colMiddle, colRight } = this.getColumnBounds(column);\n if (isMiddle) {\n return colMiddle - viewportWidth / 2;\n }\n if (alignColToStart) {\n return isRtl ? colRight : colLeft;\n }\n return isRtl ? colLeft - viewportWidth : colRight - viewportWidth;\n }\n return null;\n }\n isColumnOutsideViewport(column) {\n const { start: viewportStart, end: viewportEnd } = this.getViewportBounds();\n const { colLeft, colRight } = this.getColumnBounds(column);\n const isRtl = this.enableRtl;\n const columnBeforeStart = isRtl ? viewportStart > colRight : viewportEnd < colRight;\n const columnAfterEnd = isRtl ? viewportEnd < colLeft : viewportStart > colLeft;\n return { columnBeforeStart, columnAfterEnd };\n }\n getColumnBounds(column) {\n const isRtl = this.enableRtl;\n const bodyWidth = this.visibleCols.bodyWidth;\n const colWidth = column.getActualWidth();\n const colLeft = column.getLeft();\n const multiplier = isRtl ? -1 : 1;\n const colLeftPixel = isRtl ? bodyWidth - colLeft : colLeft;\n const colRightPixel = colLeftPixel + colWidth * multiplier;\n const colMidPixel = colLeftPixel + colWidth / 2 * multiplier;\n return { colLeft: colLeftPixel, colMiddle: colMidPixel, colRight: colRightPixel };\n }\n getViewportBounds() {\n const viewportWidth = this.centerRowsCtrl.getCenterWidth();\n const scrollPosition = this.centerRowsCtrl.getCenterViewportScrollLeft();\n const viewportStartPixel = scrollPosition;\n const viewportEndPixel = viewportWidth + scrollPosition;\n return { start: viewportStartPixel, end: viewportEndPixel, width: viewportWidth };\n }\n};\n\n// packages/ag-grid-community/src/gridBodyComp/centerWidthFeature.ts\nvar CenterWidthFeature = class extends BeanStub {\n constructor(callback, addSpacer = false) {\n super();\n this.callback = callback;\n this.addSpacer = addSpacer;\n }\n postConstruct() {\n const listener = this.setWidth.bind(this);\n this.addManagedPropertyListener(\"domLayout\", listener);\n this.addManagedEventListeners({\n columnContainerWidthChanged: listener,\n displayedColumnsChanged: listener,\n leftPinnedWidthChanged: listener\n });\n if (this.addSpacer) {\n this.addManagedEventListeners({\n rightPinnedWidthChanged: listener,\n scrollVisibilityChanged: listener,\n scrollbarWidthChanged: listener\n });\n }\n this.setWidth();\n }\n setWidth() {\n const printLayout = _isDomLayout(this.gos, \"print\");\n const { visibleCols, scrollVisibleSvc } = this.beans;\n const centerWidth = visibleCols.bodyWidth;\n const leftWidth = visibleCols.getColsLeftWidth();\n const rightWidth = visibleCols.getDisplayedColumnsRightWidth();\n let totalWidth;\n if (printLayout) {\n totalWidth = centerWidth + leftWidth + rightWidth;\n } else {\n totalWidth = centerWidth;\n if (this.addSpacer) {\n const relevantWidth = this.gos.get(\"enableRtl\") ? leftWidth : rightWidth;\n if (relevantWidth === 0 && scrollVisibleSvc.verticalScrollShowing) {\n totalWidth += scrollVisibleSvc.getScrollbarWidth();\n }\n }\n }\n this.callback(totalWidth);\n }\n};\n\n// packages/ag-grid-community/src/gridBodyComp/viewportSizeFeature.ts\nvar ViewportSizeFeature = class extends BeanStub {\n constructor(centerContainerCtrl) {\n super();\n this.centerContainerCtrl = centerContainerCtrl;\n }\n wireBeans(beans) {\n this.scrollVisibleSvc = beans.scrollVisibleSvc;\n }\n postConstruct() {\n this.beans.ctrlsSvc.whenReady(this, (p) => {\n this.gridBodyCtrl = p.gridBodyCtrl;\n this.listenForResize();\n });\n this.addManagedEventListeners({ scrollbarWidthChanged: this.onScrollbarWidthChanged.bind(this) });\n this.addManagedPropertyListeners([\"alwaysShowHorizontalScroll\", \"alwaysShowVerticalScroll\"], () => {\n this.checkViewportAndScrolls();\n });\n }\n listenForResize() {\n const { beans, centerContainerCtrl, gridBodyCtrl } = this;\n const listener = () => {\n _requestAnimationFrame(beans, () => {\n this.onCenterViewportResized();\n });\n };\n centerContainerCtrl.registerViewportResizeListener(listener);\n gridBodyCtrl.registerBodyViewportResizeListener(listener);\n }\n onScrollbarWidthChanged() {\n this.checkViewportAndScrolls();\n }\n onCenterViewportResized() {\n this.scrollVisibleSvc.updateScrollGap();\n if (this.centerContainerCtrl.isViewportInTheDOMTree()) {\n const { pinnedCols, colFlex } = this.beans;\n pinnedCols?.keepPinnedColumnsNarrowerThanViewport();\n this.checkViewportAndScrolls();\n const newWidth = this.centerContainerCtrl.getCenterWidth();\n if (newWidth !== this.centerWidth) {\n this.centerWidth = newWidth;\n colFlex?.refreshFlexedColumns({\n viewportWidth: this.centerWidth,\n updateBodyWidths: true,\n fireResizedEvent: true\n });\n }\n } else {\n this.bodyHeight = 0;\n }\n }\n // gets called every time the viewport size changes. we use this to check visibility of scrollbars\n // in the grid panel, and also to check size and position of viewport for row and column virtualisation.\n checkViewportAndScrolls() {\n this.updateScrollVisibleService();\n this.checkBodyHeight();\n this.onHorizontalViewportChanged();\n this.gridBodyCtrl.scrollFeature.checkScrollLeft();\n }\n getBodyHeight() {\n return this.bodyHeight;\n }\n checkBodyHeight() {\n const eBodyViewport = this.gridBodyCtrl.eBodyViewport;\n const bodyHeight = _getInnerHeight(eBodyViewport);\n if (this.bodyHeight !== bodyHeight) {\n this.bodyHeight = bodyHeight;\n this.eventSvc.dispatchEvent({\n type: \"bodyHeightChanged\"\n });\n }\n }\n updateScrollVisibleService() {\n this.updateScrollVisibleServiceImpl();\n setTimeout(this.updateScrollVisibleServiceImpl.bind(this), 500);\n }\n updateScrollVisibleServiceImpl() {\n const params = {\n horizontalScrollShowing: this.centerContainerCtrl.isHorizontalScrollShowing(),\n verticalScrollShowing: this.gridBodyCtrl.isVerticalScrollShowing()\n };\n this.scrollVisibleSvc.setScrollsVisible(params);\n }\n // this gets called whenever a change in the viewport, so we can inform column controller it has to work\n // out the virtual columns again. gets called from following locations:\n // + ensureColVisible, scroll, init, layoutChanged, displayedColumnsChanged\n onHorizontalViewportChanged() {\n const scrollWidth = this.centerContainerCtrl.getCenterWidth();\n const scrollPosition = this.centerContainerCtrl.getViewportScrollLeft();\n this.beans.colViewport.setScrollPosition(scrollWidth, scrollPosition);\n }\n};\n\n// packages/ag-grid-community/src/styling/stylingUtils.ts\nfunction processClassRules(expressionSvc, previousClassRules, classRules, params, onApplicableClass, onNotApplicableClass) {\n if (classRules == null && previousClassRules == null) {\n return;\n }\n const classesToApply = {};\n const classesToRemove = {};\n const forEachSingleClass = (className, callback) => {\n className.split(\" \").forEach((singleClass) => {\n if (singleClass.trim() == \"\")\n return;\n callback(singleClass);\n });\n };\n if (classRules) {\n const classNames = Object.keys(classRules);\n for (let i = 0; i < classNames.length; i++) {\n const className = classNames[i];\n const rule = classRules[className];\n let resultOfRule;\n if (typeof rule === \"string\") {\n resultOfRule = expressionSvc ? expressionSvc.evaluate(rule, params) : true;\n } else if (typeof rule === \"function\") {\n resultOfRule = rule(params);\n }\n forEachSingleClass(className, (singleClass) => {\n resultOfRule ? classesToApply[singleClass] = true : classesToRemove[singleClass] = true;\n });\n }\n }\n if (previousClassRules && onNotApplicableClass) {\n Object.keys(previousClassRules).forEach(\n (className) => forEachSingleClass(className, (singleClass) => {\n if (!classesToApply[singleClass]) {\n classesToRemove[singleClass] = true;\n }\n })\n );\n }\n if (onNotApplicableClass) {\n Object.keys(classesToRemove).forEach(onNotApplicableClass);\n }\n Object.keys(classesToApply).forEach(onApplicableClass);\n}\n\n// packages/ag-grid-community/src/styling/rowStyleService.ts\nfunction calculateRowLevel(rowNode) {\n if (rowNode.group) {\n return rowNode.level;\n }\n const parent = rowNode.parent;\n return parent ? parent.level + 1 : 0;\n}\nvar RowStyleService = class extends BeanStub {\n constructor() {\n super(...arguments);\n this.beanName = \"rowStyleSvc\";\n }\n processClassesFromGridOptions(classes, rowNode) {\n const gos = this.gos;\n const process = (rowCls) => {\n if (typeof rowCls === \"string\") {\n classes.push(rowCls);\n } else if (Array.isArray(rowCls)) {\n rowCls.forEach((e) => classes.push(e));\n }\n };\n const rowClass = gos.get(\"rowClass\");\n if (rowClass) {\n process(rowClass);\n }\n const rowClassFunc = gos.getCallback(\"getRowClass\");\n if (rowClassFunc) {\n const params = {\n data: rowNode.data,\n node: rowNode,\n rowIndex: rowNode.rowIndex\n };\n const rowClassFuncResult = rowClassFunc(params);\n process(rowClassFuncResult);\n }\n }\n preProcessRowClassRules(classes, rowNode) {\n this.processRowClassRules(\n rowNode,\n (className) => {\n classes.push(className);\n },\n () => {\n }\n );\n }\n processRowClassRules(rowNode, onApplicableClass, onNotApplicableClass) {\n const { gos, expressionSvc } = this.beans;\n const rowClassParams = _addGridCommonParams(gos, {\n data: rowNode.data,\n node: rowNode,\n rowIndex: rowNode.rowIndex\n });\n processClassRules(\n expressionSvc,\n void 0,\n gos.get(\"rowClassRules\"),\n rowClassParams,\n onApplicableClass,\n onNotApplicableClass\n );\n }\n processStylesFromGridOptions(rowNode) {\n const gos = this.gos;\n const rowStyle = gos.get(\"rowStyle\");\n const rowStyleFunc = gos.getCallback(\"getRowStyle\");\n let rowStyleFuncResult;\n if (rowStyleFunc) {\n const params = {\n data: rowNode.data,\n node: rowNode,\n rowIndex: rowNode.rowIndex\n };\n rowStyleFuncResult = rowStyleFunc(params);\n }\n if (rowStyleFuncResult || rowStyle) {\n return Object.assign({}, rowStyle, rowStyleFuncResult);\n }\n return void 0;\n }\n};\n\n// packages/ag-grid-community/src/rendering/row/rowCtrl.ts\nvar instanceIdSequence3 = 0;\nvar DOM_DATA_KEY_ROW_CTRL = \"renderedRow\";\nvar RowCtrl = class extends BeanStub {\n constructor(rowNode, beans, animateIn, useAnimationFrameForCreate, printLayout) {\n super();\n this.rowNode = rowNode;\n this.useAnimationFrameForCreate = useAnimationFrameForCreate;\n this.printLayout = printLayout;\n this.allRowGuis = [];\n this.active = true;\n this.centerCellCtrls = { list: [], map: {} };\n this.leftCellCtrls = { list: [], map: {} };\n this.rightCellCtrls = { list: [], map: {} };\n this.slideInAnimation = {\n left: false,\n center: false,\n right: false,\n fullWidth: false\n };\n this.fadeInAnimation = {\n left: false,\n center: false,\n right: false,\n fullWidth: false\n };\n this.rowDragComps = [];\n this.lastMouseDownOnDragger = false;\n this.emptyStyle = {};\n this.updateColumnListsPending = false;\n this.rowId = null;\n /** sanitised */\n this.businessKey = null;\n this.beans = beans;\n this.gos = beans.gos;\n this.paginationPage = beans.pagination?.getCurrentPage() ?? 0;\n this.suppressRowTransform = this.gos.get(\"suppressRowTransform\");\n this.instanceId = rowNode.id + \"-\" + instanceIdSequence3++;\n this.rowId = _escapeString(rowNode.id);\n this.initRowBusinessKey();\n this.rowFocused = beans.focusSvc.isRowFocused(this.rowNode.rowIndex, this.rowNode.rowPinned);\n this.rowLevel = calculateRowLevel(this.rowNode);\n this.setRowType();\n this.setAnimateFlags(animateIn);\n this.rowStyles = this.processStylesFromGridOptions();\n this.addListeners();\n }\n initRowBusinessKey() {\n this.businessKeyForNodeFunc = this.gos.get(\"getBusinessKeyForNode\");\n this.updateRowBusinessKey();\n }\n updateRowBusinessKey() {\n if (typeof this.businessKeyForNodeFunc !== \"function\") {\n return;\n }\n const businessKey = this.businessKeyForNodeFunc(this.rowNode);\n this.businessKey = _escapeString(businessKey);\n }\n updateGui(containerType, gui) {\n if (containerType === \"left\") {\n this.leftGui = gui;\n } else if (containerType === \"right\") {\n this.rightGui = gui;\n } else if (containerType === \"fullWidth\") {\n this.fullWidthGui = gui;\n } else {\n this.centerGui = gui;\n }\n }\n setComp(rowComp, element, containerType, compBean) {\n compBean = setupCompBean(this, this.beans.context, compBean);\n const gui = { rowComp, element, containerType, compBean };\n this.allRowGuis.push(gui);\n this.updateGui(containerType, gui);\n this.initialiseRowComp(gui);\n const isSsrmLoadingRow = this.rowType === \"FullWidthLoading\" || this.rowNode.stub;\n if (!isSsrmLoadingRow && !this.rowNode.rowPinned) {\n this.beans.rowRenderer.dispatchFirstDataRenderedEvent();\n }\n }\n unsetComp(containerType) {\n this.allRowGuis = this.allRowGuis.filter((rowGui) => rowGui.containerType !== containerType);\n this.updateGui(containerType, void 0);\n }\n isCacheable() {\n return this.rowType === \"FullWidthDetail\" && this.gos.get(\"keepDetailRows\");\n }\n setCached(cached) {\n const displayValue = cached ? \"none\" : \"\";\n this.allRowGuis.forEach((rg) => rg.element.style.display = displayValue);\n }\n initialiseRowComp(gui) {\n const gos = this.gos;\n this.onSuppressCellFocusChanged(this.beans.gos.get(\"suppressCellFocus\"));\n this.listenOnDomOrder(gui);\n this.onRowHeightChanged(gui);\n this.updateRowIndexes(gui);\n this.setFocusedClasses(gui);\n this.setStylesFromGridOptions(false, gui);\n if (_isRowSelection(gos) && this.rowNode.selectable) {\n this.onRowSelected(gui);\n }\n this.updateColumnLists(!this.useAnimationFrameForCreate);\n const comp = gui.rowComp;\n const initialRowClasses = this.getInitialRowClasses(gui.containerType);\n initialRowClasses.forEach((name) => comp.addOrRemoveCssClass(name, true));\n this.executeSlideAndFadeAnimations(gui);\n if (this.rowNode.group) {\n _setAriaExpanded(gui.element, this.rowNode.expanded == true);\n }\n this.setRowCompRowId(comp);\n this.setRowCompRowBusinessKey(comp);\n _setDomData(gos, gui.element, DOM_DATA_KEY_ROW_CTRL, this);\n gui.compBean.addDestroyFunc(() => _setDomData(gos, gui.element, DOM_DATA_KEY_ROW_CTRL, null));\n if (this.useAnimationFrameForCreate) {\n this.beans.animationFrameSvc.createTask(\n this.addHoverFunctionality.bind(this, gui),\n this.rowNode.rowIndex,\n \"createTasksP2\"\n );\n } else {\n this.addHoverFunctionality(gui);\n }\n if (this.isFullWidth()) {\n this.setupFullWidth(gui);\n }\n if (gos.get(\"rowDragEntireRow\")) {\n this.addRowDraggerToRow(gui);\n }\n if (this.useAnimationFrameForCreate) {\n this.beans.animationFrameSvc.addDestroyTask(() => {\n if (!this.isAlive()) {\n return;\n }\n gui.rowComp.addOrRemoveCssClass(\"ag-after-created\", true);\n });\n }\n this.executeProcessRowPostCreateFunc();\n }\n setRowCompRowBusinessKey(comp) {\n if (this.businessKey == null) {\n return;\n }\n comp.setRowBusinessKey(this.businessKey);\n }\n setRowCompRowId(comp) {\n const rowId = _escapeString(this.rowNode.id);\n this.rowId = rowId;\n if (rowId == null) {\n return;\n }\n comp.setRowId(rowId);\n }\n executeSlideAndFadeAnimations(gui) {\n const { containerType } = gui;\n const shouldSlide = this.slideInAnimation[containerType];\n if (shouldSlide) {\n _executeNextVMTurn(() => {\n this.onTopChanged();\n });\n this.slideInAnimation[containerType] = false;\n }\n const shouldFade = this.fadeInAnimation[containerType];\n if (shouldFade) {\n _executeNextVMTurn(() => {\n gui.rowComp.addOrRemoveCssClass(\"ag-opacity-zero\", false);\n });\n this.fadeInAnimation[containerType] = false;\n }\n }\n addRowDraggerToRow(gui) {\n const rowDragComp = this.beans.rowDragSvc?.createRowDragCompForRow(this.rowNode, gui.element);\n if (!rowDragComp) {\n return;\n }\n const rowDragBean = this.createBean(rowDragComp, this.beans.context);\n this.rowDragComps.push(rowDragBean);\n gui.compBean.addDestroyFunc(() => {\n this.rowDragComps = this.rowDragComps.filter((r) => r !== rowDragBean);\n this.destroyBean(rowDragBean, this.beans.context);\n });\n }\n setupFullWidth(gui) {\n const pinned = this.getPinnedForContainer(gui.containerType);\n const compDetails = this.createFullWidthCompDetails(gui.element, pinned);\n gui.rowComp.showFullWidth(compDetails);\n }\n getFullWidthCellRenderers() {\n if (this.gos.get(\"embedFullWidthRows\")) {\n return this.allRowGuis.map((gui) => gui?.rowComp?.getFullWidthCellRenderer());\n }\n return [this.fullWidthGui?.rowComp?.getFullWidthCellRenderer()];\n }\n executeProcessRowPostCreateFunc() {\n const func = this.gos.getCallback(\"processRowPostCreate\");\n if (!func || !this.areAllContainersReady()) {\n return;\n }\n const params = {\n // areAllContainersReady asserts that centerGui is not null\n eRow: this.centerGui.element,\n ePinnedLeftRow: this.leftGui ? this.leftGui.element : void 0,\n ePinnedRightRow: this.rightGui ? this.rightGui.element : void 0,\n node: this.rowNode,\n rowIndex: this.rowNode.rowIndex,\n addRenderedRowListener: this.addEventListener.bind(this)\n };\n func(params);\n }\n areAllContainersReady() {\n const {\n leftGui,\n centerGui,\n rightGui,\n beans: { visibleCols }\n } = this;\n const isLeftReady = !!leftGui || !visibleCols.isPinningLeft();\n const isCenterReady = !!centerGui;\n const isRightReady = !!rightGui || !visibleCols.isPinningRight();\n return isLeftReady && isCenterReady && isRightReady;\n }\n isNodeFullWidthCell() {\n if (this.rowNode.detail) {\n return true;\n }\n const isFullWidthCellFunc = this.beans.gos.getCallback(\"isFullWidthRow\");\n return isFullWidthCellFunc ? isFullWidthCellFunc({ rowNode: this.rowNode }) : false;\n }\n setRowType() {\n const isStub = this.rowNode.stub && !this.gos.get(\"suppressServerSideFullWidthLoadingRow\") && !this.gos.get(\"groupHideOpenParents\");\n const isFullWidthCell = this.isNodeFullWidthCell();\n const isDetailCell = this.gos.get(\"masterDetail\") && this.rowNode.detail;\n const pivotMode = this.beans.colModel.isPivotMode();\n const isGroupRow = !!this.rowNode.group && !this.rowNode.footer;\n const isFullWidthGroup = isGroupRow && _isGroupUseEntireRow(this.gos, pivotMode);\n if (isStub) {\n this.rowType = \"FullWidthLoading\";\n } else if (isDetailCell) {\n this.rowType = \"FullWidthDetail\";\n } else if (isFullWidthCell) {\n this.rowType = \"FullWidth\";\n } else if (isFullWidthGroup) {\n this.rowType = \"FullWidthGroup\";\n } else {\n this.rowType = \"Normal\";\n }\n }\n updateColumnLists(suppressAnimationFrame = false, useFlushSync = false) {\n if (this.isFullWidth()) {\n return;\n }\n const { animationFrameSvc } = this.beans;\n const noAnimation = !animationFrameSvc || suppressAnimationFrame || this.gos.get(\"suppressAnimationFrame\") || this.printLayout;\n if (noAnimation) {\n this.updateColumnListsImpl(useFlushSync);\n return;\n }\n if (this.updateColumnListsPending) {\n return;\n }\n animationFrameSvc.createTask(\n () => {\n if (!this.active) {\n return;\n }\n this.updateColumnListsImpl(true);\n },\n this.rowNode.rowIndex,\n \"createTasksP1\"\n );\n this.updateColumnListsPending = true;\n }\n /**\n * Overridden by SpannedRowCtrl\n */\n getNewCellCtrl(col) {\n const isCellSpan = this.beans.rowSpanSvc?.isCellSpanning(col, this.rowNode);\n if (isCellSpan) {\n return void 0;\n }\n return new CellCtrl(col, this.rowNode, this.beans, this);\n }\n /**\n * Overridden by SpannedRowCtrl, if span context changes cell needs rebuilt\n */\n shouldRecreateCellCtrl(cell) {\n return !!this.beans.rowSpanSvc?.isCellSpanning(cell.column, this.rowNode);\n }\n createCellCtrls(prev, cols, pinned = null) {\n const res = {\n list: [],\n map: {}\n };\n const addCell = (colInstanceId, cellCtrl, index) => {\n if (index != null) {\n res.list.splice(index, 0, cellCtrl);\n } else {\n res.list.push(cellCtrl);\n }\n res.map[colInstanceId] = cellCtrl;\n };\n const colsFromPrev = [];\n for (const col of cols) {\n const colInstanceId = col.getInstanceId();\n let cellCtrl = prev.map[colInstanceId];\n if (cellCtrl && this.shouldRecreateCellCtrl(cellCtrl)) {\n cellCtrl.destroy();\n cellCtrl = void 0;\n }\n if (!cellCtrl) {\n cellCtrl = this.getNewCellCtrl(col);\n }\n if (!cellCtrl) {\n continue;\n }\n addCell(colInstanceId, cellCtrl);\n }\n for (const prevCellCtrl of prev.list) {\n const colInstanceId = prevCellCtrl.column.getInstanceId();\n const cellInResult = res.map[colInstanceId] != null;\n if (cellInResult) {\n continue;\n }\n const keepCell = !this.isCellEligibleToBeRemoved(prevCellCtrl, pinned);\n if (keepCell) {\n colsFromPrev.push([colInstanceId, prevCellCtrl]);\n } else {\n prevCellCtrl.destroy();\n }\n }\n if (colsFromPrev.length) {\n for (const [colInstanceId, cellCtrl] of colsFromPrev) {\n const index = res.list.findIndex((ctrl) => ctrl.column.getLeft() > cellCtrl.column.getLeft());\n const normalisedIndex = index === -1 ? void 0 : Math.max(index - 1, 0);\n addCell(colInstanceId, cellCtrl, normalisedIndex);\n }\n }\n return res;\n }\n updateColumnListsImpl(useFlushSync) {\n this.updateColumnListsPending = false;\n this.createAllCellCtrls();\n this.setCellCtrls(useFlushSync);\n }\n setCellCtrls(useFlushSync) {\n this.allRowGuis.forEach((item) => {\n const cellControls = this.getCellCtrlsForContainer(item.containerType);\n item.rowComp.setCellCtrls(cellControls, useFlushSync);\n });\n }\n getCellCtrlsForContainer(containerType) {\n switch (containerType) {\n case \"left\":\n return this.leftCellCtrls.list;\n case \"right\":\n return this.rightCellCtrls.list;\n case \"fullWidth\":\n return [];\n case \"center\":\n return this.centerCellCtrls.list;\n }\n }\n createAllCellCtrls() {\n const colViewport = this.beans.colViewport;\n const presentedColsService = this.beans.visibleCols;\n if (this.printLayout) {\n this.centerCellCtrls = this.createCellCtrls(this.centerCellCtrls, presentedColsService.allCols);\n this.leftCellCtrls = { list: [], map: {} };\n this.rightCellCtrls = { list: [], map: {} };\n } else {\n const centerCols = colViewport.getColsWithinViewport(this.rowNode);\n this.centerCellCtrls = this.createCellCtrls(this.centerCellCtrls, centerCols);\n const leftCols = presentedColsService.getLeftColsForRow(this.rowNode);\n this.leftCellCtrls = this.createCellCtrls(this.leftCellCtrls, leftCols, \"left\");\n const rightCols = presentedColsService.getRightColsForRow(this.rowNode);\n this.rightCellCtrls = this.createCellCtrls(this.rightCellCtrls, rightCols, \"right\");\n }\n }\n isCellEligibleToBeRemoved(cellCtrl, nextContainerPinned) {\n const REMOVE_CELL = true;\n const KEEP_CELL = false;\n const { column } = cellCtrl;\n if (column.getPinned() != nextContainerPinned) {\n return REMOVE_CELL;\n }\n const { editing, cellPosition } = cellCtrl;\n const { focusSvc, visibleCols } = this.beans;\n const focused = focusSvc.isCellFocused(cellPosition);\n const mightWantToKeepCell = editing || focused;\n if (mightWantToKeepCell) {\n const displayedColumns = visibleCols.allCols;\n const cellStillDisplayed = displayedColumns.indexOf(column) >= 0;\n return cellStillDisplayed ? KEEP_CELL : REMOVE_CELL;\n }\n return REMOVE_CELL;\n }\n getDomOrder() {\n const isEnsureDomOrder = this.gos.get(\"ensureDomOrder\");\n return isEnsureDomOrder || _isDomLayout(this.gos, \"print\");\n }\n listenOnDomOrder(gui) {\n const listener = () => {\n gui.rowComp.setDomOrder(this.getDomOrder());\n };\n gui.compBean.addManagedPropertyListeners([\"domLayout\", \"ensureDomOrder\"], listener);\n }\n setAnimateFlags(animateIn) {\n if (this.rowNode.sticky || !animateIn) {\n return;\n }\n const oldRowTopExists = _exists(this.rowNode.oldRowTop);\n const { visibleCols } = this.beans;\n const pinningLeft = visibleCols.isPinningLeft();\n const pinningRight = visibleCols.isPinningRight();\n if (oldRowTopExists) {\n const { slideInAnimation } = this;\n if (this.isFullWidth() && !this.gos.get(\"embedFullWidthRows\")) {\n slideInAnimation.fullWidth = true;\n return;\n }\n slideInAnimation.center = true;\n slideInAnimation.left = pinningLeft;\n slideInAnimation.right = pinningRight;\n } else {\n const { fadeInAnimation } = this;\n if (this.isFullWidth() && !this.gos.get(\"embedFullWidthRows\")) {\n fadeInAnimation.fullWidth = true;\n return;\n }\n fadeInAnimation.center = true;\n fadeInAnimation.left = pinningLeft;\n fadeInAnimation.right = pinningRight;\n }\n }\n isFullWidth() {\n return this.rowType !== \"Normal\";\n }\n refreshFullWidth() {\n const tryRefresh = (gui, pinned) => {\n if (!gui) {\n return true;\n }\n return gui.rowComp.refreshFullWidth(() => {\n const compDetails = this.createFullWidthCompDetails(gui.element, pinned);\n return compDetails.params;\n });\n };\n const fullWidthSuccess = tryRefresh(this.fullWidthGui, null);\n const centerSuccess = tryRefresh(this.centerGui, null);\n const leftSuccess = tryRefresh(this.leftGui, \"left\");\n const rightSuccess = tryRefresh(this.rightGui, \"right\");\n const allFullWidthRowsRefreshed = fullWidthSuccess && centerSuccess && leftSuccess && rightSuccess;\n return allFullWidthRowsRefreshed;\n }\n addListeners() {\n this.addManagedListeners(this.rowNode, {\n heightChanged: () => this.onRowHeightChanged(),\n rowSelected: () => this.onRowSelected(),\n rowIndexChanged: this.onRowIndexChanged.bind(this),\n topChanged: this.onTopChanged.bind(this),\n ...this.beans.expansionSvc?.getRowExpandedListeners(this) ?? {}\n });\n if (this.rowNode.detail) {\n this.addManagedListeners(this.rowNode.parent, { dataChanged: this.onRowNodeDataChanged.bind(this) });\n }\n this.addManagedListeners(this.rowNode, {\n dataChanged: this.onRowNodeDataChanged.bind(this),\n cellChanged: this.postProcessCss.bind(this),\n rowHighlightChanged: this.onRowNodeHighlightChanged.bind(this),\n draggingChanged: this.postProcessRowDragging.bind(this),\n uiLevelChanged: this.onUiLevelChanged.bind(this)\n });\n this.addManagedListeners(this.beans.eventSvc, {\n paginationPixelOffsetChanged: this.onPaginationPixelOffsetChanged.bind(this),\n heightScaleChanged: this.onTopChanged.bind(this),\n displayedColumnsChanged: this.onDisplayedColumnsChanged.bind(this),\n virtualColumnsChanged: this.onVirtualColumnsChanged.bind(this),\n cellFocused: this.onCellFocusChanged.bind(this),\n cellFocusCleared: this.onCellFocusChanged.bind(this),\n paginationChanged: this.onPaginationChanged.bind(this),\n modelUpdated: this.refreshFirstAndLastRowStyles.bind(this),\n columnMoved: () => this.updateColumnLists()\n });\n if (this.beans.rowSpanSvc) {\n this.addManagedListeners(this.beans.rowSpanSvc, {\n spannedCellsUpdated: ({ pinned }) => {\n if (pinned && !this.rowNode.rowPinned) {\n return;\n }\n this.updateColumnLists();\n }\n });\n }\n this.addDestroyFunc(() => {\n this.rowDragComps = this.destroyBeans(this.rowDragComps, this.beans.context);\n this.tooltipFeature = this.destroyBean(this.tooltipFeature, this.beans.context);\n });\n this.addManagedPropertyListeners(\n [\"rowStyle\", \"getRowStyle\", \"rowClass\", \"getRowClass\", \"rowClassRules\"],\n this.postProcessCss.bind(this)\n );\n this.addManagedPropertyListener(\"rowDragEntireRow\", () => {\n const useRowDragEntireRow = this.gos.get(\"rowDragEntireRow\");\n if (useRowDragEntireRow) {\n this.allRowGuis.forEach((gui) => {\n this.addRowDraggerToRow(gui);\n });\n return;\n }\n this.rowDragComps = this.destroyBeans(this.rowDragComps, this.beans.context);\n });\n this.addListenersForCellComps();\n }\n addListenersForCellComps() {\n this.addManagedListeners(this.rowNode, {\n rowIndexChanged: () => {\n this.getAllCellCtrls().forEach((cellCtrl) => cellCtrl.onRowIndexChanged());\n },\n cellChanged: (event) => {\n this.getAllCellCtrls().forEach((cellCtrl) => cellCtrl.onCellChanged(event));\n }\n });\n }\n onRowNodeDataChanged(event) {\n const fullWidthChanged = this.isFullWidth() !== !!this.isNodeFullWidthCell();\n if (fullWidthChanged) {\n this.beans.rowRenderer.redrawRow(this.rowNode);\n return;\n }\n if (this.isFullWidth()) {\n const refresh = this.refreshFullWidth();\n if (!refresh) {\n this.beans.rowRenderer.redrawRow(this.rowNode);\n }\n return;\n }\n this.getAllCellCtrls().forEach(\n (cellCtrl) => cellCtrl.refreshCell({\n suppressFlash: !event.update,\n newData: !event.update\n })\n );\n this.allRowGuis.forEach((gui) => {\n this.setRowCompRowId(gui.rowComp);\n this.updateRowBusinessKey();\n this.setRowCompRowBusinessKey(gui.rowComp);\n });\n this.onRowSelected();\n this.postProcessCss();\n }\n postProcessCss() {\n this.setStylesFromGridOptions(true);\n this.postProcessClassesFromGridOptions();\n this.postProcessRowClassRules();\n this.postProcessRowDragging();\n }\n onRowNodeHighlightChanged() {\n const highlighted = this.rowNode.highlighted;\n this.allRowGuis.forEach((gui) => {\n const aboveOn = highlighted === \"Above\";\n const belowOn = highlighted === \"Below\";\n gui.rowComp.addOrRemoveCssClass(\"ag-row-highlight-above\", aboveOn);\n gui.rowComp.addOrRemoveCssClass(\"ag-row-highlight-below\", belowOn);\n });\n }\n postProcessRowDragging() {\n const dragging = this.rowNode.dragging;\n this.allRowGuis.forEach((gui) => gui.rowComp.addOrRemoveCssClass(\"ag-row-dragging\", dragging));\n }\n verifyCells() {\n this.onDisplayedColumnsChanged();\n }\n onDisplayedColumnsChanged() {\n this.updateColumnLists(true);\n this.beans.rowAutoHeight?.requestCheckAutoHeight();\n }\n onVirtualColumnsChanged() {\n this.updateColumnLists(false, true);\n }\n getRowPosition() {\n return {\n rowPinned: _makeNull(this.rowNode.rowPinned),\n rowIndex: this.rowNode.rowIndex\n };\n }\n onKeyboardNavigate(keyboardEvent) {\n const groupInfo = this.findFullWidthInfoForEvent(keyboardEvent);\n if (!groupInfo) {\n return;\n }\n const { rowGui, column } = groupInfo;\n const currentFullWidthContainer = rowGui.element;\n const isFullWidthContainerFocused = currentFullWidthContainer === keyboardEvent.target;\n if (!isFullWidthContainerFocused) {\n return;\n }\n const node = this.rowNode;\n const { focusSvc, navigation } = this.beans;\n const lastFocusedCell = focusSvc.getFocusedCell();\n const cellPosition = {\n rowIndex: node.rowIndex,\n rowPinned: node.rowPinned,\n column: lastFocusedCell?.column ?? column\n };\n navigation?.navigateToNextCell(keyboardEvent, keyboardEvent.key, cellPosition, true);\n keyboardEvent.preventDefault();\n }\n onTabKeyDown(keyboardEvent) {\n if (keyboardEvent.defaultPrevented || _isStopPropagationForAgGrid(keyboardEvent)) {\n return;\n }\n const currentFullWidthComp = this.allRowGuis.find(\n (c) => c.element.contains(keyboardEvent.target)\n );\n const currentFullWidthContainer = currentFullWidthComp ? currentFullWidthComp.element : null;\n const isFullWidthContainerFocused = currentFullWidthContainer === keyboardEvent.target;\n const activeEl = _getActiveDomElement(this.beans);\n let isDetailGridCellFocused = false;\n if (currentFullWidthContainer && activeEl) {\n isDetailGridCellFocused = currentFullWidthContainer.contains(activeEl) && activeEl.classList.contains(\"ag-cell\");\n }\n let nextEl = null;\n if (!isFullWidthContainerFocused && !isDetailGridCellFocused) {\n nextEl = _findNextFocusableElement(this.beans, currentFullWidthContainer, false, keyboardEvent.shiftKey);\n }\n if (this.isFullWidth() && isFullWidthContainerFocused || !nextEl) {\n this.beans.navigation?.onTabKeyDown(this, keyboardEvent);\n }\n }\n getFullWidthElement() {\n if (this.fullWidthGui) {\n return this.fullWidthGui.element;\n }\n return null;\n }\n getRowYPosition() {\n const displayedEl = this.allRowGuis.find((el) => _isVisible(el.element))?.element;\n if (displayedEl) {\n return displayedEl.getBoundingClientRect().top;\n }\n return 0;\n }\n onSuppressCellFocusChanged(suppressCellFocus) {\n const tabIndex = this.isFullWidth() && suppressCellFocus ? void 0 : -1;\n this.allRowGuis.forEach((gui) => {\n _addOrRemoveAttribute(gui.element, \"tabindex\", tabIndex);\n });\n }\n onFullWidthRowFocused(event) {\n const node = this.rowNode;\n const isFocused = !event ? false : this.isFullWidth() && event.rowIndex === node.rowIndex && event.rowPinned == node.rowPinned;\n const element = this.fullWidthGui ? this.fullWidthGui.element : this.centerGui?.element;\n if (!element) {\n return;\n }\n element.classList.toggle(\"ag-full-width-focus\", isFocused);\n if (isFocused && event?.forceBrowserFocus) {\n element.focus({ preventScroll: true });\n }\n }\n recreateCell(cellCtrl) {\n this.centerCellCtrls = this.removeCellCtrl(this.centerCellCtrls, cellCtrl);\n this.leftCellCtrls = this.removeCellCtrl(this.leftCellCtrls, cellCtrl);\n this.rightCellCtrls = this.removeCellCtrl(this.rightCellCtrls, cellCtrl);\n cellCtrl.destroy();\n this.updateColumnLists();\n }\n removeCellCtrl(prev, cellCtrlToRemove) {\n const res = {\n list: [],\n map: {}\n };\n prev.list.forEach((cellCtrl) => {\n if (cellCtrl === cellCtrlToRemove) {\n return;\n }\n res.list.push(cellCtrl);\n res.map[cellCtrl.column.getInstanceId()] = cellCtrl;\n });\n return res;\n }\n onMouseEvent(eventName, mouseEvent) {\n switch (eventName) {\n case \"dblclick\":\n this.onRowDblClick(mouseEvent);\n break;\n case \"click\":\n this.onRowClick(mouseEvent);\n break;\n case \"touchstart\":\n case \"mousedown\":\n this.onRowMouseDown(mouseEvent);\n break;\n }\n }\n createRowEvent(type, domEvent) {\n const { rowNode } = this;\n return _addGridCommonParams(this.gos, {\n type,\n node: rowNode,\n data: rowNode.data,\n rowIndex: rowNode.rowIndex,\n rowPinned: rowNode.rowPinned,\n event: domEvent\n });\n }\n createRowEventWithSource(type, domEvent) {\n const event = this.createRowEvent(type, domEvent);\n event.source = this;\n return event;\n }\n onRowDblClick(mouseEvent) {\n if (_isStopPropagationForAgGrid(mouseEvent)) {\n return;\n }\n this.beans.eventSvc.dispatchEvent(this.createRowEventWithSource(\"rowDoubleClicked\", mouseEvent));\n }\n findFullWidthInfoForEvent(event) {\n if (!event) {\n return;\n }\n const rowGui = this.findFullWidthRowGui(event.target);\n const column = this.getColumnForFullWidth(rowGui);\n if (!rowGui || !column) {\n return;\n }\n return { rowGui, column };\n }\n findFullWidthRowGui(target) {\n return this.allRowGuis.find((c) => c.element.contains(target));\n }\n getColumnForFullWidth(fullWidthRowGui) {\n const { visibleCols } = this.beans;\n switch (fullWidthRowGui?.containerType) {\n case \"center\":\n return visibleCols.centerCols[0];\n case \"left\":\n return visibleCols.leftCols[0];\n case \"right\":\n return visibleCols.rightCols[0];\n default:\n return visibleCols.allCols[0];\n }\n }\n onRowMouseDown(mouseEvent) {\n this.lastMouseDownOnDragger = _isElementChildOfClass(mouseEvent.target, \"ag-row-drag\", 3);\n if (!this.isFullWidth()) {\n return;\n }\n const node = this.rowNode;\n const { rangeSvc, focusSvc } = this.beans;\n rangeSvc?.removeAllCellRanges();\n const groupInfo = this.findFullWidthInfoForEvent(mouseEvent);\n if (!groupInfo) {\n return;\n }\n const { rowGui, column } = groupInfo;\n const element = rowGui.element;\n const target = mouseEvent.target;\n let forceBrowserFocus = mouseEvent.defaultPrevented || _isBrowserSafari();\n if (element && element.contains(target) && _isFocusableFormField(target)) {\n forceBrowserFocus = false;\n }\n focusSvc.setFocusedCell({\n rowIndex: node.rowIndex,\n column,\n rowPinned: node.rowPinned,\n forceBrowserFocus\n });\n }\n onRowClick(mouseEvent) {\n const stop = _isStopPropagationForAgGrid(mouseEvent) || this.lastMouseDownOnDragger;\n if (stop) {\n return;\n }\n const { eventSvc, selectionSvc } = this.beans;\n eventSvc.dispatchEvent(this.createRowEventWithSource(\"rowClicked\", mouseEvent));\n selectionSvc?.handleSelectionEvent(mouseEvent, this.rowNode, \"rowClicked\");\n }\n setupDetailRowAutoHeight(eDetailGui) {\n if (this.rowType !== \"FullWidthDetail\") {\n return;\n }\n this.beans.masterDetailSvc?.setupDetailRowAutoHeight(this, eDetailGui);\n }\n createFullWidthCompDetails(eRow, pinned) {\n const { gos, rowNode } = this;\n const params = _addGridCommonParams(gos, {\n fullWidth: true,\n data: rowNode.data,\n node: rowNode,\n value: rowNode.key,\n valueFormatted: rowNode.key,\n // these need to be taken out, as part of 'afterAttached' now\n eGridCell: eRow,\n eParentOfValue: eRow,\n pinned,\n addRenderedRowListener: this.addEventListener.bind(this),\n // This is not on the type of ICellRendererParams\n registerRowDragger: (rowDraggerElement, dragStartPixels, value, suppressVisibilityChange) => this.addFullWidthRowDragging(rowDraggerElement, dragStartPixels, value, suppressVisibilityChange),\n setTooltip: (value, shouldDisplayTooltip) => {\n gos.assertModuleRegistered(\"Tooltip\", 3);\n this.refreshRowTooltip(value, shouldDisplayTooltip);\n }\n });\n const compFactory = this.beans.userCompFactory;\n switch (this.rowType) {\n case \"FullWidthDetail\":\n return _getFullWidthDetailCellRendererDetails(compFactory, params);\n case \"FullWidthGroup\":\n return _getFullWidthGroupCellRendererDetails(compFactory, params);\n case \"FullWidthLoading\":\n return _getFullWidthLoadingCellRendererDetails(compFactory, params);\n default:\n return _getFullWidthCellRendererDetails(compFactory, params);\n }\n }\n refreshRowTooltip(value, shouldDisplayTooltip) {\n if (!this.fullWidthGui) {\n return;\n }\n this.tooltipFeature = this.beans.tooltipSvc?.refreshRowTooltip(\n this.tooltipFeature,\n this,\n value,\n shouldDisplayTooltip\n );\n }\n addFullWidthRowDragging(rowDraggerElement, dragStartPixels, value = \"\", suppressVisibilityChange) {\n const { rowDragSvc, context } = this.beans;\n if (!rowDragSvc || !this.isFullWidth()) {\n return;\n }\n const rowDragComp = rowDragSvc.createRowDragComp(\n () => value,\n this.rowNode,\n void 0,\n rowDraggerElement,\n dragStartPixels,\n suppressVisibilityChange\n );\n this.createBean(rowDragComp, context);\n this.addDestroyFunc(() => {\n this.destroyBean(rowDragComp, context);\n });\n }\n onUiLevelChanged() {\n const newLevel = calculateRowLevel(this.rowNode);\n if (this.rowLevel != newLevel) {\n const classToAdd = \"ag-row-level-\" + newLevel;\n const classToRemove = \"ag-row-level-\" + this.rowLevel;\n this.allRowGuis.forEach((gui) => {\n gui.rowComp.addOrRemoveCssClass(classToAdd, true);\n gui.rowComp.addOrRemoveCssClass(classToRemove, false);\n });\n }\n this.rowLevel = newLevel;\n }\n isFirstRowOnPage() {\n return this.rowNode.rowIndex === this.beans.pageBounds.getFirstRow();\n }\n isLastRowOnPage() {\n return this.rowNode.rowIndex === this.beans.pageBounds.getLastRow();\n }\n refreshFirstAndLastRowStyles() {\n const newFirst = this.isFirstRowOnPage();\n const newLast = this.isLastRowOnPage();\n if (this.firstRowOnPage !== newFirst) {\n this.firstRowOnPage = newFirst;\n this.allRowGuis.forEach((gui) => gui.rowComp.addOrRemoveCssClass(\"ag-row-first\", newFirst));\n }\n if (this.lastRowOnPage !== newLast) {\n this.lastRowOnPage = newLast;\n this.allRowGuis.forEach((gui) => gui.rowComp.addOrRemoveCssClass(\"ag-row-last\", newLast));\n }\n }\n getAllCellCtrls() {\n if (this.leftCellCtrls.list.length === 0 && this.rightCellCtrls.list.length === 0) {\n return this.centerCellCtrls.list;\n }\n const res = [...this.centerCellCtrls.list, ...this.leftCellCtrls.list, ...this.rightCellCtrls.list];\n return res;\n }\n postProcessClassesFromGridOptions() {\n const cssClasses = [];\n this.beans.rowStyleSvc?.processClassesFromGridOptions(cssClasses, this.rowNode);\n if (!cssClasses.length) {\n return;\n }\n cssClasses.forEach((classStr) => {\n this.allRowGuis.forEach((c) => c.rowComp.addOrRemoveCssClass(classStr, true));\n });\n }\n postProcessRowClassRules() {\n this.beans.rowStyleSvc?.processRowClassRules(\n this.rowNode,\n (className) => {\n this.allRowGuis.forEach((gui) => gui.rowComp.addOrRemoveCssClass(className, true));\n },\n (className) => {\n this.allRowGuis.forEach((gui) => gui.rowComp.addOrRemoveCssClass(className, false));\n }\n );\n }\n setStylesFromGridOptions(updateStyles, gui) {\n if (updateStyles) {\n this.rowStyles = this.processStylesFromGridOptions();\n }\n this.forEachGui(gui, (gui2) => gui2.rowComp.setUserStyles(this.rowStyles));\n }\n getPinnedForContainer(rowContainerType) {\n if (rowContainerType === \"left\" || rowContainerType === \"right\") {\n return rowContainerType;\n }\n return null;\n }\n getInitialRowClasses(rowContainerType) {\n const pinned = this.getPinnedForContainer(rowContainerType);\n const fullWidthRow = this.isFullWidth();\n const { rowNode, beans } = this;\n const classes = [];\n classes.push(\"ag-row\");\n classes.push(this.rowFocused ? \"ag-row-focus\" : \"ag-row-no-focus\");\n if (this.fadeInAnimation[rowContainerType]) {\n classes.push(\"ag-opacity-zero\");\n }\n classes.push(rowNode.rowIndex % 2 === 0 ? \"ag-row-even\" : \"ag-row-odd\");\n if (rowNode.isRowPinned()) {\n classes.push(\"ag-row-pinned\");\n }\n if (rowNode.isSelected()) {\n classes.push(\"ag-row-selected\");\n }\n if (rowNode.footer) {\n classes.push(\"ag-row-footer\");\n }\n classes.push(\"ag-row-level-\" + this.rowLevel);\n if (rowNode.stub) {\n classes.push(\"ag-row-loading\");\n }\n if (fullWidthRow) {\n classes.push(\"ag-full-width-row\");\n }\n beans.expansionSvc?.addExpandedCss(classes, rowNode);\n if (rowNode.dragging) {\n classes.push(\"ag-row-dragging\");\n }\n const { rowStyleSvc } = beans;\n if (rowStyleSvc) {\n rowStyleSvc.processClassesFromGridOptions(classes, rowNode);\n rowStyleSvc.preProcessRowClassRules(classes, rowNode);\n }\n classes.push(this.printLayout ? \"ag-row-position-relative\" : \"ag-row-position-absolute\");\n if (this.isFirstRowOnPage()) {\n classes.push(\"ag-row-first\");\n }\n if (this.isLastRowOnPage()) {\n classes.push(\"ag-row-last\");\n }\n if (fullWidthRow) {\n if (pinned === \"left\") {\n classes.push(\"ag-cell-last-left-pinned\");\n }\n if (pinned === \"right\") {\n classes.push(\"ag-cell-first-right-pinned\");\n }\n }\n return classes;\n }\n processStylesFromGridOptions() {\n return this.beans.rowStyleSvc?.processStylesFromGridOptions(this.rowNode) ?? this.emptyStyle;\n }\n onRowSelected(gui) {\n this.beans.selectionSvc?.onRowCtrlSelected(\n this,\n (gui2) => {\n if (gui2 === this.centerGui || gui2 === this.fullWidthGui) {\n this.announceDescription();\n }\n },\n gui\n );\n }\n announceDescription() {\n this.beans.selectionSvc?.announceAriaRowSelection(this.rowNode);\n }\n addHoverFunctionality(eGui) {\n if (!this.active) {\n return;\n }\n const { element, compBean } = eGui;\n const { rowNode, beans, gos } = this;\n compBean.addManagedListeners(element, {\n mouseenter: () => rowNode.dispatchRowEvent(\"mouseEnter\"),\n mouseleave: () => rowNode.dispatchRowEvent(\"mouseLeave\")\n });\n compBean.addManagedListeners(rowNode, {\n mouseEnter: () => {\n if (!beans.dragSvc?.dragging && !gos.get(\"suppressRowHoverHighlight\")) {\n element.classList.add(\"ag-row-hover\");\n rowNode.setHovered(true);\n }\n },\n mouseLeave: () => {\n this.resetHoveredStatus(element);\n }\n });\n }\n resetHoveredStatus(el) {\n const elements = el ? [el] : this.allRowGuis.map((gui) => gui.element);\n for (const element of elements) {\n element.classList.remove(\"ag-row-hover\");\n }\n this.rowNode.setHovered(false);\n }\n // for animation, we don't want to animate entry or exit to a very far away pixel,\n // otherwise the row would move so fast, it would appear to disappear. so this method\n // moves the row closer to the viewport if it is far away, so the row slide in / out\n // at a speed the user can see.\n roundRowTopToBounds(rowTop) {\n const range = this.beans.ctrlsSvc.getScrollFeature().getApproximateVScollPosition();\n const minPixel = this.applyPaginationOffset(range.top, true) - 100;\n const maxPixel = this.applyPaginationOffset(range.bottom, true) + 100;\n return Math.min(Math.max(minPixel, rowTop), maxPixel);\n }\n forEachGui(gui, callback) {\n if (gui) {\n callback(gui);\n } else {\n this.allRowGuis.forEach(callback);\n }\n }\n onRowHeightChanged(gui) {\n if (this.rowNode.rowHeight == null) {\n return;\n }\n const rowHeight = this.rowNode.rowHeight;\n const defaultRowHeight = this.beans.environment.getDefaultRowHeight();\n const isHeightFromFunc = _isGetRowHeightFunction(this.gos);\n const heightFromFunc = isHeightFromFunc ? _getRowHeightForNode(this.beans, this.rowNode).height : void 0;\n const lineHeight = heightFromFunc ? `${Math.min(defaultRowHeight, heightFromFunc) - 2}px` : void 0;\n this.forEachGui(gui, (gui2) => {\n gui2.element.style.height = `${rowHeight}px`;\n if (lineHeight) {\n gui2.element.style.setProperty(\"--ag-line-height\", lineHeight);\n }\n });\n }\n // note - this is NOT called by context, as we don't wire / unwire the CellComp for performance reasons.\n destroyFirstPass(suppressAnimation = false) {\n this.active = false;\n const { rowNode } = this;\n if (!suppressAnimation && _isAnimateRows(this.gos) && !rowNode.sticky) {\n const rowStillVisibleJustNotInViewport = rowNode.rowTop != null;\n if (rowStillVisibleJustNotInViewport) {\n const rowTop = this.roundRowTopToBounds(rowNode.rowTop);\n this.setRowTop(rowTop);\n } else {\n this.allRowGuis.forEach((gui) => gui.rowComp.addOrRemoveCssClass(\"ag-opacity-zero\", true));\n }\n }\n rowNode.setHovered(false);\n const event = this.createRowEvent(\"virtualRowRemoved\");\n this.dispatchLocalEvent(event);\n this.beans.eventSvc.dispatchEvent(event);\n super.destroy();\n }\n destroySecondPass() {\n this.allRowGuis.length = 0;\n this.beans.editSvc?.stopRowEditing(this);\n const destroyCellCtrls = (ctrls) => {\n ctrls.list.forEach((c) => c.destroy());\n return { list: [], map: {} };\n };\n this.centerCellCtrls = destroyCellCtrls(this.centerCellCtrls);\n this.leftCellCtrls = destroyCellCtrls(this.leftCellCtrls);\n this.rightCellCtrls = destroyCellCtrls(this.rightCellCtrls);\n }\n setFocusedClasses(gui) {\n this.forEachGui(gui, (gui2) => {\n gui2.rowComp.addOrRemoveCssClass(\"ag-row-focus\", this.rowFocused);\n gui2.rowComp.addOrRemoveCssClass(\"ag-row-no-focus\", !this.rowFocused);\n });\n }\n onCellFocusChanged() {\n const { focusSvc, editSvc } = this.beans;\n const rowFocused = focusSvc.isRowFocused(this.rowNode.rowIndex, this.rowNode.rowPinned);\n if (rowFocused !== this.rowFocused) {\n this.rowFocused = rowFocused;\n this.setFocusedClasses();\n }\n if (!rowFocused && this.editing) {\n editSvc?.stopRowEditing(this, false);\n }\n }\n onPaginationChanged() {\n const currentPage = this.beans.pagination?.getCurrentPage() ?? 0;\n if (this.paginationPage !== currentPage) {\n this.paginationPage = currentPage;\n this.onTopChanged();\n }\n this.refreshFirstAndLastRowStyles();\n }\n onTopChanged() {\n this.setRowTop(this.rowNode.rowTop);\n }\n onPaginationPixelOffsetChanged() {\n this.onTopChanged();\n }\n // applies pagination offset, eg if on second page, and page height is 500px, then removes\n // 500px from the top position, so a row with rowTop 600px is displayed at location 100px.\n // reverse will take the offset away rather than add.\n applyPaginationOffset(topPx, reverse = false) {\n if (this.rowNode.isRowPinned() || this.rowNode.sticky) {\n return topPx;\n }\n const pixelOffset = this.beans.pageBounds.getPixelOffset();\n const multiplier = reverse ? 1 : -1;\n return topPx + pixelOffset * multiplier;\n }\n setRowTop(pixels) {\n if (this.printLayout) {\n return;\n }\n if (_exists(pixels)) {\n const afterPaginationPixels = this.applyPaginationOffset(pixels);\n const skipScaling = this.rowNode.isRowPinned() || this.rowNode.sticky;\n const afterScalingPixels = skipScaling ? afterPaginationPixels : this.beans.rowContainerHeight.getRealPixelPosition(afterPaginationPixels);\n const topPx = `${afterScalingPixels}px`;\n this.setRowTopStyle(topPx);\n }\n }\n // the top needs to be set into the DOM element when the element is created, not updated afterwards.\n // otherwise the transition would not work, as it would be transitioning from zero (the unset value).\n // for example, suppose a row that is outside the viewport, then user does a filter to remove other rows\n // and this row now appears in the viewport, and the row moves up (ie it was under the viewport and not rendered,\n // but now is in the viewport) then a new RowComp is created, however it should have it's position initialised\n // to below the viewport, so the row will appear to animate up. if we didn't set the initial position at creation\n // time, the row would animate down (ie from position zero).\n getInitialRowTop(rowContainerType) {\n return this.suppressRowTransform ? this.getInitialRowTopShared(rowContainerType) : void 0;\n }\n getInitialTransform(rowContainerType) {\n return this.suppressRowTransform ? void 0 : `translateY(${this.getInitialRowTopShared(rowContainerType)})`;\n }\n getInitialRowTopShared(rowContainerType) {\n if (this.printLayout) {\n return \"\";\n }\n const rowNode = this.rowNode;\n let rowTop;\n if (rowNode.sticky) {\n rowTop = rowNode.stickyRowTop;\n } else {\n const pixels = this.slideInAnimation[rowContainerType] ? this.roundRowTopToBounds(rowNode.oldRowTop) : rowNode.rowTop;\n const afterPaginationPixels = this.applyPaginationOffset(pixels);\n rowTop = rowNode.isRowPinned() ? afterPaginationPixels : this.beans.rowContainerHeight.getRealPixelPosition(afterPaginationPixels);\n }\n return rowTop + \"px\";\n }\n setRowTopStyle(topPx) {\n this.allRowGuis.forEach(\n (gui) => this.suppressRowTransform ? gui.rowComp.setTop(topPx) : gui.rowComp.setTransform(`translateY(${topPx})`)\n );\n }\n getCellCtrl(column, skipColSpanSearch = false) {\n let res = null;\n this.getAllCellCtrls().forEach((cellCtrl) => {\n if (cellCtrl.column == column) {\n res = cellCtrl;\n }\n });\n if (res != null || skipColSpanSearch) {\n return res;\n }\n this.getAllCellCtrls().forEach((cellCtrl) => {\n if (cellCtrl.getColSpanningList().indexOf(column) >= 0) {\n res = cellCtrl;\n }\n });\n return res;\n }\n onRowIndexChanged() {\n if (this.rowNode.rowIndex != null) {\n this.onCellFocusChanged();\n this.updateRowIndexes();\n this.postProcessCss();\n }\n }\n updateRowIndexes(gui) {\n const rowIndexStr = this.rowNode.getRowIndexString();\n if (rowIndexStr === null) {\n return;\n }\n const headerRowCount = (this.beans.ctrlsSvc.getHeaderRowContainerCtrl()?.getRowCount() ?? 0) + (this.beans.filterManager?.getHeaderRowCount() ?? 0);\n const rowIsEven = this.rowNode.rowIndex % 2 === 0;\n const ariaRowIndex = headerRowCount + this.rowNode.rowIndex + 1;\n this.forEachGui(gui, (c) => {\n c.rowComp.setRowIndex(rowIndexStr);\n c.rowComp.addOrRemoveCssClass(\"ag-row-even\", rowIsEven);\n c.rowComp.addOrRemoveCssClass(\"ag-row-odd\", !rowIsEven);\n _setAriaRowIndex(c.element, ariaRowIndex);\n });\n }\n};\n\n// packages/ag-grid-community/src/utils/keyboard.ts\nfunction _isEventFromPrintableCharacter(event) {\n if (event.altKey || event.ctrlKey || event.metaKey) {\n return false;\n }\n const printableCharacter = event.key?.length === 1;\n return printableCharacter;\n}\nfunction _isUserSuppressingKeyboardEvent(gos, keyboardEvent, rowNode, column, editing) {\n const colDefFunc = column ? column.getColDef().suppressKeyboardEvent : void 0;\n if (!colDefFunc) {\n return false;\n }\n const params = _addGridCommonParams(gos, {\n event: keyboardEvent,\n editing,\n column,\n node: rowNode,\n data: rowNode.data,\n colDef: column.getColDef()\n });\n if (colDefFunc) {\n const colDefFuncResult = colDefFunc(params);\n if (colDefFuncResult) {\n return true;\n }\n }\n return false;\n}\n\n// packages/ag-grid-community/src/utils/selection.ts\nfunction _selectAllCells(beans) {\n const { pinnedRowModel, rowModel } = beans;\n const [isEmptyPinnedTop, isEmptyPinnedBottom] = [\n pinnedRowModel?.isEmpty(\"top\") ?? true,\n pinnedRowModel?.isEmpty(\"bottom\") ?? true\n ];\n const floatingStart = isEmptyPinnedTop ? null : \"top\";\n let floatingEnd;\n let rowEnd;\n if (isEmptyPinnedBottom) {\n floatingEnd = null;\n rowEnd = rowModel.getRowCount() - 1;\n } else {\n floatingEnd = \"bottom\";\n rowEnd = pinnedRowModel?.getPinnedBottomRowCount() ?? 0 - 1;\n }\n const { visibleCols, rangeSvc } = beans;\n const allDisplayedColumns = visibleCols.allCols;\n if (!rangeSvc || !allDisplayedColumns?.length) {\n return;\n }\n rangeSvc.setCellRange({\n rowStartIndex: 0,\n rowStartPinned: floatingStart,\n rowEndIndex: rowEnd,\n rowEndPinned: floatingEnd\n });\n}\n\n// packages/ag-grid-community/src/gridBodyComp/rowContainer/rowContainerEventsFeature.ts\nvar A_KEYCODE = 65;\nvar C_KEYCODE = 67;\nvar V_KEYCODE = 86;\nvar D_KEYCODE = 68;\nvar Z_KEYCODE = 90;\nvar Y_KEYCODE = 89;\nfunction _normaliseQwertyAzerty(keyboardEvent) {\n const { keyCode } = keyboardEvent;\n let code;\n switch (keyCode) {\n case A_KEYCODE:\n code = KeyCode.A;\n break;\n case C_KEYCODE:\n code = KeyCode.C;\n break;\n case V_KEYCODE:\n code = KeyCode.V;\n break;\n case D_KEYCODE:\n code = KeyCode.D;\n break;\n case Z_KEYCODE:\n code = KeyCode.Z;\n break;\n case Y_KEYCODE:\n code = KeyCode.Y;\n break;\n default:\n code = keyboardEvent.code;\n }\n return code;\n}\nvar RowContainerEventsFeature = class extends BeanStub {\n constructor(element) {\n super();\n this.element = element;\n }\n postConstruct() {\n this.addKeyboardListeners();\n this.addMouseListeners();\n this.beans.touchSvc?.mockRowContextMenu(this);\n }\n addKeyboardListeners() {\n const eventName = \"keydown\";\n const listener = this.processKeyboardEvent.bind(this, eventName);\n this.addManagedElementListeners(this.element, { [eventName]: listener });\n }\n addMouseListeners() {\n const mouseDownEvent = _isEventSupported(\"touchstart\") ? \"touchstart\" : \"mousedown\";\n const eventNames = [\"dblclick\", \"contextmenu\", \"mouseover\", \"mouseout\", \"click\", mouseDownEvent];\n eventNames.forEach((eventName) => {\n const listener = this.processMouseEvent.bind(this, eventName);\n this.addManagedElementListeners(this.element, { [eventName]: listener });\n });\n }\n processMouseEvent(eventName, mouseEvent) {\n if (!_isEventFromThisGrid(this.gos, mouseEvent) || _isStopPropagationForAgGrid(mouseEvent)) {\n return;\n }\n const { cellCtrl, rowCtrl } = this.getControlsForEventTarget(mouseEvent.target);\n if (eventName === \"contextmenu\") {\n if (cellCtrl?.column) {\n cellCtrl.dispatchCellContextMenuEvent(mouseEvent);\n }\n this.beans.contextMenuSvc?.handleContextMenuMouseEvent(mouseEvent, void 0, rowCtrl, cellCtrl);\n } else {\n if (cellCtrl) {\n cellCtrl.onMouseEvent(eventName, mouseEvent);\n }\n if (rowCtrl) {\n rowCtrl.onMouseEvent(eventName, mouseEvent);\n }\n }\n }\n getControlsForEventTarget(target) {\n const { gos } = this;\n return {\n cellCtrl: _getCellCtrlForEventTarget(gos, target),\n rowCtrl: _getCtrlForEventTarget(gos, target, DOM_DATA_KEY_ROW_CTRL)\n };\n }\n processKeyboardEvent(eventName, keyboardEvent) {\n const { cellCtrl, rowCtrl } = this.getControlsForEventTarget(keyboardEvent.target);\n if (keyboardEvent.defaultPrevented) {\n return;\n }\n if (cellCtrl) {\n this.processCellKeyboardEvent(cellCtrl, eventName, keyboardEvent);\n } else if (rowCtrl && rowCtrl.isFullWidth()) {\n this.processFullWidthRowKeyboardEvent(rowCtrl, eventName, keyboardEvent);\n }\n }\n processCellKeyboardEvent(cellCtrl, eventName, keyboardEvent) {\n const { rowNode, column, editing } = cellCtrl;\n const gridProcessingAllowed = !_isUserSuppressingKeyboardEvent(\n this.gos,\n keyboardEvent,\n rowNode,\n column,\n editing\n );\n if (gridProcessingAllowed) {\n if (eventName === \"keydown\") {\n const wasScrollKey = !editing && this.beans.navigation?.handlePageScrollingKey(keyboardEvent);\n if (!wasScrollKey) {\n cellCtrl.onKeyDown(keyboardEvent);\n }\n this.doGridOperations(keyboardEvent, cellCtrl.editing);\n if (_isEventFromPrintableCharacter(keyboardEvent)) {\n cellCtrl.processCharacter(keyboardEvent);\n }\n }\n }\n if (eventName === \"keydown\") {\n this.eventSvc.dispatchEvent(cellCtrl.createEvent(keyboardEvent, \"cellKeyDown\"));\n }\n }\n processFullWidthRowKeyboardEvent(rowComp, eventName, keyboardEvent) {\n const { rowNode } = rowComp;\n const { focusSvc, navigation } = this.beans;\n const focusedCell = focusSvc.getFocusedCell();\n const column = focusedCell && focusedCell.column;\n const gridProcessingAllowed = !_isUserSuppressingKeyboardEvent(this.gos, keyboardEvent, rowNode, column, false);\n if (gridProcessingAllowed) {\n const key = keyboardEvent.key;\n if (eventName === \"keydown\") {\n switch (key) {\n case KeyCode.PAGE_HOME:\n case KeyCode.PAGE_END:\n case KeyCode.PAGE_UP:\n case KeyCode.PAGE_DOWN:\n navigation?.handlePageScrollingKey(keyboardEvent, true);\n break;\n case KeyCode.UP:\n case KeyCode.DOWN:\n rowComp.onKeyboardNavigate(keyboardEvent);\n break;\n case KeyCode.TAB:\n rowComp.onTabKeyDown(keyboardEvent);\n break;\n default:\n }\n }\n }\n if (eventName === \"keydown\") {\n this.eventSvc.dispatchEvent(rowComp.createRowEvent(\"cellKeyDown\", keyboardEvent));\n }\n }\n doGridOperations(keyboardEvent, editing) {\n if (!keyboardEvent.ctrlKey && !keyboardEvent.metaKey) {\n return;\n }\n if (editing) {\n return;\n }\n if (!_isEventFromThisGrid(this.gos, keyboardEvent)) {\n return;\n }\n const keyCode = _normaliseQwertyAzerty(keyboardEvent);\n const { clipboardSvc, undoRedo } = this.beans;\n if (keyCode === KeyCode.A) {\n return this.onCtrlAndA(keyboardEvent);\n }\n if (keyCode === KeyCode.C) {\n return this.onCtrlAndC(clipboardSvc, keyboardEvent);\n }\n if (keyCode === KeyCode.D) {\n return this.onCtrlAndD(clipboardSvc, keyboardEvent);\n }\n if (keyCode === KeyCode.V) {\n return this.onCtrlAndV(clipboardSvc, keyboardEvent);\n }\n if (keyCode === KeyCode.X) {\n return this.onCtrlAndX(clipboardSvc, keyboardEvent);\n }\n if (keyCode === KeyCode.Y) {\n return this.onCtrlAndY(undoRedo);\n }\n if (keyCode === KeyCode.Z) {\n return this.onCtrlAndZ(undoRedo, keyboardEvent);\n }\n }\n onCtrlAndA(event) {\n const {\n beans: { rowModel, rangeSvc, selectionSvc },\n gos\n } = this;\n if (rangeSvc && _isCellSelectionEnabled(gos) && rowModel.isRowsToRender()) {\n _selectAllCells(this.beans);\n } else if (selectionSvc) {\n selectionSvc?.selectAllRowNodes({ source: \"keyboardSelectAll\", selectAll: _getSelectAll(gos) });\n }\n event.preventDefault();\n }\n onCtrlAndC(clipboardSvc, event) {\n if (!clipboardSvc || this.gos.get(\"enableCellTextSelection\")) {\n return;\n }\n const { cellCtrl, rowCtrl } = this.getControlsForEventTarget(event.target);\n if (cellCtrl?.editing || rowCtrl?.editing) {\n return;\n }\n event.preventDefault();\n clipboardSvc.copyToClipboard();\n }\n onCtrlAndX(clipboardSvc, event) {\n if (!clipboardSvc || this.gos.get(\"enableCellTextSelection\") || this.gos.get(\"suppressCutToClipboard\")) {\n return;\n }\n const { cellCtrl, rowCtrl } = this.getControlsForEventTarget(event.target);\n if (cellCtrl?.editing || rowCtrl?.editing) {\n return;\n }\n event.preventDefault();\n clipboardSvc.cutToClipboard(void 0, \"ui\");\n }\n onCtrlAndV(clipboardSvc, event) {\n const { cellCtrl, rowCtrl } = this.getControlsForEventTarget(event.target);\n if (cellCtrl?.editing || rowCtrl?.editing) {\n return;\n }\n if (clipboardSvc && !this.gos.get(\"suppressClipboardPaste\")) {\n clipboardSvc.pasteFromClipboard();\n }\n }\n onCtrlAndD(clipboardSvc, event) {\n if (clipboardSvc && !this.gos.get(\"suppressClipboardPaste\")) {\n clipboardSvc.copyRangeDown();\n }\n event.preventDefault();\n }\n onCtrlAndZ(undoRedo, event) {\n if (!this.gos.get(\"undoRedoCellEditing\") || !undoRedo) {\n return;\n }\n event.preventDefault();\n if (event.shiftKey) {\n undoRedo.redo(\"ui\");\n } else {\n undoRedo.undo(\"ui\");\n }\n }\n onCtrlAndY(undoRedo) {\n undoRedo?.redo(\"ui\");\n }\n};\n\n// packages/ag-grid-community/src/gridBodyComp/rowContainer/setHeightFeature.ts\nvar SetHeightFeature = class extends BeanStub {\n constructor(eContainer, eViewport) {\n super();\n this.eContainer = eContainer;\n this.eViewport = eViewport;\n }\n postConstruct() {\n this.addManagedEventListeners({\n rowContainerHeightChanged: this.onHeightChanged.bind(this, this.beans.rowContainerHeight)\n });\n }\n onHeightChanged(maxDivHeightScaler) {\n const height = maxDivHeightScaler.uiContainerHeight;\n const heightString = height != null ? `${height}px` : ``;\n this.eContainer.style.height = heightString;\n if (this.eViewport) {\n this.eViewport.style.height = heightString;\n }\n }\n};\n\n// packages/ag-grid-community/src/gridBodyComp/rowContainer/rowContainerCtrl.ts\nvar getTopRowCtrls = (r) => r.topRowCtrls;\nvar getStickyTopRowCtrls = (r) => r.getStickyTopRowCtrls();\nvar getStickyBottomRowCtrls = (r) => r.getStickyBottomRowCtrls();\nvar getBottomRowCtrls = (r) => r.bottomRowCtrls;\nvar getCentreRowCtrls = (r) => r.allRowCtrls;\nvar getSpannedTopRowCtrls = (r) => r.getCtrls(\"top\");\nvar getSpannedCenterRowCtrls = (r) => r.getCtrls(\"center\");\nvar getSpannedBottomRowCtrls = (r) => r.getCtrls(\"bottom\");\nvar ContainerCssClasses = {\n center: {\n type: \"center\",\n name: \"center-cols\",\n getRowCtrls: getCentreRowCtrls,\n getSpannedRowCtrls: getSpannedCenterRowCtrls\n },\n left: {\n type: \"left\",\n name: \"pinned-left-cols\",\n pinnedType: \"left\",\n getRowCtrls: getCentreRowCtrls,\n getSpannedRowCtrls: getSpannedCenterRowCtrls\n },\n right: {\n type: \"right\",\n name: \"pinned-right-cols\",\n pinnedType: \"right\",\n getRowCtrls: getCentreRowCtrls,\n getSpannedRowCtrls: getSpannedCenterRowCtrls\n },\n fullWidth: {\n type: \"fullWidth\",\n name: \"full-width\",\n fullWidth: true,\n getRowCtrls: getCentreRowCtrls\n },\n topCenter: {\n type: \"center\",\n name: \"floating-top\",\n getRowCtrls: getTopRowCtrls,\n getSpannedRowCtrls: getSpannedTopRowCtrls\n },\n topLeft: {\n type: \"left\",\n name: \"pinned-left-floating\",\n container: \"ag-pinned-left-floating-top\",\n pinnedType: \"left\",\n getRowCtrls: getTopRowCtrls,\n getSpannedRowCtrls: getSpannedTopRowCtrls\n },\n topRight: {\n type: \"right\",\n name: \"pinned-right-floating\",\n container: \"ag-pinned-right-floating-top\",\n pinnedType: \"right\",\n getRowCtrls: getTopRowCtrls,\n getSpannedRowCtrls: getSpannedTopRowCtrls\n },\n topFullWidth: {\n type: \"fullWidth\",\n name: \"floating-top-full-width\",\n fullWidth: true,\n getRowCtrls: getTopRowCtrls\n },\n stickyTopCenter: {\n type: \"center\",\n name: \"sticky-top\",\n getRowCtrls: getStickyTopRowCtrls\n },\n stickyTopLeft: {\n type: \"left\",\n name: \"pinned-left-sticky-top\",\n container: \"ag-pinned-left-sticky-top\",\n pinnedType: \"left\",\n getRowCtrls: getStickyTopRowCtrls\n },\n stickyTopRight: {\n type: \"right\",\n name: \"pinned-right-sticky-top\",\n container: \"ag-pinned-right-sticky-top\",\n pinnedType: \"right\",\n getRowCtrls: getStickyTopRowCtrls\n },\n stickyTopFullWidth: {\n type: \"fullWidth\",\n name: \"sticky-top-full-width\",\n fullWidth: true,\n getRowCtrls: getStickyTopRowCtrls\n },\n stickyBottomCenter: {\n type: \"center\",\n name: \"sticky-bottom\",\n getRowCtrls: getStickyBottomRowCtrls\n },\n stickyBottomLeft: {\n type: \"left\",\n name: \"pinned-left-sticky-bottom\",\n container: \"ag-pinned-left-sticky-bottom\",\n pinnedType: \"left\",\n getRowCtrls: getStickyBottomRowCtrls\n },\n stickyBottomRight: {\n type: \"right\",\n name: \"pinned-right-sticky-bottom\",\n container: \"ag-pinned-right-sticky-bottom\",\n pinnedType: \"right\",\n getRowCtrls: getStickyBottomRowCtrls\n },\n stickyBottomFullWidth: {\n type: \"fullWidth\",\n name: \"sticky-bottom-full-width\",\n fullWidth: true,\n getRowCtrls: getStickyBottomRowCtrls\n },\n bottomCenter: {\n type: \"center\",\n name: \"floating-bottom\",\n getRowCtrls: getBottomRowCtrls,\n getSpannedRowCtrls: getSpannedBottomRowCtrls\n },\n bottomLeft: {\n type: \"left\",\n name: \"pinned-left-floating-bottom\",\n container: \"ag-pinned-left-floating-bottom\",\n pinnedType: \"left\",\n getRowCtrls: getBottomRowCtrls,\n getSpannedRowCtrls: getSpannedBottomRowCtrls\n },\n bottomRight: {\n type: \"right\",\n name: \"pinned-right-floating-bottom\",\n container: \"ag-pinned-right-floating-bottom\",\n pinnedType: \"right\",\n getRowCtrls: getBottomRowCtrls,\n getSpannedRowCtrls: getSpannedBottomRowCtrls\n },\n bottomFullWidth: {\n type: \"fullWidth\",\n name: \"floating-bottom-full-width\",\n fullWidth: true,\n getRowCtrls: getBottomRowCtrls\n }\n};\nfunction _getRowViewportClass(name) {\n const options = _getRowContainerOptions(name);\n return `ag-${options.name}-viewport`;\n}\nfunction _getRowContainerClass(name) {\n const options = _getRowContainerOptions(name);\n return options.container ?? `ag-${options.name}-container`;\n}\nfunction _getRowSpanContainerClass(name) {\n const options = _getRowContainerOptions(name);\n return `ag-${options.name}-spanned-cells-container`;\n}\nfunction _getRowContainerOptions(name) {\n return ContainerCssClasses[name];\n}\nvar allTopNoFW = [\"topCenter\", \"topLeft\", \"topRight\"];\nvar allBottomNoFW = [\"bottomCenter\", \"bottomLeft\", \"bottomRight\"];\nvar allMiddleNoFW = [\"center\", \"left\", \"right\"];\nvar allMiddle = [\"center\", \"left\", \"right\", \"fullWidth\"];\nvar allCenter = [\"stickyTopCenter\", \"stickyBottomCenter\", \"center\", \"topCenter\", \"bottomCenter\"];\nvar allLeft = [\"left\", \"bottomLeft\", \"topLeft\", \"stickyTopLeft\", \"stickyBottomLeft\"];\nvar allRight = [\"right\", \"bottomRight\", \"topRight\", \"stickyTopRight\", \"stickyBottomRight\"];\nvar allStickyTopNoFW = [\"stickyTopCenter\", \"stickyTopLeft\", \"stickyTopRight\"];\nvar allStickyBottomNoFW = [\"stickyBottomCenter\", \"stickyBottomLeft\", \"stickyBottomRight\"];\nvar allStickyContainers = [\n ...allStickyTopNoFW,\n \"stickyTopFullWidth\",\n ...allStickyBottomNoFW,\n \"stickyBottomFullWidth\"\n];\nvar allNoFW = [\n ...allTopNoFW,\n ...allBottomNoFW,\n ...allMiddleNoFW,\n ...allStickyTopNoFW,\n ...allStickyBottomNoFW\n];\nvar RowContainerCtrl = class extends BeanStub {\n constructor(name) {\n super();\n this.name = name;\n this.visible = true;\n // Maintaining a constant reference enables optimization in React.\n this.EMPTY_CTRLS = [];\n this.options = _getRowContainerOptions(name);\n }\n postConstruct() {\n this.enableRtl = this.gos.get(\"enableRtl\");\n this.forContainers([\"center\"], () => {\n this.viewportSizeFeature = this.createManagedBean(new ViewportSizeFeature(this));\n this.addManagedEventListeners({\n stickyTopOffsetChanged: this.onStickyTopOffsetChanged.bind(this)\n });\n });\n }\n onStickyTopOffsetChanged(event) {\n this.comp.setOffsetTop(`${event.offset}px`);\n }\n registerWithCtrlsService() {\n if (this.options.fullWidth)\n return;\n this.beans.ctrlsSvc.register(this.name, this);\n }\n forContainers(names, callback) {\n if (names.indexOf(this.name) >= 0) {\n callback();\n }\n }\n setComp(view, eContainer, eSpannedContainer, eViewport) {\n this.comp = view;\n this.eContainer = eContainer;\n this.eSpannedContainer = eSpannedContainer;\n this.eViewport = eViewport;\n this.createManagedBean(new RowContainerEventsFeature(this.eViewport ?? this.eContainer));\n this.addPreventScrollWhileDragging();\n this.listenOnDomOrder();\n const { pinnedCols, rangeSvc } = this.beans;\n const pinnedWidthChanged = () => this.onPinnedWidthChanged();\n this.forContainers(allLeft, () => {\n this.pinnedWidthFeature = this.createOptionalManagedBean(\n pinnedCols?.createPinnedWidthFeature(true, this.eContainer, this.eSpannedContainer)\n );\n this.addManagedEventListeners({ leftPinnedWidthChanged: pinnedWidthChanged });\n });\n this.forContainers(allRight, () => {\n this.pinnedWidthFeature = this.createOptionalManagedBean(\n pinnedCols?.createPinnedWidthFeature(false, this.eContainer, this.eSpannedContainer)\n );\n this.addManagedEventListeners({ rightPinnedWidthChanged: pinnedWidthChanged });\n });\n this.forContainers(\n allMiddle,\n () => this.createManagedBean(\n new SetHeightFeature(this.eContainer, this.name === \"center\" ? eViewport : void 0)\n )\n );\n if (rangeSvc) {\n this.forContainers(\n allNoFW,\n () => this.createManagedBean(rangeSvc.createDragListenerFeature(this.eContainer))\n );\n }\n this.forContainers(\n allCenter,\n () => this.createManagedBean(new CenterWidthFeature((width) => this.comp.setContainerWidth(`${width}px`)))\n );\n this.visible = this.isContainerVisible();\n this.addListeners();\n this.registerWithCtrlsService();\n }\n onScrollCallback(fn) {\n this.addManagedElementListeners(this.eViewport, { scroll: fn });\n }\n addListeners() {\n const { spannedRowRenderer, gos } = this.beans;\n this.addManagedEventListeners({\n displayedColumnsChanged: this.onDisplayedColumnsChanged.bind(this),\n displayedColumnsWidthChanged: this.onDisplayedColumnsChanged.bind(this),\n displayedRowsChanged: (params) => this.onDisplayedRowsChanged(params.afterScroll)\n });\n this.onDisplayedColumnsChanged();\n this.onDisplayedRowsChanged();\n if (spannedRowRenderer && this.options.getSpannedRowCtrls && gos.get(\"enableCellSpan\")) {\n this.addManagedListeners(spannedRowRenderer, {\n spannedRowsUpdated: () => {\n const spannedCtrls = this.options.getSpannedRowCtrls(spannedRowRenderer);\n if (!spannedCtrls) {\n return;\n }\n this.comp.setSpannedRowCtrls(spannedCtrls, false);\n }\n });\n }\n }\n listenOnDomOrder() {\n const isStickContainer = allStickyContainers.indexOf(this.name) >= 0;\n if (isStickContainer) {\n this.comp.setDomOrder(true);\n return;\n }\n const listener = () => {\n const isEnsureDomOrder = this.gos.get(\"ensureDomOrder\");\n const isPrintLayout = _isDomLayout(this.gos, \"print\");\n this.comp.setDomOrder(isEnsureDomOrder || isPrintLayout);\n };\n this.addManagedPropertyListener(\"domLayout\", listener);\n listener();\n }\n onDisplayedColumnsChanged() {\n this.forContainers([\"center\"], () => this.onHorizontalViewportChanged());\n }\n // this methods prevents the grid views from being scrolled while the dragService is being used\n // eg. the view should not scroll up and down while dragging rows using the rowDragComp.\n addPreventScrollWhileDragging() {\n const { dragSvc } = this.beans;\n if (!dragSvc) {\n return;\n }\n const preventScroll = (e) => {\n if (dragSvc.dragging) {\n if (e.cancelable) {\n e.preventDefault();\n }\n }\n };\n this.eContainer.addEventListener(\"touchmove\", preventScroll, { passive: false });\n this.addDestroyFunc(() => this.eContainer.removeEventListener(\"touchmove\", preventScroll));\n }\n // this gets called whenever a change in the viewport, so we can inform column controller it has to work\n // out the virtual columns again. gets called from following locations:\n // + ensureColVisible, scroll, init, layoutChanged, displayedColumnsChanged\n onHorizontalViewportChanged(afterScroll = false) {\n const scrollWidth = this.getCenterWidth();\n const scrollPosition = this.getCenterViewportScrollLeft();\n this.beans.colViewport.setScrollPosition(scrollWidth, scrollPosition, afterScroll);\n }\n hasHorizontalScrollGap() {\n return this.eContainer.clientWidth - this.eViewport.clientWidth < 0;\n }\n hasVerticalScrollGap() {\n return this.eContainer.clientHeight - this.eViewport.clientHeight < 0;\n }\n getCenterWidth() {\n return _getInnerWidth(this.eViewport);\n }\n getCenterViewportScrollLeft() {\n return _getScrollLeft(this.eViewport, this.enableRtl);\n }\n registerViewportResizeListener(listener) {\n const unsubscribeFromResize = _observeResize(this.beans, this.eViewport, listener);\n this.addDestroyFunc(() => unsubscribeFromResize());\n }\n isViewportInTheDOMTree() {\n return _isInDOM(this.eViewport);\n }\n getViewportScrollLeft() {\n return _getScrollLeft(this.eViewport, this.enableRtl);\n }\n isHorizontalScrollShowing() {\n const isAlwaysShowHorizontalScroll = this.gos.get(\"alwaysShowHorizontalScroll\");\n return isAlwaysShowHorizontalScroll || _isHorizontalScrollShowing(this.eViewport);\n }\n setHorizontalScroll(offset) {\n this.comp.setHorizontalScroll(offset);\n }\n getHScrollPosition() {\n const res = {\n left: this.eViewport.scrollLeft,\n right: this.eViewport.scrollLeft + this.eViewport.offsetWidth\n };\n return res;\n }\n setCenterViewportScrollLeft(value) {\n _setScrollLeft(this.eViewport, value, this.enableRtl);\n }\n isContainerVisible() {\n const pinned = this.options.pinnedType != null;\n return !pinned || !!this.pinnedWidthFeature && this.pinnedWidthFeature.getWidth() > 0;\n }\n onPinnedWidthChanged() {\n const visible = this.isContainerVisible();\n if (this.visible != visible) {\n this.visible = visible;\n this.onDisplayedRowsChanged();\n }\n }\n onDisplayedRowsChanged(afterScroll = false) {\n const rows = this.options.getRowCtrls(this.beans.rowRenderer);\n if (!this.visible || rows.length === 0) {\n this.comp.setRowCtrls({ rowCtrls: this.EMPTY_CTRLS });\n return;\n }\n const printLayout = _isDomLayout(this.gos, \"print\");\n const embedFullWidthRows = this.gos.get(\"embedFullWidthRows\");\n const embedFW = embedFullWidthRows || printLayout;\n const rowsThisContainer = rows.filter((rowCtrl) => {\n const fullWidthRow = rowCtrl.isFullWidth();\n const match = this.options.fullWidth ? !embedFW && fullWidthRow : embedFW || !fullWidthRow;\n return match;\n });\n this.comp.setRowCtrls({ rowCtrls: rowsThisContainer, useFlushSync: afterScroll });\n }\n};\n\n// packages/ag-grid-community/src/gridBodyComp/gridBodyCtrl.ts\nvar CSS_CLASS_FORCE_VERTICAL_SCROLL = \"ag-force-vertical-scroll\";\nvar CSS_CLASS_CELL_SELECTABLE = \"ag-selectable\";\nvar CSS_CLASS_COLUMN_MOVING = \"ag-column-moving\";\nvar GridBodyCtrl = class extends BeanStub {\n constructor() {\n super(...arguments);\n this.stickyTopHeight = 0;\n this.stickyBottomHeight = 0;\n }\n wireBeans(beans) {\n this.ctrlsSvc = beans.ctrlsSvc;\n this.colModel = beans.colModel;\n this.scrollVisibleSvc = beans.scrollVisibleSvc;\n this.pinnedRowModel = beans.pinnedRowModel;\n this.filterManager = beans.filterManager;\n this.rowGroupColsSvc = beans.rowGroupColsSvc;\n }\n setComp(comp, eGridBody, eBodyViewport, eTop, eBottom, eStickyTop, eStickyBottom) {\n this.comp = comp;\n this.eGridBody = eGridBody;\n this.eBodyViewport = eBodyViewport;\n this.eTop = eTop;\n this.eBottom = eBottom;\n this.eStickyTop = eStickyTop;\n this.eStickyBottom = eStickyBottom;\n this.eCenterColsViewport = eBodyViewport.querySelector(`.${_getRowViewportClass(\"center\")}`);\n this.eFullWidthContainer = eBodyViewport.querySelector(`.${_getRowContainerClass(\"fullWidth\")}`);\n this.eStickyTopFullWidthContainer = eStickyTop.querySelector(\n `.${_getRowContainerClass(\"stickyTopFullWidth\")}`\n );\n this.eStickyBottomFullWidthContainer = eStickyBottom.querySelector(\n `.${_getRowContainerClass(\"stickyBottomFullWidth\")}`\n );\n this.setCellTextSelection(this.gos.get(\"enableCellTextSelection\"));\n this.addManagedPropertyListener(\n \"enableCellTextSelection\",\n (props) => this.setCellTextSelection(props.currentValue)\n );\n this.createManagedBean(new LayoutFeature(this.comp));\n this.scrollFeature = this.createManagedBean(new GridBodyScrollFeature(this.eBodyViewport));\n this.beans.rowDragSvc?.setupRowDrag(this.eBodyViewport, this);\n this.setupRowAnimationCssClass();\n this.addEventListeners();\n this.addFocusListeners([eTop, eBodyViewport, eBottom, eStickyTop, eStickyBottom]);\n this.setGridRootRole();\n this.onGridColumnsChanged();\n this.addBodyViewportListener();\n this.setFloatingHeights();\n this.disableBrowserDragging();\n this.addStopEditingWhenGridLosesFocus();\n this.updateScrollingClasses();\n this.filterManager?.setupAdvFilterHeaderComp(eTop);\n this.ctrlsSvc.register(\"gridBodyCtrl\", this);\n }\n addEventListeners() {\n const setFloatingHeights = this.setFloatingHeights.bind(this);\n const setGridRootRole = this.setGridRootRole.bind(this);\n this.addManagedEventListeners({\n gridColumnsChanged: this.onGridColumnsChanged.bind(this),\n scrollVisibilityChanged: this.onScrollVisibilityChanged.bind(this),\n scrollGapChanged: this.updateScrollingClasses.bind(this),\n pinnedRowDataChanged: setFloatingHeights,\n pinnedHeightChanged: setFloatingHeights,\n headerHeightChanged: this.setStickyTopOffsetTop.bind(this),\n columnRowGroupChanged: setGridRootRole,\n columnPivotChanged: setGridRootRole\n });\n this.addManagedPropertyListener(\"treeData\", setGridRootRole);\n }\n onGridColumnsChanged() {\n const columns = this.beans.colModel.getCols();\n this.comp.setColumnCount(columns.length);\n }\n onScrollVisibilityChanged() {\n const { scrollVisibleSvc } = this;\n const visible = scrollVisibleSvc.verticalScrollShowing;\n this.setVerticalScrollPaddingVisible(visible);\n this.setStickyWidth(visible);\n this.setStickyBottomOffsetBottom();\n const scrollbarWidth = visible ? scrollVisibleSvc.getScrollbarWidth() || 0 : 0;\n const pad = _isInvisibleScrollbar() ? 16 : 0;\n const width = `calc(100% + ${scrollbarWidth + pad}px)`;\n _requestAnimationFrame(this.beans, () => this.comp.setBodyViewportWidth(width));\n this.updateScrollingClasses();\n }\n setGridRootRole() {\n const { rowGroupColsSvc, colModel } = this;\n let isTreeGrid = this.gos.get(\"treeData\");\n if (!isTreeGrid) {\n const isPivotActive = colModel.isPivotMode();\n const rowGroupColumnLen = !rowGroupColsSvc ? 0 : rowGroupColsSvc.columns.length;\n const columnsNeededForGrouping = isPivotActive ? 2 : 1;\n isTreeGrid = rowGroupColumnLen >= columnsNeededForGrouping;\n }\n this.comp.setGridRootRole(isTreeGrid ? \"treegrid\" : \"grid\");\n }\n addFocusListeners(elements) {\n elements.forEach((element) => {\n this.addManagedElementListeners(element, {\n focusin: (e) => {\n const { target } = e;\n const isFocusedElementNested = _isElementChildOfClass(target, \"ag-root\", element);\n element.classList.toggle(\"ag-has-focus\", !isFocusedElementNested);\n },\n focusout: (e) => {\n const { target, relatedTarget } = e;\n const gridContainRelatedTarget = element.contains(relatedTarget);\n const isNestedRelatedTarget = _isElementChildOfClass(\n relatedTarget,\n \"ag-root\",\n element\n );\n const isNestedTarget = _isElementChildOfClass(target, \"ag-root\", element);\n if (isNestedTarget) {\n return;\n }\n if (!gridContainRelatedTarget || isNestedRelatedTarget) {\n element.classList.remove(\"ag-has-focus\");\n }\n }\n });\n });\n }\n // used by ColumnAnimationService\n setColumnMovingCss(moving) {\n this.comp.setColumnMovingCss(CSS_CLASS_COLUMN_MOVING, moving);\n }\n setCellTextSelection(selectable = false) {\n this.comp.setCellSelectableCss(CSS_CLASS_CELL_SELECTABLE, selectable);\n }\n updateScrollingClasses() {\n const {\n eGridBody: { classList },\n scrollVisibleSvc\n } = this;\n classList.toggle(\"ag-body-vertical-content-no-gap\", !scrollVisibleSvc.verticalScrollGap);\n classList.toggle(\"ag-body-horizontal-content-no-gap\", !scrollVisibleSvc.horizontalScrollGap);\n }\n // if we do not do this, then the user can select a pic in the grid (eg an image in a custom cell renderer)\n // and then that will start the browser native drag n' drop, which messes up with our own drag and drop.\n disableBrowserDragging() {\n this.addManagedElementListeners(this.eGridBody, {\n dragstart: (event) => {\n if (event.target instanceof HTMLImageElement) {\n event.preventDefault();\n return false;\n }\n }\n });\n }\n addStopEditingWhenGridLosesFocus() {\n this.beans.editSvc?.addStopEditingWhenGridLosesFocus([\n this.eBodyViewport,\n this.eBottom,\n this.eTop,\n this.eStickyTop,\n this.eStickyBottom\n ]);\n }\n updateRowCount() {\n const headerCount = (this.ctrlsSvc.getHeaderRowContainerCtrl()?.getRowCount() ?? 0) + (this.filterManager?.getHeaderRowCount() ?? 0);\n const { rowModel } = this.beans;\n const rowCount = rowModel.isLastRowIndexKnown() ? rowModel.getRowCount() : -1;\n const total = rowCount === -1 ? -1 : headerCount + rowCount;\n this.comp.setRowCount(total);\n }\n registerBodyViewportResizeListener(listener) {\n this.comp.registerBodyViewportResizeListener(listener);\n }\n setVerticalScrollPaddingVisible(visible) {\n const overflowY = visible ? \"scroll\" : \"hidden\";\n this.comp.setPinnedTopBottomOverflowY(overflowY);\n }\n isVerticalScrollShowing() {\n const show = this.gos.get(\"alwaysShowVerticalScroll\");\n const cssClass = show ? CSS_CLASS_FORCE_VERTICAL_SCROLL : null;\n const allowVerticalScroll = _isDomLayout(this.gos, \"normal\");\n this.comp.setAlwaysVerticalScrollClass(cssClass, show);\n return show || allowVerticalScroll && _isVerticalScrollShowing(this.eBodyViewport);\n }\n setupRowAnimationCssClass() {\n const { rowContainerHeight, environment } = this.beans;\n let initialSizeMeasurementComplete = environment.sizesMeasured;\n const updateAnimationClass = () => {\n const animateRows = initialSizeMeasurementComplete && _isAnimateRows(this.gos) && !rowContainerHeight.stretching;\n const animateRowsCssClass = animateRows ? \"ag-row-animation\" : \"ag-row-no-animation\";\n this.comp.setRowAnimationCssOnBodyViewport(animateRowsCssClass, animateRows);\n };\n updateAnimationClass();\n this.addManagedEventListeners({ heightScaleChanged: updateAnimationClass });\n this.addManagedPropertyListener(\"animateRows\", updateAnimationClass);\n this.addManagedEventListeners({\n gridStylesChanged: () => {\n if (!initialSizeMeasurementComplete && environment.sizesMeasured) {\n initialSizeMeasurementComplete = true;\n updateAnimationClass();\n }\n }\n });\n }\n addBodyViewportListener() {\n const { popupSvc, touchSvc } = this.beans;\n const listener = this.onBodyViewportContextMenu.bind(this);\n this.addManagedElementListeners(this.eBodyViewport, { contextmenu: listener });\n touchSvc?.mockBodyContextMenu(this, listener);\n this.addManagedElementListeners(this.eBodyViewport, {\n wheel: this.onBodyViewportWheel.bind(this, popupSvc)\n });\n this.addManagedElementListeners(this.eStickyTop, { wheel: this.onStickyWheel.bind(this) });\n this.addManagedElementListeners(this.eStickyBottom, { wheel: this.onStickyWheel.bind(this) });\n this.addFullWidthContainerWheelListener();\n }\n addFullWidthContainerWheelListener() {\n this.addManagedElementListeners(this.eFullWidthContainer, {\n wheel: (e) => this.onFullWidthContainerWheel(e)\n });\n }\n onFullWidthContainerWheel(e) {\n const { deltaX, deltaY, shiftKey } = e;\n const isHorizontalScroll = shiftKey || Math.abs(deltaX) > Math.abs(deltaY);\n if (isHorizontalScroll && _isEventFromThisGrid(this.gos, e)) {\n this.scrollGridBodyToMatchEvent(e);\n }\n }\n onStickyWheel(e) {\n const { deltaX, deltaY, shiftKey } = e;\n const isHorizontalScroll = shiftKey || Math.abs(deltaX) > Math.abs(deltaY);\n const target = e.target;\n if (!isHorizontalScroll) {\n e.preventDefault();\n this.scrollVertically(deltaY);\n } else if (this.eStickyTopFullWidthContainer.contains(target) || this.eStickyBottomFullWidthContainer.contains(target)) {\n this.scrollGridBodyToMatchEvent(e);\n }\n }\n scrollGridBodyToMatchEvent(e) {\n const { deltaX, deltaY } = e;\n e.preventDefault();\n this.eCenterColsViewport.scrollBy({ left: deltaX || deltaY });\n }\n onBodyViewportContextMenu(mouseEvent, touch, touchEvent) {\n if (!mouseEvent && !touchEvent) {\n return;\n }\n if (this.gos.get(\"preventDefaultOnContextMenu\")) {\n const event = mouseEvent || touchEvent;\n event.preventDefault();\n }\n const { target } = mouseEvent || touch;\n if (target === this.eBodyViewport || target === this.ctrlsSvc.get(\"center\").eViewport) {\n this.beans.contextMenuSvc?.showContextMenu({\n mouseEvent,\n touchEvent,\n value: null,\n anchorToElement: this.eGridBody,\n source: \"ui\"\n });\n }\n }\n onBodyViewportWheel(popupSvc, e) {\n if (!this.gos.get(\"suppressScrollWhenPopupsAreOpen\")) {\n return;\n }\n if (popupSvc?.hasAnchoredPopup()) {\n e.preventDefault();\n }\n }\n // called by rowDragFeature\n scrollVertically(pixels) {\n const oldScrollPosition = this.eBodyViewport.scrollTop;\n this.scrollFeature.setVerticalScrollPosition(oldScrollPosition + pixels);\n return this.eBodyViewport.scrollTop - oldScrollPosition;\n }\n setFloatingHeights() {\n const { pinnedRowModel } = this;\n const floatingTopHeight = pinnedRowModel?.getPinnedTopTotalHeight() ?? 0;\n const floatingBottomHeight = pinnedRowModel?.getPinnedBottomTotalHeight() ?? 0;\n this.comp.setTopHeight(floatingTopHeight);\n this.comp.setBottomHeight(floatingBottomHeight);\n this.comp.setTopDisplay(floatingTopHeight ? \"inherit\" : \"none\");\n this.comp.setBottomDisplay(floatingBottomHeight ? \"inherit\" : \"none\");\n this.setStickyTopOffsetTop();\n this.setStickyBottomOffsetBottom();\n }\n setStickyTopHeight(height = 0) {\n this.comp.setStickyTopHeight(`${height}px`);\n this.stickyTopHeight = height;\n }\n setStickyBottomHeight(height = 0) {\n this.comp.setStickyBottomHeight(`${height}px`);\n this.stickyBottomHeight = height;\n }\n setStickyWidth(vScrollVisible) {\n if (!vScrollVisible) {\n this.comp.setStickyTopWidth(\"100%\");\n this.comp.setStickyBottomWidth(\"100%\");\n } else {\n const scrollbarWidth = this.scrollVisibleSvc.getScrollbarWidth();\n this.comp.setStickyTopWidth(`calc(100% - ${scrollbarWidth}px)`);\n this.comp.setStickyBottomWidth(`calc(100% - ${scrollbarWidth}px)`);\n }\n }\n setStickyTopOffsetTop() {\n const headerCtrl = this.ctrlsSvc.get(\"gridHeaderCtrl\");\n const headerHeight = headerCtrl.headerHeight + (this.filterManager?.getHeaderHeight() ?? 0);\n const pinnedTopHeight = this.pinnedRowModel?.getPinnedTopTotalHeight() ?? 0;\n let height = 0;\n if (headerHeight > 0) {\n height += headerHeight;\n }\n if (pinnedTopHeight > 0) {\n height += pinnedTopHeight;\n }\n if (height > 0) {\n height += 1;\n }\n this.comp.setStickyTopTop(`${height}px`);\n }\n setStickyBottomOffsetBottom() {\n const { pinnedRowModel, scrollVisibleSvc, comp } = this;\n const pinnedBottomHeight = pinnedRowModel?.getPinnedBottomTotalHeight() ?? 0;\n const hScrollShowing = scrollVisibleSvc.horizontalScrollShowing;\n const scrollbarWidth = hScrollShowing ? scrollVisibleSvc.getScrollbarWidth() || 0 : 0;\n const height = pinnedBottomHeight + scrollbarWidth;\n comp.setStickyBottomBottom(`${height}px`);\n }\n};\n\n// packages/ag-grid-community/src/gridBodyComp/abstractFakeScrollComp.ts\nvar AbstractFakeScrollComp = class extends Component {\n constructor(template, direction) {\n super();\n this.direction = direction;\n this.eViewport = RefPlaceholder;\n this.eContainer = RefPlaceholder;\n this.hideTimeout = 0;\n this.setTemplate(template);\n }\n postConstruct() {\n this.addManagedEventListeners({\n scrollVisibilityChanged: this.onScrollVisibilityChanged.bind(this)\n });\n this.onScrollVisibilityChanged();\n this.addOrRemoveCssClass(\"ag-apple-scrollbar\", _isMacOsUserAgent() || _isIOSUserAgent());\n }\n destroy() {\n super.destroy();\n window.clearTimeout(this.hideTimeout);\n }\n initialiseInvisibleScrollbar() {\n if (this.invisibleScrollbar !== void 0) {\n return;\n }\n this.invisibleScrollbar = _isInvisibleScrollbar();\n if (this.invisibleScrollbar) {\n this.hideAndShowInvisibleScrollAsNeeded();\n this.addActiveListenerToggles();\n }\n }\n addActiveListenerToggles() {\n const eGui = this.getGui();\n const onActivate = () => this.addOrRemoveCssClass(\"ag-scrollbar-active\", true);\n const onDeactivate = () => this.addOrRemoveCssClass(\"ag-scrollbar-active\", false);\n this.addManagedListeners(eGui, {\n mouseenter: onActivate,\n mousedown: onActivate,\n touchstart: onActivate,\n mouseleave: onDeactivate,\n touchend: onDeactivate\n });\n }\n onScrollVisibilityChanged() {\n if (this.invisibleScrollbar === void 0) {\n this.initialiseInvisibleScrollbar();\n }\n _requestAnimationFrame(this.beans, () => this.setScrollVisible());\n }\n hideAndShowInvisibleScrollAsNeeded() {\n this.addManagedEventListeners({\n bodyScroll: (params) => {\n if (params.direction === this.direction) {\n if (this.hideTimeout) {\n window.clearTimeout(this.hideTimeout);\n this.hideTimeout = 0;\n }\n this.addOrRemoveCssClass(\"ag-scrollbar-scrolling\", true);\n }\n },\n bodyScrollEnd: () => {\n this.hideTimeout = window.setTimeout(() => {\n this.addOrRemoveCssClass(\"ag-scrollbar-scrolling\", false);\n this.hideTimeout = 0;\n }, 400);\n }\n });\n }\n attemptSettingScrollPosition(value) {\n const viewport = this.eViewport;\n _waitUntil(\n () => _isVisible(viewport),\n () => this.setScrollPosition(value),\n 100\n );\n }\n onScrollCallback(fn) {\n this.addManagedElementListeners(this.eViewport, { scroll: fn });\n }\n};\n\n// packages/ag-grid-community/src/gridBodyComp/fakeHScrollComp.ts\nvar FakeHScrollComp = class extends AbstractFakeScrollComp {\n constructor() {\n super(\n /* html */\n ``,\n \"horizontal\"\n );\n this.eLeftSpacer = RefPlaceholder;\n this.eRightSpacer = RefPlaceholder;\n this.setScrollVisibleDebounce = 0;\n }\n wireBeans(beans) {\n this.visibleCols = beans.visibleCols;\n this.scrollVisibleSvc = beans.scrollVisibleSvc;\n }\n postConstruct() {\n super.postConstruct();\n const spacerWidthsListener = this.setFakeHScrollSpacerWidths.bind(this);\n this.addManagedEventListeners({\n displayedColumnsChanged: spacerWidthsListener,\n displayedColumnsWidthChanged: spacerWidthsListener,\n pinnedRowDataChanged: this.refreshCompBottom.bind(this)\n });\n this.addManagedPropertyListener(\"domLayout\", spacerWidthsListener);\n this.beans.ctrlsSvc.register(\"fakeHScrollComp\", this);\n this.createManagedBean(new CenterWidthFeature((width) => this.eContainer.style.width = `${width}px`));\n this.addManagedPropertyListeners([\"suppressHorizontalScroll\"], this.onScrollVisibilityChanged.bind(this));\n }\n destroy() {\n window.clearTimeout(this.setScrollVisibleDebounce);\n super.destroy();\n }\n initialiseInvisibleScrollbar() {\n if (this.invisibleScrollbar !== void 0) {\n return;\n }\n this.enableRtl = this.gos.get(\"enableRtl\");\n super.initialiseInvisibleScrollbar();\n if (this.invisibleScrollbar) {\n this.refreshCompBottom();\n }\n }\n refreshCompBottom() {\n if (!this.invisibleScrollbar) {\n return;\n }\n const bottomPinnedHeight = this.beans.pinnedRowModel?.getPinnedBottomTotalHeight() ?? 0;\n this.getGui().style.bottom = `${bottomPinnedHeight}px`;\n }\n onScrollVisibilityChanged() {\n super.onScrollVisibilityChanged();\n this.setFakeHScrollSpacerWidths();\n }\n setFakeHScrollSpacerWidths() {\n const vScrollShowing = this.scrollVisibleSvc.verticalScrollShowing;\n let rightSpacing = this.visibleCols.getDisplayedColumnsRightWidth();\n const scrollOnRight = !this.enableRtl && vScrollShowing;\n const scrollbarWidth = this.scrollVisibleSvc.getScrollbarWidth();\n if (scrollOnRight) {\n rightSpacing += scrollbarWidth;\n }\n _setFixedWidth(this.eRightSpacer, rightSpacing);\n this.eRightSpacer.classList.toggle(\"ag-scroller-corner\", rightSpacing <= scrollbarWidth);\n let leftSpacing = this.visibleCols.getColsLeftWidth();\n const scrollOnLeft = this.enableRtl && vScrollShowing;\n if (scrollOnLeft) {\n leftSpacing += scrollbarWidth;\n }\n _setFixedWidth(this.eLeftSpacer, leftSpacing);\n this.eLeftSpacer.classList.toggle(\"ag-scroller-corner\", leftSpacing <= scrollbarWidth);\n }\n setScrollVisible() {\n const hScrollShowing = this.scrollVisibleSvc.horizontalScrollShowing;\n const invisibleScrollbar2 = this.invisibleScrollbar;\n const isSuppressHorizontalScroll = this.gos.get(\"suppressHorizontalScroll\");\n const scrollbarWidth = hScrollShowing ? this.scrollVisibleSvc.getScrollbarWidth() || 0 : 0;\n const adjustedScrollbarWidth = scrollbarWidth === 0 && invisibleScrollbar2 ? 16 : scrollbarWidth;\n const scrollContainerSize = !isSuppressHorizontalScroll ? adjustedScrollbarWidth : 0;\n const apply = () => {\n this.setScrollVisibleDebounce = 0;\n this.addOrRemoveCssClass(\"ag-scrollbar-invisible\", invisibleScrollbar2);\n _setFixedHeight(this.getGui(), scrollContainerSize);\n _setFixedHeight(this.eViewport, scrollContainerSize);\n _setFixedHeight(this.eContainer, scrollContainerSize);\n this.setDisplayed(hScrollShowing, { skipAriaHidden: true });\n };\n window.clearTimeout(this.setScrollVisibleDebounce);\n if (!hScrollShowing) {\n apply();\n } else {\n this.setScrollVisibleDebounce = window.setTimeout(apply, 100);\n }\n }\n getScrollPosition() {\n return _getScrollLeft(this.eViewport, this.enableRtl);\n }\n setScrollPosition(value) {\n if (!_isVisible(this.eViewport)) {\n this.attemptSettingScrollPosition(value);\n }\n _setScrollLeft(this.eViewport, value, this.enableRtl);\n }\n};\nvar FakeHScrollSelector = {\n selector: \"AG-FAKE-HORIZONTAL-SCROLL\",\n component: FakeHScrollComp\n};\n\n// packages/ag-grid-community/src/gridBodyComp/fakeVScrollComp.ts\nvar FakeVScrollComp = class extends AbstractFakeScrollComp {\n constructor() {\n super(\n /* html */\n ``,\n \"vertical\"\n );\n }\n postConstruct() {\n super.postConstruct();\n this.createManagedBean(new SetHeightFeature(this.eContainer));\n const { ctrlsSvc } = this.beans;\n ctrlsSvc.register(\"fakeVScrollComp\", this);\n this.addManagedEventListeners({\n rowContainerHeightChanged: this.onRowContainerHeightChanged.bind(this, ctrlsSvc)\n });\n }\n setScrollVisible() {\n const { scrollVisibleSvc } = this.beans;\n const vScrollShowing = scrollVisibleSvc.verticalScrollShowing;\n const invisibleScrollbar2 = this.invisibleScrollbar;\n const scrollbarWidth = vScrollShowing ? scrollVisibleSvc.getScrollbarWidth() || 0 : 0;\n const adjustedScrollbarWidth = scrollbarWidth === 0 && invisibleScrollbar2 ? 16 : scrollbarWidth;\n this.addOrRemoveCssClass(\"ag-scrollbar-invisible\", invisibleScrollbar2);\n _setFixedWidth(this.getGui(), adjustedScrollbarWidth);\n _setFixedWidth(this.eViewport, adjustedScrollbarWidth);\n _setFixedWidth(this.eContainer, adjustedScrollbarWidth);\n this.setDisplayed(vScrollShowing, { skipAriaHidden: true });\n }\n onRowContainerHeightChanged(ctrlsSvc) {\n const gridBodyCtrl = ctrlsSvc.getGridBodyCtrl();\n const gridBodyViewportEl = gridBodyCtrl.eBodyViewport;\n const eViewportScrollTop = this.getScrollPosition();\n const gridBodyViewportScrollTop = gridBodyViewportEl.scrollTop;\n if (eViewportScrollTop != gridBodyViewportScrollTop) {\n this.setScrollPosition(gridBodyViewportScrollTop, true);\n }\n }\n getScrollPosition() {\n return this.eViewport.scrollTop;\n }\n setScrollPosition(value, force) {\n if (!force && !_isVisible(this.eViewport)) {\n this.attemptSettingScrollPosition(value);\n }\n this.eViewport.scrollTop = value;\n }\n};\nvar FakeVScrollSelector = {\n selector: \"AG-FAKE-VERTICAL-SCROLL\",\n component: FakeVScrollComp\n};\n\n// packages/ag-grid-community/src/headerRendering/headerUtils.ts\nfunction getHeaderRowCount(colModel) {\n return colModel.cols ? colModel.cols.treeDepth + 1 : -1;\n}\nfunction getFocusHeaderRowCount(beans) {\n return beans.ctrlsSvc.getHeaderRowContainerCtrl()?.getRowCount() ?? 0;\n}\nfunction getGroupRowsHeight(beans) {\n const heights = [];\n const headerRowContainerCtrls = beans.ctrlsSvc.getHeaderRowContainerCtrls();\n for (const headerRowContainerCtrl of headerRowContainerCtrls) {\n if (!headerRowContainerCtrl) {\n continue;\n }\n const groupRowCount = headerRowContainerCtrl.getGroupRowCount() || 0;\n for (let i = 0; i < groupRowCount; i++) {\n const headerRowCtrl = headerRowContainerCtrl.getGroupRowCtrlAtIndex(i);\n const currentHeightAtPos = heights[i];\n if (headerRowCtrl) {\n const newHeight = getColumnGroupHeaderRowHeight(beans, headerRowCtrl);\n if (currentHeightAtPos == null || newHeight > currentHeightAtPos) {\n heights[i] = newHeight;\n }\n }\n }\n }\n return heights;\n}\nfunction getColumnGroupHeaderRowHeight(beans, headerRowCtrl) {\n const defaultHeight = beans.colModel.isPivotMode() ? getPivotGroupHeaderHeight(beans) : getGroupHeaderHeight(beans);\n let displayedHeights = 0;\n const headerRowCellCtrls = headerRowCtrl.getHeaderCtrls();\n for (const headerCellCtrl of headerRowCellCtrls) {\n const { column } = headerCellCtrl;\n if (column.isAutoHeaderHeight()) {\n const height = column.getAutoHeaderHeight();\n if (height != null && height > displayedHeights) {\n displayedHeights = height;\n }\n }\n }\n return Math.max(defaultHeight, displayedHeights);\n}\nfunction getColumnHeaderRowHeight(beans) {\n const defaultHeight = beans.colModel.isPivotMode() ? getPivotHeaderHeight(beans) : getHeaderHeight(beans);\n const allDisplayedCols = beans.visibleCols.allCols;\n const displayedHeights = allDisplayedCols.filter((col) => col.isAutoHeaderHeight()).map((col) => col.getAutoHeaderHeight() || 0);\n return Math.max(defaultHeight, ...displayedHeights);\n}\nfunction getHeaderHeight(beans) {\n return beans.gos.get(\"headerHeight\") ?? beans.environment.getDefaultHeaderHeight();\n}\nfunction getFloatingFiltersHeight(beans) {\n return beans.gos.get(\"floatingFiltersHeight\") ?? getHeaderHeight(beans);\n}\nfunction getGroupHeaderHeight(beans) {\n return beans.gos.get(\"groupHeaderHeight\") ?? getHeaderHeight(beans);\n}\nfunction getPivotHeaderHeight(beans) {\n return beans.gos.get(\"pivotHeaderHeight\") ?? getHeaderHeight(beans);\n}\nfunction getPivotGroupHeaderHeight(beans) {\n return beans.gos.get(\"pivotGroupHeaderHeight\") ?? getGroupHeaderHeight(beans);\n}\n\n// packages/ag-grid-community/src/headerRendering/gridHeaderCtrl.ts\nvar GridHeaderCtrl = class extends BeanStub {\n setComp(comp, eGui, eFocusableElement) {\n this.comp = comp;\n this.eGui = eGui;\n const { beans } = this;\n const { headerNavigation, touchSvc, ctrlsSvc } = beans;\n if (headerNavigation) {\n this.createManagedBean(\n new ManagedFocusFeature(eFocusableElement, {\n onTabKeyDown: this.onTabKeyDown.bind(this),\n handleKeyDown: this.handleKeyDown.bind(this),\n onFocusOut: this.onFocusOut.bind(this)\n })\n );\n }\n this.addManagedEventListeners({\n columnPivotModeChanged: this.onPivotModeChanged.bind(this, beans),\n displayedColumnsChanged: this.onDisplayedColumnsChanged.bind(this, beans)\n });\n this.onPivotModeChanged(beans);\n this.setupHeaderHeight();\n const listener = this.onHeaderContextMenu.bind(this);\n this.addManagedElementListeners(this.eGui, { contextmenu: listener });\n touchSvc?.mockHeaderContextMenu(this, listener);\n ctrlsSvc.register(\"gridHeaderCtrl\", this);\n }\n setupHeaderHeight() {\n const listener = this.setHeaderHeight.bind(this);\n listener();\n this.addManagedPropertyListeners(\n [\n \"headerHeight\",\n \"pivotHeaderHeight\",\n \"groupHeaderHeight\",\n \"pivotGroupHeaderHeight\",\n \"floatingFiltersHeight\"\n ],\n listener\n );\n this.addManagedEventListeners({\n displayedColumnsChanged: listener,\n columnHeaderHeightChanged: listener,\n // add this to the animation frame to avoid a feedback loop\n columnGroupHeaderHeightChanged: () => _requestAnimationFrame(this.beans, () => listener()),\n gridStylesChanged: listener,\n advancedFilterEnabledChanged: listener\n });\n }\n setHeaderHeight() {\n const { beans } = this;\n let totalHeaderHeight = 0;\n const groupHeight = getGroupRowsHeight(beans).reduce((prev, curr) => prev + curr, 0);\n const headerHeight = getColumnHeaderRowHeight(beans);\n if (beans.filterManager?.hasFloatingFilters()) {\n totalHeaderHeight += getFloatingFiltersHeight(beans);\n }\n totalHeaderHeight += groupHeight;\n totalHeaderHeight += headerHeight;\n if (this.headerHeight === totalHeaderHeight) {\n return;\n }\n this.headerHeight = totalHeaderHeight;\n const px = `${totalHeaderHeight + 1}px`;\n this.comp.setHeightAndMinHeight(px);\n this.eventSvc.dispatchEvent({\n type: \"headerHeightChanged\"\n });\n }\n onPivotModeChanged(beans) {\n const pivotMode = beans.colModel.isPivotMode();\n this.comp.addOrRemoveCssClass(\"ag-pivot-on\", pivotMode);\n this.comp.addOrRemoveCssClass(\"ag-pivot-off\", !pivotMode);\n }\n onDisplayedColumnsChanged(beans) {\n const columns = beans.visibleCols.allCols;\n const shouldAllowOverflow = columns.some((col) => col.isSpanHeaderHeight());\n this.comp.addOrRemoveCssClass(\"ag-header-allow-overflow\", shouldAllowOverflow);\n }\n onTabKeyDown(e) {\n const isRtl = this.gos.get(\"enableRtl\");\n const backwards = e.shiftKey;\n const direction = backwards !== isRtl ? \"LEFT\" : \"RIGHT\";\n const { beans } = this;\n const { headerNavigation, focusSvc } = beans;\n if (headerNavigation.navigateHorizontally(direction, true, e) || !backwards && focusSvc.focusOverlay(false) || _focusNextGridCoreContainer(beans, backwards, true)) {\n e.preventDefault();\n }\n }\n handleKeyDown(e) {\n let direction = null;\n const { headerNavigation } = this.beans;\n switch (e.key) {\n case KeyCode.LEFT:\n direction = \"LEFT\";\n case KeyCode.RIGHT: {\n if (!_exists(direction)) {\n direction = \"RIGHT\";\n }\n if (headerNavigation.navigateHorizontally(direction, false, e)) {\n e.preventDefault();\n }\n break;\n }\n case KeyCode.UP:\n direction = \"UP\";\n case KeyCode.DOWN: {\n if (!_exists(direction)) {\n direction = \"DOWN\";\n }\n if (headerNavigation.navigateVertically(direction, null, e)) {\n e.preventDefault();\n }\n break;\n }\n default:\n return;\n }\n }\n onFocusOut(e) {\n const { relatedTarget } = e;\n const { eGui, beans } = this;\n if (!relatedTarget && eGui.contains(_getActiveDomElement(beans))) {\n return;\n }\n if (!eGui.contains(relatedTarget)) {\n beans.focusSvc.focusedHeader = null;\n }\n }\n onHeaderContextMenu(mouseEvent, touch, touchEvent) {\n const { menuSvc, ctrlsSvc } = this.beans;\n if (!mouseEvent && !touchEvent || !menuSvc?.isHeaderContextMenuEnabled()) {\n return;\n }\n const { target } = mouseEvent ?? touch;\n if (target === this.eGui || target === ctrlsSvc.getHeaderRowContainerCtrl()?.eViewport) {\n menuSvc.showHeaderContextMenu(void 0, mouseEvent, touchEvent);\n }\n }\n};\n\n// packages/ag-grid-community/src/headerRendering/cells/abstractCell/abstractHeaderCellComp.ts\nvar AbstractHeaderCellComp = class extends Component {\n constructor(template, ctrl) {\n super(template);\n this.ctrl = ctrl;\n }\n getCtrl() {\n return this.ctrl;\n }\n};\n\n// packages/ag-grid-community/src/headerRendering/cells/column/headerCellComp.ts\nvar HeaderCellComp = class extends AbstractHeaderCellComp {\n constructor(ctrl) {\n super(\n /* html */\n ``,\n ctrl\n );\n this.eResize = RefPlaceholder;\n this.eHeaderCompWrapper = RefPlaceholder;\n this.headerCompVersion = 0;\n }\n postConstruct() {\n const eGui = this.getGui();\n const setAttribute = (name, value) => {\n if (value != null && value != \"\") {\n eGui.setAttribute(name, value);\n } else {\n eGui.removeAttribute(name);\n }\n };\n setAttribute(\"col-id\", this.ctrl.column.getColId());\n const compProxy = {\n setWidth: (width) => eGui.style.width = width,\n addOrRemoveCssClass: (cssClassName, on) => this.addOrRemoveCssClass(cssClassName, on),\n setUserStyles: (styles) => _addStylesToElement(eGui, styles),\n setAriaSort: (sort) => sort ? _setAriaSort(eGui, sort) : _removeAriaSort(eGui),\n setUserCompDetails: (compDetails) => this.setUserCompDetails(compDetails),\n getUserCompInstance: () => this.headerComp\n };\n this.ctrl.setComp(compProxy, this.getGui(), this.eResize, this.eHeaderCompWrapper, void 0);\n const selectAllGui = this.ctrl.getSelectAllGui();\n if (selectAllGui) {\n this.eResize.insertAdjacentElement(\"afterend\", selectAllGui);\n }\n }\n destroy() {\n this.destroyHeaderComp();\n super.destroy();\n }\n destroyHeaderComp() {\n if (this.headerComp) {\n this.eHeaderCompWrapper.removeChild(this.headerCompGui);\n this.headerComp = this.destroyBean(this.headerComp);\n this.headerCompGui = void 0;\n }\n }\n setUserCompDetails(compDetails) {\n this.headerCompVersion++;\n const versionCopy = this.headerCompVersion;\n compDetails.newAgStackInstance().then((comp) => this.afterCompCreated(versionCopy, comp));\n }\n afterCompCreated(version, headerComp) {\n if (version != this.headerCompVersion || !this.isAlive()) {\n this.destroyBean(headerComp);\n return;\n }\n this.destroyHeaderComp();\n this.headerComp = headerComp;\n this.headerCompGui = headerComp.getGui();\n this.eHeaderCompWrapper.appendChild(this.headerCompGui);\n this.ctrl.setDragSource(this.getGui());\n }\n};\n\n// packages/ag-grid-community/src/headerRendering/cells/columnGroup/headerGroupCellComp.ts\nvar HeaderGroupCellComp = class extends AbstractHeaderCellComp {\n constructor(ctrl) {\n super(\n /* html */\n ``,\n ctrl\n );\n this.eResize = RefPlaceholder;\n this.eHeaderCompWrapper = RefPlaceholder;\n }\n postConstruct() {\n const eGui = this.getGui();\n const setAttribute = (key, value) => value != void 0 ? eGui.setAttribute(key, value) : eGui.removeAttribute(key);\n eGui.setAttribute(\"col-id\", this.ctrl.column.getUniqueId());\n const compProxy = {\n addOrRemoveCssClass: (cssClassName, on) => this.addOrRemoveCssClass(cssClassName, on),\n setUserStyles: (styles) => _addStylesToElement(eGui, styles),\n setHeaderWrapperHidden: (hidden) => {\n if (hidden) {\n this.eHeaderCompWrapper.style.setProperty(\"display\", \"none\");\n } else {\n this.eHeaderCompWrapper.style.removeProperty(\"display\");\n }\n },\n setHeaderWrapperMaxHeight: (value) => {\n if (value != null) {\n this.eHeaderCompWrapper.style.setProperty(\"max-height\", `${value}px`);\n } else {\n this.eHeaderCompWrapper.style.removeProperty(\"max-height\");\n }\n this.eHeaderCompWrapper.classList.toggle(\"ag-header-cell-comp-wrapper-limited-height\", value != null);\n },\n setResizableDisplayed: (displayed) => _setDisplayed(this.eResize, displayed),\n setWidth: (width) => eGui.style.width = width,\n setAriaExpanded: (expanded) => setAttribute(\"aria-expanded\", expanded),\n setUserCompDetails: (details) => this.setUserCompDetails(details),\n getUserCompInstance: () => this.headerGroupComp\n };\n this.ctrl.setComp(compProxy, eGui, this.eResize, this.eHeaderCompWrapper, void 0);\n }\n setUserCompDetails(details) {\n details.newAgStackInstance().then((comp) => this.afterHeaderCompCreated(comp));\n }\n afterHeaderCompCreated(headerGroupComp) {\n const destroyFunc = () => this.destroyBean(headerGroupComp);\n if (!this.isAlive()) {\n destroyFunc();\n return;\n }\n const eGui = this.getGui();\n const eHeaderGroupGui = headerGroupComp.getGui();\n this.eHeaderCompWrapper.appendChild(eHeaderGroupGui);\n this.addDestroyFunc(destroyFunc);\n this.headerGroupComp = headerGroupComp;\n this.ctrl.setDragSource(eGui);\n }\n addOrRemoveHeaderWrapperStyle(style, value) {\n const { eHeaderCompWrapper } = this;\n if (value) {\n eHeaderCompWrapper.style.setProperty(style, value);\n } else {\n eHeaderCompWrapper.style.removeProperty(style);\n }\n }\n};\n\n// packages/ag-grid-community/src/headerRendering/cells/floatingFilter/headerFilterCellComp.ts\nvar HeaderFilterCellComp = class extends AbstractHeaderCellComp {\n constructor(ctrl) {\n super(\n /* html */\n ``,\n ctrl\n );\n this.eFloatingFilterBody = RefPlaceholder;\n this.eButtonWrapper = RefPlaceholder;\n this.eButtonShowMainFilter = RefPlaceholder;\n }\n postConstruct() {\n const eGui = this.getGui();\n const compProxy = {\n addOrRemoveCssClass: (cssClassName, on) => this.addOrRemoveCssClass(cssClassName, on),\n setUserStyles: (styles) => _addStylesToElement(eGui, styles),\n addOrRemoveBodyCssClass: (cssClassName, on) => this.eFloatingFilterBody.classList.toggle(cssClassName, on),\n setButtonWrapperDisplayed: (displayed) => _setDisplayed(this.eButtonWrapper, displayed),\n setCompDetails: (compDetails) => this.setCompDetails(compDetails),\n getFloatingFilterComp: () => this.compPromise,\n setWidth: (width) => eGui.style.width = width,\n setMenuIcon: (eIcon) => this.eButtonShowMainFilter.appendChild(eIcon)\n };\n this.ctrl.setComp(compProxy, eGui, this.eButtonShowMainFilter, this.eFloatingFilterBody, void 0);\n }\n setCompDetails(compDetails) {\n if (!compDetails) {\n this.destroyFloatingFilterComp();\n this.compPromise = null;\n return;\n }\n this.compPromise = compDetails.newAgStackInstance();\n this.compPromise.then((comp) => this.afterCompCreated(comp));\n }\n destroy() {\n this.destroyFloatingFilterComp();\n super.destroy();\n }\n destroyFloatingFilterComp() {\n if (this.floatingFilterComp) {\n this.eFloatingFilterBody.removeChild(this.floatingFilterComp.getGui());\n this.floatingFilterComp = this.destroyBean(this.floatingFilterComp);\n }\n }\n afterCompCreated(comp) {\n if (!comp) {\n return;\n }\n if (!this.isAlive()) {\n this.destroyBean(comp);\n return;\n }\n this.destroyFloatingFilterComp();\n this.floatingFilterComp = comp;\n this.eFloatingFilterBody.appendChild(comp.getGui());\n if (comp.afterGuiAttached) {\n comp.afterGuiAttached();\n }\n }\n};\n\n// packages/ag-grid-community/src/headerRendering/row/headerRowComp.ts\nvar HeaderRowComp = class extends Component {\n constructor(ctrl) {\n super();\n this.ctrl = ctrl;\n this.headerComps = {};\n this.setTemplate(\n /* html */\n ``\n );\n }\n postConstruct() {\n _setAriaRowIndex(this.getGui(), this.ctrl.getAriaRowIndex());\n const compProxy = {\n setHeight: (height) => this.getGui().style.height = height,\n setTop: (top) => this.getGui().style.top = top,\n setHeaderCtrls: (ctrls, forceOrder) => this.setHeaderCtrls(ctrls, forceOrder),\n setWidth: (width) => this.getGui().style.width = width\n };\n this.ctrl.setComp(compProxy, void 0);\n }\n destroy() {\n this.setHeaderCtrls([], false);\n super.destroy();\n }\n setHeaderCtrls(ctrls, forceOrder) {\n if (!this.isAlive()) {\n return;\n }\n const oldComps = this.headerComps;\n this.headerComps = {};\n ctrls.forEach((ctrl) => {\n const id = ctrl.instanceId;\n let comp = oldComps[id];\n delete oldComps[id];\n if (comp == null) {\n comp = this.createHeaderComp(ctrl);\n this.getGui().appendChild(comp.getGui());\n }\n this.headerComps[id] = comp;\n });\n Object.values(oldComps).forEach((comp) => {\n this.getGui().removeChild(comp.getGui());\n this.destroyBean(comp);\n });\n if (forceOrder) {\n const comps = Object.values(this.headerComps);\n comps.sort(\n (a, b) => {\n const leftA = a.getCtrl().column.getLeft();\n const leftB = b.getCtrl().column.getLeft();\n return leftA - leftB;\n }\n );\n const elementsInOrder = comps.map((c) => c.getGui());\n _setDomChildOrder(this.getGui(), elementsInOrder);\n }\n }\n createHeaderComp(headerCtrl) {\n let result;\n switch (this.ctrl.type) {\n case \"group\":\n result = new HeaderGroupCellComp(headerCtrl);\n break;\n case \"filter\":\n result = new HeaderFilterCellComp(headerCtrl);\n break;\n default:\n result = new HeaderCellComp(headerCtrl);\n break;\n }\n this.createBean(result);\n result.setParentComponent(this);\n return result;\n }\n};\n\n// packages/ag-grid-community/src/rendering/features/setLeftFeature.ts\nvar SetLeftFeature = class extends BeanStub {\n constructor(columnOrGroup, eCell, beans, colsSpanning) {\n super();\n this.columnOrGroup = columnOrGroup;\n this.eCell = eCell;\n this.colsSpanning = colsSpanning;\n this.columnOrGroup = columnOrGroup;\n this.ariaEl = eCell.querySelector(\"[role=columnheader]\") || eCell;\n this.beans = beans;\n }\n setColsSpanning(colsSpanning) {\n this.colsSpanning = colsSpanning;\n this.onLeftChanged();\n }\n getColumnOrGroup() {\n const { beans, colsSpanning } = this;\n if (beans.gos.get(\"enableRtl\") && colsSpanning) {\n return _last(colsSpanning);\n }\n return this.columnOrGroup;\n }\n postConstruct() {\n const onLeftChanged = this.onLeftChanged.bind(this);\n this.addManagedListeners(this.columnOrGroup, { leftChanged: onLeftChanged });\n this.setLeftFirstTime();\n this.addManagedEventListeners({ displayedColumnsWidthChanged: onLeftChanged });\n this.addManagedPropertyListener(\"domLayout\", onLeftChanged);\n }\n setLeftFirstTime() {\n const { gos, colAnimation } = this.beans;\n const suppressMoveAnimation = gos.get(\"suppressColumnMoveAnimation\");\n const oldLeftExists = _exists(this.columnOrGroup.getOldLeft());\n const animateColumnMove = colAnimation?.isActive() && oldLeftExists && !suppressMoveAnimation;\n if (animateColumnMove) {\n this.animateInLeft();\n } else {\n this.onLeftChanged();\n }\n }\n animateInLeft() {\n const colOrGroup = this.getColumnOrGroup();\n const oldActualLeft = this.modifyLeftForPrintLayout(colOrGroup, colOrGroup.getOldLeft());\n const actualLeft = this.modifyLeftForPrintLayout(colOrGroup, colOrGroup.getLeft());\n this.setLeft(oldActualLeft);\n this.actualLeft = actualLeft;\n this.beans.colAnimation.executeNextVMTurn(() => {\n if (this.actualLeft === actualLeft) {\n this.setLeft(actualLeft);\n }\n });\n }\n onLeftChanged() {\n const colOrGroup = this.getColumnOrGroup();\n const left = colOrGroup.getLeft();\n this.actualLeft = this.modifyLeftForPrintLayout(colOrGroup, left);\n this.setLeft(this.actualLeft);\n }\n modifyLeftForPrintLayout(colOrGroup, leftPosition) {\n const { gos, visibleCols } = this.beans;\n const printLayout = _isDomLayout(gos, \"print\");\n if (!printLayout) {\n return leftPosition;\n }\n if (colOrGroup.getPinned() === \"left\") {\n return leftPosition;\n }\n const leftWidth = visibleCols.getColsLeftWidth();\n if (colOrGroup.getPinned() === \"right\") {\n const bodyWidth = visibleCols.bodyWidth;\n return leftWidth + bodyWidth + leftPosition;\n }\n return leftWidth + leftPosition;\n }\n setLeft(value) {\n if (_exists(value)) {\n this.eCell.style.left = `${value}px`;\n }\n if (isColumnGroup2(this.columnOrGroup)) {\n const children = this.columnOrGroup.getLeafColumns();\n if (!children.length) {\n return;\n }\n if (children.length > 1) {\n _setAriaColSpan(this.ariaEl, children.length);\n }\n }\n }\n};\n\n// packages/ag-grid-community/src/headerRendering/cells/abstractCell/abstractHeaderCellCtrl.ts\nvar instanceIdSequence4 = 0;\nvar DOM_DATA_KEY_HEADER_CTRL = \"headerCtrl\";\nvar AbstractHeaderCellCtrl = class extends BeanStub {\n constructor(column, rowCtrl) {\n super();\n this.column = column;\n this.rowCtrl = rowCtrl;\n this.resizeToggleTimeout = 0;\n this.resizeMultiplier = 1;\n this.resizeFeature = null;\n this.lastFocusEvent = null;\n this.dragSource = null;\n this.instanceId = column.getUniqueId() + \"-\" + instanceIdSequence4++;\n }\n postConstruct() {\n const refreshTabIndex = this.refreshTabIndex.bind(this);\n this.addManagedPropertyListeners([\"suppressHeaderFocus\"], refreshTabIndex);\n this.addManagedEventListeners({\n overlayExclusiveChanged: refreshTabIndex\n });\n }\n shouldStopEventPropagation(event) {\n const { headerRowIndex, column } = this.beans.focusSvc.focusedHeader;\n const colDef = column.getDefinition();\n const colDefFunc = colDef && colDef.suppressHeaderKeyboardEvent;\n if (!_exists(colDefFunc)) {\n return false;\n }\n const params = _addGridCommonParams(this.gos, {\n colDef,\n column,\n headerRowIndex,\n event\n });\n return !!colDefFunc(params);\n }\n getWrapperHasFocus() {\n const activeEl = _getActiveDomElement(this.beans);\n return activeEl === this.eGui;\n }\n setGui(eGui, compBean) {\n this.eGui = eGui;\n this.addDomData(compBean);\n compBean.addManagedListeners(this.beans.eventSvc, {\n displayedColumnsChanged: this.onDisplayedColumnsChanged.bind(this)\n });\n compBean.addManagedElementListeners(this.eGui, {\n focus: this.onGuiFocus.bind(this)\n });\n this.onDisplayedColumnsChanged();\n this.refreshTabIndex();\n }\n refreshHeaderStyles() {\n const colDef = this.column.getDefinition();\n if (!colDef) {\n return;\n }\n const { headerStyle } = colDef;\n let styles;\n if (typeof headerStyle === \"function\") {\n const cellStyleParams = this.getHeaderClassParams();\n styles = headerStyle(cellStyleParams);\n } else {\n styles = headerStyle;\n }\n if (styles) {\n this.comp.setUserStyles(styles);\n }\n }\n onGuiFocus() {\n this.eventSvc.dispatchEvent({\n type: \"headerFocused\",\n column: this.column\n });\n }\n setupAutoHeight(params) {\n const { wrapperElement, checkMeasuringCallback, compBean } = params;\n const { beans } = this;\n const measureHeight = (timesCalled) => {\n if (!this.isAlive() || !compBean.isAlive()) {\n return;\n }\n const { paddingTop, paddingBottom, borderBottomWidth, borderTopWidth } = _getElementSize(this.eGui);\n const extraHeight = paddingTop + paddingBottom + borderBottomWidth + borderTopWidth;\n const wrapperHeight = wrapperElement.offsetHeight;\n const autoHeight = wrapperHeight + extraHeight;\n if (timesCalled < 5) {\n const doc = _getDocument(beans);\n const notYetInDom = !doc || !doc.contains(wrapperElement);\n const possiblyNoContentYet = autoHeight == 0;\n if (notYetInDom || possiblyNoContentYet) {\n _requestAnimationFrame(beans, () => measureHeight(timesCalled + 1));\n return;\n }\n }\n this.setColHeaderHeight(this.column, autoHeight);\n };\n let isMeasuring = false;\n let stopResizeObserver;\n const checkMeasuring = () => {\n const newValue = this.column.isAutoHeaderHeight();\n if (newValue && !isMeasuring) {\n startMeasuring();\n }\n if (!newValue && isMeasuring) {\n stopMeasuring();\n }\n };\n const startMeasuring = () => {\n isMeasuring = true;\n measureHeight(0);\n this.comp.addOrRemoveCssClass(\"ag-header-cell-auto-height\", true);\n stopResizeObserver = _observeResize(this.beans, wrapperElement, () => measureHeight(0));\n };\n const stopMeasuring = () => {\n isMeasuring = false;\n if (stopResizeObserver) {\n stopResizeObserver();\n }\n this.comp.addOrRemoveCssClass(\"ag-header-cell-auto-height\", false);\n stopResizeObserver = void 0;\n };\n checkMeasuring();\n compBean.addDestroyFunc(() => stopMeasuring());\n compBean.addManagedListeners(this.column, { widthChanged: () => isMeasuring && measureHeight(0) });\n compBean.addManagedEventListeners({\n sortChanged: () => {\n if (isMeasuring) {\n window.setTimeout(() => measureHeight(0));\n }\n }\n });\n if (checkMeasuringCallback) {\n checkMeasuringCallback(checkMeasuring);\n }\n }\n onDisplayedColumnsChanged() {\n const { comp, column, beans, eGui } = this;\n if (!comp || !column || !eGui) {\n return;\n }\n refreshFirstAndLastStyles(comp, column, beans.visibleCols);\n _setAriaColIndex(eGui, beans.visibleCols.getAriaColIndex(column));\n }\n addResizeAndMoveKeyboardListeners(compBean) {\n compBean.addManagedListeners(this.eGui, {\n keydown: this.onGuiKeyDown.bind(this),\n keyup: this.onGuiKeyUp.bind(this)\n });\n }\n refreshTabIndex() {\n const suppressHeaderFocus = _isHeaderFocusSuppressed(this.beans);\n if (this.eGui) {\n _addOrRemoveAttribute(this.eGui, \"tabindex\", suppressHeaderFocus ? null : \"-1\");\n }\n }\n onGuiKeyDown(e) {\n const activeEl = _getActiveDomElement(this.beans);\n const isLeftOrRight = e.key === KeyCode.LEFT || e.key === KeyCode.RIGHT;\n if (this.isResizing) {\n e.preventDefault();\n e.stopImmediatePropagation();\n }\n if (\n // if elements within the header are focused, we don't process the event\n activeEl !== this.eGui || // if shiftKey and altKey are not pressed, it's cell navigation so we don't process the event\n !e.shiftKey && !e.altKey\n ) {\n return;\n }\n if (this.isResizing || isLeftOrRight) {\n e.preventDefault();\n e.stopImmediatePropagation();\n }\n if (!isLeftOrRight) {\n return;\n }\n const isLeft = e.key === KeyCode.LEFT !== this.gos.get(\"enableRtl\");\n const direction = isLeft ? \"left\" : \"right\";\n if (e.altKey) {\n this.isResizing = true;\n this.resizeMultiplier += 1;\n const diff = this.getViewportAdjustedResizeDiff(e);\n this.resizeHeader(diff, e.shiftKey);\n this.resizeFeature?.toggleColumnResizing(true);\n } else {\n this.moveHeader(direction);\n }\n }\n moveHeader(hDirection) {\n this.beans.colMoves?.moveHeader(hDirection, this.eGui, this.column, this.rowCtrl.pinned, this);\n }\n getViewportAdjustedResizeDiff(e) {\n const diff = this.getResizeDiff(e);\n const { pinnedCols } = this.beans;\n return pinnedCols ? pinnedCols.getHeaderResizeDiff(diff, this.column) : diff;\n }\n getResizeDiff(e) {\n const { gos, column } = this;\n let isLeft = e.key === KeyCode.LEFT !== gos.get(\"enableRtl\");\n const pinned = column.getPinned();\n const isRtl = gos.get(\"enableRtl\");\n if (pinned) {\n if (isRtl !== (pinned === \"right\")) {\n isLeft = !isLeft;\n }\n }\n return (isLeft ? -1 : 1) * this.resizeMultiplier;\n }\n onGuiKeyUp() {\n if (!this.isResizing) {\n return;\n }\n if (this.resizeToggleTimeout) {\n window.clearTimeout(this.resizeToggleTimeout);\n this.resizeToggleTimeout = 0;\n }\n this.isResizing = false;\n this.resizeMultiplier = 1;\n this.resizeToggleTimeout = window.setTimeout(() => {\n this.resizeFeature?.toggleColumnResizing(false);\n }, 150);\n }\n handleKeyDown(e) {\n const wrapperHasFocus = this.getWrapperHasFocus();\n switch (e.key) {\n case KeyCode.PAGE_DOWN:\n case KeyCode.PAGE_UP:\n case KeyCode.PAGE_HOME:\n case KeyCode.PAGE_END:\n if (wrapperHasFocus) {\n e.preventDefault();\n }\n }\n }\n addDomData(compBean) {\n const key = DOM_DATA_KEY_HEADER_CTRL;\n const { eGui, gos } = this;\n _setDomData(gos, eGui, key, this);\n compBean.addDestroyFunc(() => _setDomData(gos, eGui, key, null));\n }\n focus(event) {\n const { eGui } = this;\n if (!eGui) {\n return false;\n }\n this.lastFocusEvent = event || null;\n eGui.focus();\n return true;\n }\n focusThis() {\n this.beans.focusSvc.focusedHeader = { headerRowIndex: this.rowCtrl.rowIndex, column: this.column };\n }\n removeDragSource() {\n if (this.dragSource) {\n this.beans.dragAndDrop?.removeDragSource(this.dragSource);\n this.dragSource = null;\n }\n }\n handleContextMenuMouseEvent(mouseEvent, touchEvent, column) {\n const event = mouseEvent ?? touchEvent;\n const { menuSvc, gos } = this.beans;\n if (gos.get(\"preventDefaultOnContextMenu\")) {\n event.preventDefault();\n }\n if (menuSvc?.isHeaderContextMenuEnabled(column)) {\n menuSvc.showHeaderContextMenu(column, mouseEvent, touchEvent);\n }\n this.dispatchColumnMouseEvent(\"columnHeaderContextMenu\", column);\n }\n dispatchColumnMouseEvent(eventType, column) {\n this.eventSvc.dispatchEvent({\n type: eventType,\n column\n });\n }\n setColHeaderHeight(col, height) {\n if (!col.setAutoHeaderHeight(height)) {\n return;\n }\n const { eventSvc } = this;\n if (col.isColumn) {\n eventSvc.dispatchEvent({\n type: \"columnHeaderHeightChanged\",\n column: col,\n columns: [col],\n source: \"autosizeColumnHeaderHeight\"\n });\n } else {\n eventSvc.dispatchEvent({\n type: \"columnGroupHeaderHeightChanged\",\n columnGroup: col,\n source: \"autosizeColumnGroupHeaderHeight\"\n });\n }\n }\n clearComponent() {\n this.removeDragSource();\n this.resizeFeature = null;\n this.comp = null;\n this.eGui = null;\n }\n destroy() {\n super.destroy();\n this.column = null;\n this.lastFocusEvent = null;\n this.rowCtrl = null;\n }\n};\n\n// packages/ag-grid-community/src/headerRendering/cells/column/headerCellCtrl.ts\nvar HeaderCellCtrl = class extends AbstractHeaderCellCtrl {\n constructor() {\n super(...arguments);\n this.refreshFunctions = {};\n this.userHeaderClasses = /* @__PURE__ */ new Set();\n this.ariaDescriptionProperties = /* @__PURE__ */ new Map();\n }\n setComp(comp, eGui, eResize, eHeaderCompWrapper, compBeanInput) {\n this.comp = comp;\n const { rowCtrl, column, beans } = this;\n const { colResize, context, colHover, rangeSvc } = beans;\n const compBean = setupCompBean(this, context, compBeanInput);\n this.setGui(eGui, compBean);\n this.updateState();\n this.setupWidth(compBean);\n this.setupMovingCss(compBean);\n this.setupMenuClass(compBean);\n this.setupSortableClass(compBean);\n this.setupWrapTextClass();\n this.refreshSpanHeaderHeight();\n this.setupAutoHeight({\n wrapperElement: eHeaderCompWrapper,\n checkMeasuringCallback: (checkMeasuring) => this.setRefreshFunction(\"measuring\", checkMeasuring),\n compBean\n });\n this.addColumnHoverListener(compBean);\n this.setupFilterClass(compBean);\n this.setupStylesFromColDef();\n this.setupClassesFromColDef();\n this.setupTooltip();\n this.addActiveHeaderMouseListeners(compBean);\n this.setupSelectAll(compBean);\n this.setupUserComp();\n this.refreshAria();\n if (colResize) {\n this.resizeFeature = compBean.createManagedBean(\n colResize.createResizeFeature(rowCtrl.pinned, column, eResize, comp, this)\n );\n } else {\n _setDisplayed(eResize, false);\n }\n colHover?.createHoverFeature(compBean, [column], eGui);\n rangeSvc?.createRangeHighlightFeature(compBean, column, comp);\n compBean.createManagedBean(new SetLeftFeature(column, eGui, beans));\n compBean.createManagedBean(\n new ManagedFocusFeature(eGui, {\n shouldStopEventPropagation: (e) => this.shouldStopEventPropagation(e),\n onTabKeyDown: () => null,\n handleKeyDown: this.handleKeyDown.bind(this),\n onFocusIn: this.onFocusIn.bind(this),\n onFocusOut: this.onFocusOut.bind(this)\n })\n );\n this.addResizeAndMoveKeyboardListeners(compBean);\n compBean.addManagedPropertyListeners(\n [\"suppressMovableColumns\", \"suppressMenuHide\", \"suppressAggFuncInHeader\", \"enableAdvancedFilter\"],\n () => this.refresh()\n );\n compBean.addManagedListeners(column, { colDefChanged: () => this.refresh() });\n compBean.addManagedListeners(column, { headerHighlightChanged: this.onHeaderHighlightChanged.bind(this) });\n const listener = () => this.checkDisplayName();\n compBean.addManagedEventListeners({\n columnValueChanged: listener,\n columnRowGroupChanged: listener,\n columnPivotChanged: listener,\n headerHeightChanged: this.onHeaderHeightChanged.bind(this)\n });\n compBean.addDestroyFunc(() => {\n this.refreshFunctions = {};\n this.selectAllFeature = null;\n this.dragSourceElement = void 0;\n this.userCompDetails = null;\n this.userHeaderClasses.clear();\n this.ariaDescriptionProperties.clear();\n this.clearComponent();\n });\n }\n resizeHeader(delta, shiftKey) {\n this.beans.colResize?.resizeHeader(this.column, delta, shiftKey);\n }\n getHeaderClassParams() {\n const { column, beans } = this;\n const colDef = column.colDef;\n return _addGridCommonParams(beans.gos, {\n colDef,\n column,\n floatingFilter: false\n });\n }\n setupUserComp() {\n const compDetails = this.lookupUserCompDetails();\n if (compDetails) {\n this.setCompDetails(compDetails);\n }\n }\n setCompDetails(compDetails) {\n this.userCompDetails = compDetails;\n this.comp.setUserCompDetails(compDetails);\n }\n lookupUserCompDetails() {\n const params = this.createParams();\n const colDef = this.column.getColDef();\n return _getHeaderCompDetails(this.beans.userCompFactory, colDef, params);\n }\n createParams() {\n const { menuSvc, sortSvc, colFilter, gos } = this.beans;\n const params = _addGridCommonParams(gos, {\n column: this.column,\n displayName: this.displayName,\n enableSorting: this.column.isSortable(),\n enableMenu: this.menuEnabled,\n enableFilterButton: this.openFilterEnabled && !!menuSvc?.isHeaderFilterButtonEnabled(this.column),\n enableFilterIcon: !!colFilter && (!this.openFilterEnabled || _isLegacyMenuEnabled(this.gos)),\n showColumnMenu: (buttonElement, onClosedCallback) => {\n menuSvc?.showColumnMenu({\n column: this.column,\n buttonElement,\n positionBy: \"button\",\n onClosedCallback\n });\n },\n showColumnMenuAfterMouseClick: (mouseEvent, onClosedCallback) => {\n menuSvc?.showColumnMenu({\n column: this.column,\n mouseEvent,\n positionBy: \"mouse\",\n onClosedCallback\n });\n },\n showFilter: (buttonElement) => {\n menuSvc?.showFilterMenu({\n column: this.column,\n buttonElement,\n containerType: \"columnFilter\",\n positionBy: \"button\"\n });\n },\n progressSort: (multiSort) => {\n sortSvc?.progressSort(this.column, !!multiSort, \"uiColumnSorted\");\n },\n setSort: (sort, multiSort) => {\n sortSvc?.setSortForColumn(this.column, sort, !!multiSort, \"uiColumnSorted\");\n },\n eGridHeader: this.eGui,\n setTooltip: (value, shouldDisplayTooltip) => {\n gos.assertModuleRegistered(\"Tooltip\", 3);\n this.setupTooltip(value, shouldDisplayTooltip);\n }\n });\n return params;\n }\n setupSelectAll(compBean) {\n const { selectionSvc } = this.beans;\n if (!selectionSvc) {\n return;\n }\n this.selectAllFeature = compBean.createManagedBean(selectionSvc.createSelectAllFeature(this.column));\n this.selectAllFeature.setComp(this);\n }\n getSelectAllGui() {\n return this.selectAllFeature?.getCheckboxGui();\n }\n handleKeyDown(e) {\n super.handleKeyDown(e);\n if (e.key === KeyCode.SPACE) {\n this.selectAllFeature?.onSpaceKeyDown(e);\n }\n if (e.key === KeyCode.ENTER) {\n this.onEnterKeyDown(e);\n }\n if (e.key === KeyCode.DOWN && e.altKey) {\n this.showMenuOnKeyPress(e, false);\n }\n }\n onEnterKeyDown(e) {\n if (e.ctrlKey || e.metaKey) {\n this.showMenuOnKeyPress(e, true);\n } else if (this.sortable) {\n this.beans.sortSvc?.progressSort(this.column, e.shiftKey, \"uiColumnSorted\");\n }\n }\n showMenuOnKeyPress(e, isFilterShortcut) {\n const headerComp = this.comp.getUserCompInstance();\n if (!isHeaderComp(headerComp)) {\n return;\n }\n if (headerComp.onMenuKeyboardShortcut(isFilterShortcut)) {\n e.preventDefault();\n }\n }\n onFocusIn(e) {\n if (!this.eGui.contains(e.relatedTarget)) {\n this.focusThis();\n this.announceAriaDescription();\n }\n if (_isKeyboardMode()) {\n this.setActiveHeader(true);\n }\n }\n onFocusOut(e) {\n if (this.eGui.contains(e.relatedTarget)) {\n return;\n }\n this.setActiveHeader(false);\n }\n setupTooltip(value, shouldDisplayTooltip) {\n this.tooltipFeature = this.beans.tooltipSvc?.setupHeaderTooltip(\n this.tooltipFeature,\n this,\n value,\n shouldDisplayTooltip\n );\n }\n setupStylesFromColDef() {\n this.setRefreshFunction(\"headerStyles\", this.refreshHeaderStyles.bind(this));\n this.refreshHeaderStyles();\n }\n setupClassesFromColDef() {\n const refreshHeaderClasses = () => {\n const colDef = this.column.getColDef();\n const classes = _getHeaderClassesFromColDef(colDef, this.gos, this.column, null);\n const oldClasses = this.userHeaderClasses;\n this.userHeaderClasses = new Set(classes);\n classes.forEach((c) => {\n if (oldClasses.has(c)) {\n oldClasses.delete(c);\n } else {\n this.comp.addOrRemoveCssClass(c, true);\n }\n });\n oldClasses.forEach((c) => this.comp.addOrRemoveCssClass(c, false));\n };\n this.setRefreshFunction(\"headerClasses\", refreshHeaderClasses);\n refreshHeaderClasses();\n }\n setDragSource(eSource) {\n this.dragSourceElement = eSource;\n this.removeDragSource();\n if (!eSource || !this.draggable) {\n return;\n }\n this.dragSource = this.beans.colMoves?.setDragSourceForHeader(eSource, this.column, this.displayName) ?? null;\n }\n updateState() {\n const { menuSvc } = this.beans;\n this.menuEnabled = !!menuSvc?.isColumnMenuInHeaderEnabled(this.column);\n this.openFilterEnabled = !!menuSvc?.isFilterMenuInHeaderEnabled(this.column);\n this.sortable = this.column.isSortable();\n this.displayName = this.calculateDisplayName();\n this.draggable = this.workOutDraggable();\n }\n setRefreshFunction(name, func) {\n this.refreshFunctions[name] = func;\n }\n refresh() {\n this.updateState();\n this.refreshHeaderComp();\n this.refreshAria();\n Object.values(this.refreshFunctions).forEach((f) => f());\n }\n refreshHeaderComp() {\n const newCompDetails = this.lookupUserCompDetails();\n if (!newCompDetails) {\n return;\n }\n const compInstance = this.comp.getUserCompInstance();\n const attemptRefresh = compInstance != null && this.userCompDetails.componentClass == newCompDetails.componentClass;\n const headerCompRefreshed = attemptRefresh ? this.attemptHeaderCompRefresh(newCompDetails.params) : false;\n if (headerCompRefreshed) {\n this.setDragSource(this.dragSourceElement);\n } else {\n this.setCompDetails(newCompDetails);\n }\n }\n attemptHeaderCompRefresh(params) {\n const headerComp = this.comp.getUserCompInstance();\n if (!headerComp) {\n return false;\n }\n if (!headerComp.refresh) {\n return false;\n }\n const res = headerComp.refresh(params);\n return res;\n }\n calculateDisplayName() {\n return this.beans.colNames.getDisplayNameForColumn(this.column, \"header\", true);\n }\n checkDisplayName() {\n if (this.displayName !== this.calculateDisplayName()) {\n this.refresh();\n }\n }\n workOutDraggable() {\n const colDef = this.column.getColDef();\n const isSuppressMovableColumns = this.gos.get(\"suppressMovableColumns\");\n const colCanMove = !isSuppressMovableColumns && !colDef.suppressMovable && !colDef.lockPosition;\n return !!colCanMove || !!colDef.enableRowGroup || !!colDef.enablePivot;\n }\n setupWidth(compBean) {\n const listener = () => {\n const columnWidth = this.column.getActualWidth();\n this.comp.setWidth(`${columnWidth}px`);\n };\n compBean.addManagedListeners(this.column, { widthChanged: listener });\n listener();\n }\n setupMovingCss(compBean) {\n const listener = () => {\n this.comp.addOrRemoveCssClass(\"ag-header-cell-moving\", this.column.isMoving());\n };\n compBean.addManagedListeners(this.column, { movingChanged: listener });\n listener();\n }\n setupMenuClass(compBean) {\n const listener = () => {\n this.comp?.addOrRemoveCssClass(\"ag-column-menu-visible\", this.column.isMenuVisible());\n };\n compBean.addManagedListeners(this.column, { menuVisibleChanged: listener });\n listener();\n }\n setupSortableClass(compBean) {\n const updateSortableCssClass = () => {\n this.comp.addOrRemoveCssClass(\"ag-header-cell-sortable\", !!this.sortable);\n };\n updateSortableCssClass();\n this.setRefreshFunction(\"updateSortable\", updateSortableCssClass);\n compBean.addManagedEventListeners({ sortChanged: this.refreshAriaSort.bind(this) });\n }\n setupFilterClass(compBean) {\n const listener = () => {\n const isFilterActive = this.column.isFilterActive();\n this.comp.addOrRemoveCssClass(\"ag-header-cell-filtered\", isFilterActive);\n this.refreshAria();\n };\n compBean.addManagedListeners(this.column, { filterActiveChanged: listener });\n listener();\n }\n setupWrapTextClass() {\n const listener = () => {\n const wrapText = !!this.column.getColDef().wrapHeaderText;\n this.comp.addOrRemoveCssClass(\"ag-header-cell-wrap-text\", wrapText);\n };\n listener();\n this.setRefreshFunction(\"wrapText\", listener);\n }\n onHeaderHighlightChanged() {\n const highlighted = this.column.getHighlighted();\n const beforeOn = highlighted === 0 /* Before */;\n const afterOn = highlighted === 1 /* After */;\n this.comp.addOrRemoveCssClass(\"ag-header-highlight-before\", beforeOn);\n this.comp.addOrRemoveCssClass(\"ag-header-highlight-after\", afterOn);\n }\n onDisplayedColumnsChanged() {\n super.onDisplayedColumnsChanged();\n if (!this.isAlive()) {\n return;\n }\n this.onHeaderHeightChanged();\n }\n onHeaderHeightChanged() {\n this.refreshSpanHeaderHeight();\n }\n refreshSpanHeaderHeight() {\n const { eGui, column, comp, beans } = this;\n const groupHeaderHeight = getGroupRowsHeight(this.beans);\n const isZeroGroupHeight = groupHeaderHeight.reduce((total, next) => total += next, 0) === 0;\n comp.addOrRemoveCssClass(\"ag-header-parent-hidden\", isZeroGroupHeight);\n if (!column.isSpanHeaderHeight()) {\n eGui.style.removeProperty(\"top\");\n eGui.style.removeProperty(\"height\");\n comp.addOrRemoveCssClass(\"ag-header-span-height\", false);\n comp.addOrRemoveCssClass(\"ag-header-span-total\", false);\n return;\n }\n const { numberOfParents, isSpanningTotal } = this.column.getColumnGroupPaddingInfo();\n comp.addOrRemoveCssClass(\"ag-header-span-height\", numberOfParents > 0);\n const headerHeight = getColumnHeaderRowHeight(beans);\n if (numberOfParents === 0) {\n comp.addOrRemoveCssClass(\"ag-header-span-total\", false);\n eGui.style.setProperty(\"top\", `0px`);\n eGui.style.setProperty(\"height\", `${headerHeight}px`);\n return;\n }\n comp.addOrRemoveCssClass(\"ag-header-span-total\", isSpanningTotal);\n let extraHeight = 0;\n for (let i = 0; i < numberOfParents; i++) {\n extraHeight += groupHeaderHeight[groupHeaderHeight.length - 1 - i];\n }\n eGui.style.setProperty(\"top\", `${-extraHeight}px`);\n eGui.style.setProperty(\"height\", `${headerHeight + extraHeight}px`);\n }\n refreshAriaSort() {\n if (this.sortable) {\n const translate = this.getLocaleTextFunc();\n const sort = this.beans.sortSvc?.getDisplaySortForColumn(this.column) || null;\n this.comp.setAriaSort(_getAriaSortState(sort));\n this.setAriaDescriptionProperty(\"sort\", translate(\"ariaSortableColumn\", \"Press ENTER to sort\"));\n } else {\n this.comp.setAriaSort();\n this.setAriaDescriptionProperty(\"sort\", null);\n }\n }\n refreshAriaMenu() {\n if (this.menuEnabled) {\n const translate = this.getLocaleTextFunc();\n this.setAriaDescriptionProperty(\"menu\", translate(\"ariaMenuColumn\", \"Press ALT DOWN to open column menu\"));\n } else {\n this.setAriaDescriptionProperty(\"menu\", null);\n }\n }\n refreshAriaFilterButton() {\n if (this.openFilterEnabled && !_isLegacyMenuEnabled(this.gos)) {\n const translate = this.getLocaleTextFunc();\n this.setAriaDescriptionProperty(\n \"filterButton\",\n translate(\"ariaFilterColumn\", \"Press CTRL ENTER to open filter\")\n );\n } else {\n this.setAriaDescriptionProperty(\"filterButton\", null);\n }\n }\n refreshAriaFiltered() {\n const translate = this.getLocaleTextFunc();\n const isFilterActive = this.column.isFilterActive();\n if (isFilterActive) {\n this.setAriaDescriptionProperty(\"filter\", translate(\"ariaColumnFiltered\", \"Column Filtered\"));\n } else {\n this.setAriaDescriptionProperty(\"filter\", null);\n }\n }\n setAriaDescriptionProperty(property, value) {\n if (value != null) {\n this.ariaDescriptionProperties.set(property, value);\n } else {\n this.ariaDescriptionProperties.delete(property);\n }\n }\n announceAriaDescription() {\n if (!this.eGui.contains(_getActiveDomElement(this.beans))) {\n return;\n }\n const ariaDescription = Array.from(this.ariaDescriptionProperties.keys()).sort((a, b) => a === \"filter\" ? -1 : b.charCodeAt(0) - a.charCodeAt(0)).map((key) => this.ariaDescriptionProperties.get(key)).join(\". \");\n this.beans.ariaAnnounce?.announceValue(ariaDescription, \"columnHeader\");\n }\n refreshAria() {\n this.refreshAriaSort();\n this.refreshAriaMenu();\n this.refreshAriaFilterButton();\n this.refreshAriaFiltered();\n }\n addColumnHoverListener(compBean) {\n this.beans.colHover?.addHeaderColumnHoverListener(compBean, this.comp, this.column);\n }\n addActiveHeaderMouseListeners(compBean) {\n const listener = (e) => this.handleMouseOverChange(e.type === \"mouseenter\");\n const clickListener = () => {\n this.setActiveHeader(true);\n this.dispatchColumnMouseEvent(\"columnHeaderClicked\", this.column);\n };\n const contextMenuListener = (event) => this.handleContextMenuMouseEvent(event, void 0, this.column);\n compBean.addManagedListeners(this.eGui, {\n mouseenter: listener,\n mouseleave: listener,\n click: clickListener,\n contextmenu: contextMenuListener\n });\n }\n handleMouseOverChange(isMouseOver) {\n this.setActiveHeader(isMouseOver);\n this.eventSvc.dispatchEvent({\n type: isMouseOver ? \"columnHeaderMouseOver\" : \"columnHeaderMouseLeave\",\n column: this.column\n });\n }\n setActiveHeader(active) {\n this.comp.addOrRemoveCssClass(\"ag-header-active\", active);\n }\n getAnchorElementForMenu(isFilter) {\n const headerComp = this.comp.getUserCompInstance();\n if (isHeaderComp(headerComp)) {\n return headerComp.getAnchorElementForMenu(isFilter);\n }\n return this.eGui;\n }\n destroy() {\n this.tooltipFeature = this.destroyBean(this.tooltipFeature);\n super.destroy();\n }\n};\nfunction isHeaderComp(headerComp) {\n return typeof headerComp.getAnchorElementForMenu === \"function\" && typeof headerComp.onMenuKeyboardShortcut === \"function\";\n}\n\n// packages/ag-grid-community/src/headerRendering/row/headerRowCtrl.ts\nvar instanceIdSequence5 = 0;\nvar HeaderRowCtrl = class extends BeanStub {\n constructor(rowIndex, pinned, type) {\n super();\n this.rowIndex = rowIndex;\n this.pinned = pinned;\n this.type = type;\n this.instanceId = instanceIdSequence5++;\n const typeClass = type == \"group\" ? `ag-header-row-column-group` : type == \"filter\" ? `ag-header-row-column-filter` : `ag-header-row-column`;\n this.headerRowClass = `ag-header-row ${typeClass}`;\n }\n postConstruct() {\n this.isPrintLayout = _isDomLayout(this.gos, \"print\");\n this.isEnsureDomOrder = this.gos.get(\"ensureDomOrder\");\n }\n /** Checks that every header cell that is currently visible has been rendered.\n * Can only be false under some circumstances when using React\n */\n areCellsRendered() {\n if (!this.comp) {\n return false;\n }\n return this.getHeaderCellCtrls().every((ctrl) => ctrl.eGui != null);\n }\n /**\n *\n * @param comp Proxy to the actual component\n * @param initCompState Should the component be initialised with the current state of the controller. Default: true\n */\n setComp(comp, compBean, initCompState = true) {\n this.comp = comp;\n compBean = setupCompBean(this, this.beans.context, compBean);\n if (initCompState) {\n this.onRowHeightChanged();\n this.onVirtualColumnsChanged();\n }\n this.setWidth();\n this.addEventListeners(compBean);\n }\n getAriaRowIndex() {\n return this.rowIndex + 1;\n }\n addEventListeners(compBean) {\n const onHeightChanged = this.onRowHeightChanged.bind(this);\n const onDisplayedColumnsChanged = this.onDisplayedColumnsChanged.bind(this);\n compBean.addManagedEventListeners({\n columnResized: this.setWidth.bind(this),\n displayedColumnsChanged: onDisplayedColumnsChanged,\n virtualColumnsChanged: (params) => this.onVirtualColumnsChanged(params.afterScroll),\n columnGroupHeaderHeightChanged: onHeightChanged,\n columnHeaderHeightChanged: onHeightChanged,\n gridStylesChanged: onHeightChanged,\n advancedFilterEnabledChanged: onHeightChanged\n });\n compBean.addManagedPropertyListener(\"domLayout\", onDisplayedColumnsChanged);\n compBean.addManagedPropertyListener(\"ensureDomOrder\", (e) => this.isEnsureDomOrder = e.currentValue);\n compBean.addManagedPropertyListeners(\n [\n \"headerHeight\",\n \"pivotHeaderHeight\",\n \"groupHeaderHeight\",\n \"pivotGroupHeaderHeight\",\n \"floatingFiltersHeight\"\n ],\n onHeightChanged\n );\n }\n getHeaderCellCtrl(column) {\n if (!this.headerCellCtrls) {\n return;\n }\n for (const cellCtrl of this.headerCellCtrls.values()) {\n if (cellCtrl.column === column) {\n return cellCtrl;\n }\n }\n return void 0;\n }\n onDisplayedColumnsChanged() {\n this.isPrintLayout = _isDomLayout(this.gos, \"print\");\n this.onVirtualColumnsChanged();\n this.setWidth();\n this.onRowHeightChanged();\n }\n setWidth() {\n const width = this.getWidthForRow();\n this.comp.setWidth(`${width}px`);\n }\n getWidthForRow() {\n const { visibleCols } = this.beans;\n if (this.isPrintLayout) {\n const pinned = this.pinned != null;\n if (pinned) {\n return 0;\n }\n return visibleCols.getContainerWidth(\"right\") + visibleCols.getContainerWidth(\"left\") + visibleCols.getContainerWidth(null);\n }\n return visibleCols.getContainerWidth(this.pinned);\n }\n onRowHeightChanged() {\n const { topOffset, rowHeight } = this.getTopAndHeight();\n this.comp.setTop(topOffset + \"px\");\n this.comp.setHeight(rowHeight + \"px\");\n }\n getTopAndHeight() {\n const { filterManager } = this.beans;\n const sizes = [];\n const groupHeadersHeight = getGroupRowsHeight(this.beans);\n const headerHeight = getColumnHeaderRowHeight(this.beans);\n sizes.push(...groupHeadersHeight);\n sizes.push(headerHeight);\n if (filterManager?.hasFloatingFilters()) {\n sizes.push(getFloatingFiltersHeight(this.beans));\n }\n let topOffset = 0;\n for (let i = 0; i < this.rowIndex; i++) {\n topOffset += sizes[i];\n }\n const rowHeight = sizes[this.rowIndex];\n return { topOffset, rowHeight };\n }\n onVirtualColumnsChanged(afterScroll = false) {\n const ctrlsToDisplay = this.getHeaderCtrls();\n const forceOrder = this.isEnsureDomOrder || this.isPrintLayout;\n this.comp.setHeaderCtrls(ctrlsToDisplay, forceOrder, afterScroll);\n }\n getHeaderCtrls() {\n const oldCtrls = this.headerCellCtrls;\n this.headerCellCtrls = /* @__PURE__ */ new Map();\n const columns = this.getColumnsInViewport();\n for (const child of columns) {\n this.recycleAndCreateHeaderCtrls(child, oldCtrls);\n }\n const isFocusedAndDisplayed = (ctrl) => {\n const { focusSvc, visibleCols } = this.beans;\n const isFocused = focusSvc.isHeaderWrapperFocused(ctrl);\n if (!isFocused) {\n return false;\n }\n const isDisplayed = visibleCols.isVisible(ctrl.column);\n return isDisplayed;\n };\n if (oldCtrls) {\n for (const [id, oldCtrl] of oldCtrls) {\n const keepCtrl = isFocusedAndDisplayed(oldCtrl);\n if (keepCtrl) {\n this.headerCellCtrls.set(id, oldCtrl);\n } else {\n this.destroyBean(oldCtrl);\n }\n }\n }\n return this.getHeaderCellCtrls();\n }\n getHeaderCellCtrls() {\n return Array.from(this.headerCellCtrls?.values() ?? []);\n }\n recycleAndCreateHeaderCtrls(headerColumn, oldCtrls) {\n if (!this.headerCellCtrls) {\n return;\n }\n if (headerColumn.isEmptyGroup()) {\n return;\n }\n const idOfChild = headerColumn.getUniqueId();\n let headerCtrl;\n if (oldCtrls) {\n headerCtrl = oldCtrls.get(idOfChild);\n oldCtrls.delete(idOfChild);\n }\n const forOldColumn = headerCtrl && headerCtrl.column != headerColumn;\n if (forOldColumn) {\n this.destroyBean(headerCtrl);\n headerCtrl = void 0;\n }\n if (headerCtrl == null) {\n switch (this.type) {\n case \"filter\": {\n headerCtrl = this.createBean(\n this.beans.registry.createDynamicBean(\n \"headerFilterCellCtrl\",\n true,\n headerColumn,\n this\n )\n );\n break;\n }\n case \"group\":\n headerCtrl = this.createBean(\n this.beans.registry.createDynamicBean(\n \"headerGroupCellCtrl\",\n true,\n headerColumn,\n this\n )\n );\n break;\n default:\n headerCtrl = this.createBean(new HeaderCellCtrl(headerColumn, this));\n break;\n }\n }\n this.headerCellCtrls.set(idOfChild, headerCtrl);\n }\n getColumnsInViewport() {\n return this.isPrintLayout ? this.getColumnsInViewportPrintLayout() : this.getColumnsInViewportNormalLayout();\n }\n getColumnsInViewportPrintLayout() {\n if (this.pinned != null) {\n return [];\n }\n let viewportColumns = [];\n const actualDepth = this.getActualDepth();\n const { colViewport } = this.beans;\n [\"left\", null, \"right\"].forEach((pinned) => {\n const items = colViewport.getHeadersToRender(pinned, actualDepth);\n viewportColumns = viewportColumns.concat(items);\n });\n return viewportColumns;\n }\n getActualDepth() {\n return this.type == \"filter\" ? this.rowIndex - 1 : this.rowIndex;\n }\n getColumnsInViewportNormalLayout() {\n return this.beans.colViewport.getHeadersToRender(this.pinned, this.getActualDepth());\n }\n findHeaderCellCtrl(column) {\n if (!this.headerCellCtrls) {\n return;\n }\n const allCtrls = this.getHeaderCellCtrls();\n let ctrl;\n if (typeof column === \"function\") {\n ctrl = allCtrls.find(column);\n } else {\n ctrl = allCtrls.find((ctrl2) => ctrl2.column == column);\n }\n return ctrl;\n }\n focusHeader(column, event) {\n const ctrl = this.findHeaderCellCtrl(column);\n if (!ctrl) {\n return false;\n }\n const focused = ctrl.focus(event);\n return focused;\n }\n destroy() {\n this.headerCellCtrls?.forEach((ctrl) => {\n this.destroyBean(ctrl);\n });\n this.headerCellCtrls = void 0;\n super.destroy();\n }\n};\n\n// packages/ag-grid-community/src/headerRendering/rowContainer/headerRowContainerCtrl.ts\nvar HeaderRowContainerCtrl = class extends BeanStub {\n constructor(pinned) {\n super();\n this.pinned = pinned;\n this.hidden = false;\n this.includeFloatingFilter = false;\n this.groupsRowCtrls = [];\n }\n setComp(comp, eGui) {\n this.comp = comp;\n this.eViewport = eGui;\n const { pinnedCols, ctrlsSvc, colModel, colMoves, filterManager } = this.beans;\n this.setupCenterWidth();\n pinnedCols?.setupHeaderPinnedWidth(this);\n this.setupDragAndDrop(colMoves, this.eViewport);\n const onDisplayedColsChanged = this.onDisplayedColumnsChanged.bind(this, filterManager);\n this.addManagedEventListeners({\n gridColumnsChanged: this.onGridColumnsChanged.bind(this),\n displayedColumnsChanged: onDisplayedColsChanged,\n advancedFilterEnabledChanged: onDisplayedColsChanged\n });\n const headerType = `${typeof this.pinned === \"string\" ? this.pinned : \"center\"}Header`;\n ctrlsSvc.register(headerType, this);\n if (colModel.ready) {\n this.refresh();\n }\n }\n getAllCtrls() {\n const res = [...this.groupsRowCtrls];\n if (this.columnsRowCtrl) {\n res.push(this.columnsRowCtrl);\n }\n if (this.filtersRowCtrl) {\n res.push(this.filtersRowCtrl);\n }\n return res;\n }\n refresh(keepColumns = false) {\n const { focusSvc, colModel, filterManager } = this.beans;\n let sequence = 0;\n const focusedHeaderPosition = focusSvc.getFocusHeaderToUseAfterRefresh();\n const refreshColumnGroups = () => {\n const groupRowCount = getHeaderRowCount(colModel) - 1;\n this.groupsRowCtrls = this.destroyBeans(this.groupsRowCtrls);\n for (let i = 0; i < groupRowCount; i++) {\n const ctrl = this.createBean(new HeaderRowCtrl(sequence++, this.pinned, \"group\"));\n this.groupsRowCtrls.push(ctrl);\n }\n };\n const refreshColumns = () => {\n const rowIndex = sequence++;\n const needNewInstance = !this.hidden && (this.columnsRowCtrl == null || !keepColumns || this.columnsRowCtrl.rowIndex !== rowIndex);\n const shouldDestroyInstance = needNewInstance || this.hidden;\n if (shouldDestroyInstance) {\n this.columnsRowCtrl = this.destroyBean(this.columnsRowCtrl);\n }\n if (needNewInstance) {\n this.columnsRowCtrl = this.createBean(new HeaderRowCtrl(rowIndex, this.pinned, \"column\"));\n }\n };\n const refreshFilters = () => {\n this.includeFloatingFilter = !!filterManager?.hasFloatingFilters() && !this.hidden;\n const destroyPreviousComp = () => {\n this.filtersRowCtrl = this.destroyBean(this.filtersRowCtrl);\n };\n if (!this.includeFloatingFilter) {\n destroyPreviousComp();\n return;\n }\n const rowIndex = sequence++;\n if (this.filtersRowCtrl) {\n const rowIndexMismatch = this.filtersRowCtrl.rowIndex !== rowIndex;\n if (!keepColumns || rowIndexMismatch) {\n destroyPreviousComp();\n }\n }\n if (!this.filtersRowCtrl) {\n this.filtersRowCtrl = this.createBean(new HeaderRowCtrl(rowIndex, this.pinned, \"filter\"));\n }\n };\n refreshColumnGroups();\n refreshColumns();\n refreshFilters();\n const allCtrls = this.getAllCtrls();\n this.comp.setCtrls(allCtrls);\n this.restoreFocusOnHeader(focusSvc, focusedHeaderPosition);\n }\n getHeaderCtrlForColumn(column) {\n if (isColumn(column)) {\n return this.columnsRowCtrl?.getHeaderCellCtrl(column);\n }\n if (this.groupsRowCtrls.length === 0) {\n return;\n }\n for (let i = 0; i < this.groupsRowCtrls.length; i++) {\n const ctrl = this.groupsRowCtrls[i].getHeaderCellCtrl(column);\n if (ctrl) {\n return ctrl;\n }\n }\n }\n getHtmlElementForColumnHeader(column) {\n return this.getHeaderCtrlForColumn(column)?.eGui ?? null;\n }\n getRowType(rowIndex) {\n return this.getAllCtrls()[rowIndex]?.type;\n }\n focusHeader(rowIndex, column, event) {\n const allCtrls = this.getAllCtrls();\n const ctrl = allCtrls[rowIndex];\n if (!ctrl) {\n return false;\n }\n return ctrl.focusHeader(column, event);\n }\n getGroupRowCount() {\n return this.groupsRowCtrls.length;\n }\n getGroupRowCtrlAtIndex(index) {\n return this.groupsRowCtrls[index];\n }\n getRowCount() {\n return this.groupsRowCtrls.length + (this.columnsRowCtrl ? 1 : 0) + (this.filtersRowCtrl ? 1 : 0);\n }\n setHorizontalScroll(offset) {\n this.comp.setViewportScrollLeft(offset);\n }\n onScrollCallback(fn) {\n this.addManagedElementListeners(this.eViewport, { scroll: fn });\n }\n destroy() {\n this.filtersRowCtrl = this.destroyBean(this.filtersRowCtrl);\n this.columnsRowCtrl = this.destroyBean(this.columnsRowCtrl);\n this.groupsRowCtrls = this.destroyBeans(this.groupsRowCtrls);\n super.destroy();\n }\n setupDragAndDrop(colMoves, dropContainer) {\n const bodyDropTarget = colMoves?.createBodyDropTarget(this.pinned, dropContainer);\n if (bodyDropTarget) {\n this.createManagedBean(bodyDropTarget);\n }\n }\n restoreFocusOnHeader(focusSvc, position) {\n if (!position) {\n return;\n }\n const { column } = position;\n if (column.getPinned() != this.pinned) {\n return;\n }\n focusSvc.focusHeaderPosition({ headerPosition: position });\n }\n // grid cols have changed - this also means the number of rows in the header can have\n // changed. so we remove all the old rows and insert new ones for a complete refresh\n onGridColumnsChanged() {\n this.refresh(true);\n }\n onDisplayedColumnsChanged(filterManager) {\n const includeFloatingFilter = !!filterManager?.hasFloatingFilters() && !this.hidden;\n if (this.includeFloatingFilter !== includeFloatingFilter) {\n this.refresh(true);\n }\n }\n setupCenterWidth() {\n if (this.pinned != null) {\n return;\n }\n this.createManagedBean(new CenterWidthFeature((width) => this.comp.setCenterWidth(`${width}px`), true));\n }\n};\n\n// packages/ag-grid-community/src/misc/menu/menuService.ts\nvar MenuService = class extends BeanStub {\n constructor() {\n super(...arguments);\n this.beanName = \"menuSvc\";\n }\n postConstruct() {\n const { enterpriseMenuFactory, filterMenuFactory } = this.beans;\n this.activeMenuFactory = enterpriseMenuFactory ?? filterMenuFactory;\n }\n showColumnMenu(params) {\n this.showColumnMenuCommon(this.activeMenuFactory, params, \"columnMenu\");\n }\n showFilterMenu(params) {\n const { enterpriseMenuFactory, filterMenuFactory } = this.beans;\n const menuFactory = enterpriseMenuFactory && _isLegacyMenuEnabled(this.gos) ? enterpriseMenuFactory : filterMenuFactory;\n this.showColumnMenuCommon(menuFactory, params, params.containerType, true);\n }\n showHeaderContextMenu(column, mouseEvent, touchEvent) {\n this.activeMenuFactory?.showMenuAfterContextMenuEvent(column, mouseEvent, touchEvent);\n }\n hidePopupMenu() {\n this.beans.contextMenuSvc?.hideActiveMenu();\n this.activeMenuFactory?.hideActiveMenu();\n }\n isColumnMenuInHeaderEnabled(column) {\n const { suppressHeaderMenuButton } = column.getColDef();\n return !suppressHeaderMenuButton && !!this.activeMenuFactory?.isMenuEnabled(column) && (_isLegacyMenuEnabled(this.gos) || !!this.beans.enterpriseMenuFactory);\n }\n isFilterMenuInHeaderEnabled(column) {\n return !column.getColDef().suppressHeaderFilterButton && !!this.beans.filterManager?.isFilterAllowed(column);\n }\n isHeaderContextMenuEnabled(column) {\n const colDef = column && isColumn(column) ? column.getColDef() : column?.getColGroupDef();\n return !colDef?.suppressHeaderContextMenu && this.gos.get(\"columnMenu\") === \"new\";\n }\n isHeaderMenuButtonAlwaysShowEnabled() {\n return this.isSuppressMenuHide();\n }\n isHeaderMenuButtonEnabled() {\n const menuHides = !this.isSuppressMenuHide();\n const onIpadAndMenuHides = _isIOSUserAgent() && menuHides;\n return !onIpadAndMenuHides;\n }\n isHeaderFilterButtonEnabled(column) {\n return this.isFilterMenuInHeaderEnabled(column) && !_isLegacyMenuEnabled(this.gos) && !this.isFloatingFilterButtonDisplayed(column);\n }\n isFilterMenuItemEnabled(column) {\n return !!this.beans.filterManager?.isFilterAllowed(column) && !_isLegacyMenuEnabled(this.gos) && !this.isFilterMenuInHeaderEnabled(column) && !this.isFloatingFilterButtonDisplayed(column);\n }\n isFloatingFilterButtonEnabled(column) {\n return !column.getColDef().suppressFloatingFilterButton;\n }\n isFloatingFilterButtonDisplayed(column) {\n return !!column.getColDef().floatingFilter && this.isFloatingFilterButtonEnabled(column);\n }\n isSuppressMenuHide() {\n const gos = this.gos;\n const suppressMenuHide = gos.get(\"suppressMenuHide\");\n if (_isLegacyMenuEnabled(gos)) {\n return gos.exists(\"suppressMenuHide\") ? suppressMenuHide : false;\n }\n return suppressMenuHide;\n }\n showColumnMenuCommon(menuFactory, params, containerType, filtersOnly) {\n const { positionBy, onClosedCallback } = params;\n const column = params.column;\n if (positionBy === \"button\") {\n const { buttonElement } = params;\n menuFactory?.showMenuAfterButtonClick(column, buttonElement, containerType, onClosedCallback, filtersOnly);\n } else if (positionBy === \"mouse\") {\n const { mouseEvent } = params;\n menuFactory?.showMenuAfterMouseEvent(column, mouseEvent, containerType, onClosedCallback, filtersOnly);\n } else if (column) {\n const beans = this.beans;\n const ctrlsSvc = beans.ctrlsSvc;\n ctrlsSvc.getScrollFeature().ensureColumnVisible(column, \"auto\");\n _requestAnimationFrame(beans, () => {\n const headerCellCtrl = ctrlsSvc.getHeaderRowContainerCtrl(column.getPinned())?.getHeaderCtrlForColumn(column);\n if (headerCellCtrl) {\n menuFactory?.showMenuAfterButtonClick(\n column,\n headerCellCtrl.getAnchorElementForMenu(filtersOnly),\n containerType,\n onClosedCallback,\n true\n );\n }\n });\n }\n }\n};\nfunction _setColMenuVisible(column, visible, source) {\n if (column.menuVisible !== visible) {\n column.menuVisible = visible;\n column.dispatchColEvent(\"menuVisibleChanged\", source);\n }\n}\n\n// packages/ag-grid-community/src/rendering/overlays/overlayComponent.ts\nvar OverlayComponent = class extends Component {\n constructor() {\n super();\n }\n};\n\n// packages/ag-grid-community/src/rendering/overlays/loadingOverlayComponent.ts\nvar LoadingOverlayComponent2 = class extends OverlayComponent {\n init() {\n const customTemplate = _makeNull(this.gos.get(\"overlayLoadingTemplate\")?.trim());\n this.setTemplate(\n customTemplate ?? /* html */\n ``\n );\n if (!customTemplate) {\n const localeTextFunc = this.getLocaleTextFunc();\n setTimeout(() => {\n this.getGui().textContent = localeTextFunc(\"loadingOoo\", \"Loading...\");\n });\n }\n }\n};\n\n// packages/ag-grid-community/src/rendering/overlays/noRowsOverlayComponent.ts\nvar NoRowsOverlayComponent2 = class extends OverlayComponent {\n init() {\n const customTemplate = _makeNull(this.gos.get(\"overlayNoRowsTemplate\")?.trim());\n this.setTemplate(customTemplate ?? /* html */\n ``);\n if (!customTemplate) {\n const localeTextFunc = this.getLocaleTextFunc();\n setTimeout(() => {\n this.getGui().textContent = localeTextFunc(\"noRowsToShow\", \"No Rows To Show\");\n });\n }\n }\n};\n\n// packages/ag-grid-community/src/utils/icon.ts\nfunction _createIcon(iconName, beans, column) {\n const iconContents = _createIconNoSpan(iconName, beans, column);\n if (iconContents) {\n const { className } = iconContents;\n if (typeof className === \"string\" && className.indexOf(\"ag-icon\") > -1 || typeof className === \"object\" && className[\"ag-icon\"]) {\n return iconContents;\n }\n }\n const eResult = document.createElement(\"span\");\n eResult.appendChild(iconContents);\n return eResult;\n}\nfunction _createIconNoSpan(iconName, beans, column) {\n let userProvidedIcon = null;\n if (iconName === \"smallDown\") {\n _warn(262);\n } else if (iconName === \"smallLeft\") {\n _warn(263);\n } else if (iconName === \"smallRight\") {\n _warn(264);\n }\n const icons = column && column.getColDef().icons;\n if (icons) {\n userProvidedIcon = icons[iconName];\n }\n if (beans.gos && !userProvidedIcon) {\n const optionsIcons = beans.gos.get(\"icons\");\n if (optionsIcons) {\n userProvidedIcon = optionsIcons[iconName];\n }\n }\n if (userProvidedIcon) {\n let rendererResult;\n if (typeof userProvidedIcon === \"function\") {\n rendererResult = userProvidedIcon();\n } else if (typeof userProvidedIcon === \"string\") {\n rendererResult = userProvidedIcon;\n } else {\n _warn(38, { iconName });\n return void 0;\n }\n if (typeof rendererResult === \"string\") {\n return _loadTemplate(rendererResult);\n }\n if (_isNodeOrElement(rendererResult)) {\n return rendererResult;\n }\n _warn(133, { iconName });\n return void 0;\n } else {\n const span = document.createElement(\"span\");\n const iconValue = beans.registry.getIcon(iconName);\n if (!iconValue) {\n beans.validation?.validateIcon(iconName);\n }\n const cssClass = iconValue ?? iconName;\n span.setAttribute(\"class\", `ag-icon ag-icon-${cssClass}`);\n span.setAttribute(\"unselectable\", \"on\");\n _setAriaRole(span, \"presentation\");\n return span;\n }\n}\n\n// packages/ag-grid-community/src/dragAndDrop/dragAndDropImageComponent.css-GENERATED.ts\nvar dragAndDropImageComponentCSS = (\n /*css*/\n `.ag-dnd-ghost{align-items:center;background-color:var(--ag-drag-and-drop-image-background-color);border:var(--ag-drag-and-drop-image-border);border-radius:var(--ag-border-radius);box-shadow:var(--ag-drag-and-drop-image-shadow);color:var(--ag-text-color);cursor:move;display:flex;font-weight:500;gap:var(--ag-cell-widget-spacing);height:var(--ag-header-height);overflow:hidden;padding-left:var(--ag-cell-horizontal-padding);padding-right:var(--ag-cell-horizontal-padding);text-overflow:ellipsis;transform:translateY(calc(var(--ag-spacing)*2));white-space:nowrap}`\n);\n\n// packages/ag-grid-community/src/dragAndDrop/dragAndDropImageComponent.ts\nvar DragAndDropImageComponent2 = class extends Component {\n constructor() {\n super();\n this.dragSource = null;\n this.eIcon = RefPlaceholder;\n this.eLabel = RefPlaceholder;\n this.registerCSS(dragAndDropImageComponentCSS);\n }\n postConstruct() {\n const create = (iconName) => _createIcon(iconName, this.beans, null);\n this.dropIconMap = {\n pinned: create(\"columnMovePin\"),\n hide: create(\"columnMoveHide\"),\n move: create(\"columnMoveMove\"),\n left: create(\"columnMoveLeft\"),\n right: create(\"columnMoveRight\"),\n group: create(\"columnMoveGroup\"),\n aggregate: create(\"columnMoveValue\"),\n pivot: create(\"columnMovePivot\"),\n notAllowed: create(\"dropNotAllowed\")\n };\n }\n init(params) {\n this.dragSource = params.dragSource;\n this.setTemplate(\n /* html */\n ``\n );\n }\n destroy() {\n this.dragSource = null;\n super.destroy();\n }\n setIcon(iconName, shake) {\n const { eIcon, dragSource, dropIconMap, gos } = this;\n _clearElement(eIcon);\n let eIconChild = null;\n if (!iconName) {\n iconName = dragSource?.getDefaultIconName ? dragSource.getDefaultIconName() : \"notAllowed\";\n }\n eIconChild = dropIconMap[iconName];\n eIcon.classList.toggle(\"ag-shake-left-to-right\", shake);\n if (eIconChild === dropIconMap[\"hide\"] && gos.get(\"suppressDragLeaveHidesColumns\")) {\n return;\n }\n if (eIconChild) {\n eIcon.appendChild(eIconChild);\n }\n }\n setLabel(label) {\n this.eLabel.textContent = label;\n }\n};\n\n// packages/ag-grid-community/src/widgets/agAbstractLabel.css-GENERATED.ts\nvar agAbstractLabelCSS = (\n /*css*/\n `.ag-label{white-space:nowrap}:where(.ag-ltr) .ag-label{margin-right:var(--ag-spacing)}:where(.ag-rtl) .ag-label{margin-left:var(--ag-spacing)}:where(.ag-label-align-right) .ag-label{order:1}:where(.ag-ltr) :where(.ag-label-align-right) .ag-label{margin-left:var(--ag-spacing)}:where(.ag-rtl) :where(.ag-label-align-right) .ag-label{margin-right:var(--ag-spacing)}.ag-label-align-right>*{flex:none}.ag-label-align-top{align-items:flex-start;flex-direction:column;>*{align-self:stretch}}.ag-label-ellipsis{flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}:where(.ag-label-align-top) .ag-label{margin-bottom:calc(var(--ag-spacing)*.5)}`\n);\n\n// packages/ag-grid-community/src/widgets/agAbstractLabel.ts\nvar AgAbstractLabel = class extends Component {\n constructor(config, template, components) {\n super(template, components);\n this.labelSeparator = \"\";\n this.labelAlignment = \"left\";\n this.disabled = false;\n this.label = \"\";\n this.config = config || {};\n this.registerCSS(agAbstractLabelCSS);\n }\n postConstruct() {\n this.addCssClass(\"ag-labeled\");\n this.eLabel.classList.add(\"ag-label\");\n const { labelSeparator, label, labelWidth, labelAlignment, disabled } = this.config;\n if (disabled != null) {\n this.setDisabled(disabled);\n }\n if (labelSeparator != null) {\n this.setLabelSeparator(labelSeparator);\n }\n if (label != null) {\n this.setLabel(label);\n }\n if (labelWidth != null) {\n this.setLabelWidth(labelWidth);\n }\n this.setLabelAlignment(labelAlignment || this.labelAlignment);\n this.refreshLabel();\n }\n refreshLabel() {\n const { label, eLabel } = this;\n _clearElement(eLabel);\n if (typeof label === \"string\") {\n eLabel.innerText = label + this.labelSeparator;\n } else if (label) {\n eLabel.appendChild(label);\n }\n if (label === \"\") {\n _setDisplayed(eLabel, false);\n _setAriaRole(eLabel, \"presentation\");\n } else {\n _setDisplayed(eLabel, true);\n _setAriaRole(eLabel, null);\n }\n }\n setLabelSeparator(labelSeparator) {\n if (this.labelSeparator === labelSeparator) {\n return this;\n }\n this.labelSeparator = labelSeparator;\n if (this.label != null) {\n this.refreshLabel();\n }\n return this;\n }\n getLabelId() {\n const eLabel = this.eLabel;\n eLabel.id = eLabel.id || `ag-${this.getCompId()}-label`;\n return eLabel.id;\n }\n getLabel() {\n return this.label;\n }\n setLabel(label) {\n if (this.label === label) {\n return this;\n }\n this.label = label;\n this.refreshLabel();\n return this;\n }\n setLabelAlignment(alignment) {\n const eGui = this.getGui();\n const eGuiClassList = eGui.classList;\n eGuiClassList.toggle(\"ag-label-align-left\", alignment === \"left\");\n eGuiClassList.toggle(\"ag-label-align-right\", alignment === \"right\");\n eGuiClassList.toggle(\"ag-label-align-top\", alignment === \"top\");\n return this;\n }\n setLabelEllipsis(hasEllipsis) {\n this.eLabel.classList.toggle(\"ag-label-ellipsis\", hasEllipsis);\n return this;\n }\n setLabelWidth(width) {\n if (this.label == null) {\n return this;\n }\n _setElementWidth(this.eLabel, width);\n return this;\n }\n setDisabled(disabled) {\n disabled = !!disabled;\n const element = this.getGui();\n _setDisabled(element, disabled);\n element.classList.toggle(\"ag-disabled\", disabled);\n this.disabled = disabled;\n return this;\n }\n isDisabled() {\n return !!this.disabled;\n }\n};\n\n// packages/ag-grid-community/src/widgets/agAbstractField.ts\nvar AgAbstractField = class extends AgAbstractLabel {\n constructor(config, template, components, className) {\n super(config, template, components);\n this.className = className;\n }\n postConstruct() {\n super.postConstruct();\n const { width, value, onValueChange } = this.config;\n if (width != null) {\n this.setWidth(width);\n }\n if (value != null) {\n this.setValue(value);\n }\n if (onValueChange != null) {\n this.onValueChange(onValueChange);\n }\n if (this.className) {\n this.addCssClass(this.className);\n }\n this.refreshAriaLabelledBy();\n }\n setLabel(label) {\n super.setLabel(label);\n this.refreshAriaLabelledBy();\n return this;\n }\n refreshAriaLabelledBy() {\n const ariaEl = this.getAriaElement();\n const labelId = this.getLabelId();\n const label = this.getLabel();\n if (label == null || label == \"\" || _getAriaLabel(ariaEl) !== null) {\n _setAriaLabelledBy(ariaEl, \"\");\n } else {\n _setAriaLabelledBy(ariaEl, labelId ?? \"\");\n }\n }\n setAriaLabel(label) {\n _setAriaLabel(this.getAriaElement(), label);\n this.refreshAriaLabelledBy();\n return this;\n }\n onValueChange(callbackFn) {\n this.addManagedListeners(this, { fieldValueChanged: () => callbackFn(this.getValue()) });\n return this;\n }\n getWidth() {\n return this.getGui().clientWidth;\n }\n setWidth(width) {\n _setFixedWidth(this.getGui(), width);\n return this;\n }\n getPreviousValue() {\n return this.previousValue;\n }\n getValue() {\n return this.value;\n }\n setValue(value, silent) {\n if (this.value === value) {\n return this;\n }\n this.previousValue = this.value;\n this.value = value;\n if (!silent) {\n this.dispatchLocalEvent({ type: \"fieldValueChanged\" });\n }\n return this;\n }\n};\n\n// packages/ag-grid-community/src/widgets/agAbstractInputField.ts\nvar AgAbstractInputField = class extends AgAbstractField {\n constructor(config, className, inputType = \"text\", displayFieldTag = \"input\") {\n super(\n config,\n config?.template ?? /* html */\n `\n \n
\n
\n <${displayFieldTag} data-ref=\"eInput\" class=\"ag-input-field-input\">\n
\n