ag-grid-community/dist/package/main.esm.mjs

Advanced Data Grid / Data Table supporting Javascript / Typescript / React / Angular / Vue

// packages/ag-grid-community/src/entities/agColumn.ts
import { LocalEventService, _escapeString } from "ag-stack";

// packages/ag-grid-community/src/entities/defaultColumnTypes.ts
var DefaultColumnTypes = {
  numericColumn: {
    headerClass: "ag-right-aligned-header",
    cellClass: "ag-right-aligned-cell"
  },
  rightAligned: {
    headerClass: "ag-right-aligned-header",
    cellClass: "ag-right-aligned-cell"
  }
};

// packages/ag-grid-community/src/gridOptionsUtils.ts
import { _doOnce as _doOnce2, _missing } from "ag-stack";

// packages/ag-grid-community/src/utils/mergeDeep.ts
import { _areEqual } from "ag-stack";
var _isProtoPollutionKey = (key) => key === "__proto__" || key === "constructor" || key === "prototype";
var isPlainProto = (value) => {
  const proto = Object.getPrototypeOf(value);
  return proto === Object.prototype || proto === null;
};
var _isPlainObject = (value) => value !== null && typeof value === "object" && isPlainProto(value);
var setKey = (out, key, value, copyUndef, simpleObjects) => {
  let destValue = out[key];
  if (destValue === value) {
    return;
  }
  if (value === null || typeof value !== "object") {
    if (copyUndef || value !== void 0) {
      out[key] = value;
    }
    return;
  }
  if (simpleObjects && destValue == null && isPlainProto(value)) {
    destValue = {};
    out[key] = destValue;
  }
  if (destValue !== null && typeof destValue === "object" && !Array.isArray(destValue)) {
    _mergeDeep(destValue, value, copyUndef, simpleObjects);
  } else {
    out[key] = value;
  }
};
var _mergeDeep = (dest, source, copyUndefined = true, makeCopyOfSimpleObjects = false) => {
  if (source == null || source === "") {
    return;
  }
  if (Array.isArray(source)) {
    for (let i = 0, len = source.length; i < len; ++i) {
      setKey(dest, i, source[i], copyUndefined, makeCopyOfSimpleObjects);
    }
    return;
  }
  for (const key of Object.keys(source)) {
    if (!_isProtoPollutionKey(key)) {
      setKey(dest, key, source[key], copyUndefined, makeCopyOfSimpleObjects);
    }
  }
};
var _mergedEqual = (a, b, topLevelSkipKey) => {
  if (a === b) {
    return true;
  }
  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") {
    return false;
  }
  const aIsArr = Array.isArray(a);
  if (aIsArr !== Array.isArray(b)) {
    return false;
  }
  if (aIsArr) {
    return _areEqual(a, b);
  }
  if (!isPlainProto(a) || !isPlainProto(b)) {
    return false;
  }
  const aKeys = Object.keys(a);
  const bKeys = Object.keys(b);
  const aLen = aKeys.length;
  const bLen = bKeys.length;
  if (topLevelSkipKey === void 0) {
    if (aLen !== bLen) {
      return false;
    }
    for (let i = 0; i < aLen; ++i) {
      const k = aKeys[i];
      if (!(k in b) || !_mergedEqual(a[k], b[k])) {
        return false;
      }
    }
    return true;
  }
  let aSkip = 0;
  for (let i = 0; i < aLen; ++i) {
    const k = aKeys[i];
    if (aSkip === 0 && k === topLevelSkipKey) {
      aSkip = 1;
      continue;
    }
    if (!(k in b) || !_mergedEqual(a[k], b[k])) {
      return false;
    }
  }
  const bSkip = topLevelSkipKey in b ? 1 : 0;
  return aLen - aSkip === bLen - bSkip;
};

// packages/ag-grid-community/src/globalGridOptions.ts
var _GlobalGridOptions = class _GlobalGridOptions {
  /**
   * @param providedOptions
   * @returns Shallow copy of the provided options with global options merged in.
   */
  static applyGlobalGridOptions(providedOptions) {
    if (!_GlobalGridOptions.gridOptions) {
      return { ...providedOptions };
    }
    let mergedGridOps = {};
    _mergeDeep(mergedGridOps, _GlobalGridOptions.gridOptions, true, true);
    if (_GlobalGridOptions.mergeStrategy === "deep") {
      _mergeDeep(mergedGridOps, providedOptions, true, true);
    } else {
      mergedGridOps = { ...mergedGridOps, ...providedOptions };
    }
    if (_GlobalGridOptions.gridOptions.context) {
      mergedGridOps.context = _GlobalGridOptions.gridOptions.context;
    }
    if (providedOptions.context) {
      if (_GlobalGridOptions.mergeStrategy === "deep" && mergedGridOps.context) {
        _mergeDeep(providedOptions.context, mergedGridOps.context, true, true);
      }
      mergedGridOps.context = providedOptions.context;
    }
    return mergedGridOps;
  }
  /**
   * Apply global grid option for a specific option key.
   * If the merge strategy is 'deep' and both global and provided values are objects, they will be merged deeply.
   * Otherwise, the provided value is returned as is.
   * @param optionKey - The key of the grid option to apply.
   * @param providedValue - The value provided to the grid instance.
   * @returns The merged value if applicable, otherwise the provided value.
   */
  static applyGlobalGridOption(optionKey, providedValue) {
    if (_GlobalGridOptions.mergeStrategy === "deep") {
      const globalValue = _getGlobalGridOption(optionKey);
      if (globalValue && typeof globalValue === "object" && typeof providedValue === "object") {
        return _GlobalGridOptions.applyGlobalGridOptions({ [optionKey]: providedValue })[optionKey];
      }
    }
    return providedValue;
  }
};
// eslint-disable-next-line no-restricted-syntax
_GlobalGridOptions.gridOptions = void 0;
// eslint-disable-next-line no-restricted-syntax
_GlobalGridOptions.mergeStrategy = "shallow";
var GlobalGridOptions = _GlobalGridOptions;
function provideGlobalGridOptions(gridOptions, mergeStrategy = "shallow") {
  GlobalGridOptions.gridOptions = gridOptions;
  GlobalGridOptions.mergeStrategy = mergeStrategy;
}
function _getGlobalGridOption(gridOption) {
  return GlobalGridOptions.gridOptions?.[gridOption];
}

// packages/ag-grid-community/src/gridOptionsDefault.ts
var GRID_OPTION_DEFAULTS = {
  suppressContextMenu: false,
  preventDefaultOnContextMenu: false,
  allowContextMenuWithControlKey: false,
  suppressMenuHide: true,
  enableBrowserTooltips: false,
  tooltipTrigger: "hover",
  tooltipShowDelay: 2e3,
  tooltipSwitchShowDelay: 200,
  tooltipHideDelay: 1e4,
  noteTrigger: "hover",
  noteShowDelay: 180,
  noteHideDelay: 220,
  tooltipMouseTrack: false,
  tooltipShowMode: "standard",
  tooltipInteraction: false,
  copyHeadersToClipboard: false,
  copyGroupHeadersToClipboard: false,
  clipboardDelimiter: "	",
  suppressCopyRowsToClipboard: false,
  suppressCopySingleCellRanges: false,
  suppressLastEmptyLineOnPaste: false,
  suppressClipboardPaste: false,
  suppressClipboardApi: false,
  suppressCutToClipboard: false,
  maintainColumnOrder: false,
  enableStrictPivotColumnOrder: false,
  suppressFieldDotNotation: false,
  allowDragFromColumnsToolPanel: false,
  suppressMovableColumns: false,
  suppressColumnMoveAnimation: false,
  suppressMoveWhenColumnDragging: false,
  suppressDragLeaveHidesColumns: false,
  suppressRowGroupHidesColumns: false,
  suppressAutoSize: false,
  autoSizePadding: 20,
  skipHeaderOnAutoSize: false,
  singleClickEdit: false,
  suppressClickEdit: false,
  readOnlyEdit: false,
  stopEditingWhenCellsLoseFocus: false,
  enterNavigatesVertically: false,
  enterNavigatesVerticallyAfterEdit: false,
  enableCellEditingOnBackspace: false,
  undoRedoCellEditing: false,
  undoRedoCellEditingLimit: 10,
  suppressCsvExport: false,
  suppressExcelExport: false,
  cacheQuickFilter: false,
  includeHiddenColumnsInQuickFilter: false,
  excludeChildrenWhenTreeDataFiltering: false,
  enableAdvancedFilter: false,
  includeHiddenColumnsInAdvancedFilter: false,
  enableCharts: false,
  masterDetail: false,
  keepDetailRows: false,
  keepDetailRowsCount: 10,
  detailRowAutoHeight: false,
  tabIndex: 0,
  rowBuffer: 10,
  valueCache: false,
  valueCacheNeverExpires: false,
  enableCellExpressions: false,
  suppressTouch: false,
  suppressFocusAfterRefresh: false,
  suppressBrowserResizeObserver: false,
  suppressPropertyNamesCheck: false,
  suppressChangeDetection: false,
  debug: false,
  suppressLoadingOverlay: false,
  suppressNoRowsOverlay: false,
  pagination: false,
  paginationPageSize: 100,
  paginationPageSizeSelector: true,
  paginationAutoPageSize: false,
  paginateChildRows: false,
  suppressPaginationPanel: false,
  pivotMode: false,
  pivotPanelShow: "never",
  pivotDefaultExpanded: 0,
  pivotSuppressAutoColumn: false,
  suppressExpandablePivotGroups: false,
  functionsReadOnly: false,
  suppressAggFuncInHeader: false,
  alwaysAggregateAtRootLevel: false,
  aggregateOnlyChangedColumns: false,
  suppressAggFilteredOnly: false,
  removePivotHeaderRowWhenSingleValueColumn: false,
  animateRows: true,
  cellFlashDuration: 500,
  cellFadeDuration: 1e3,
  allowShowChangeAfterFilter: false,
  domLayout: "normal",
  ensureDomOrder: false,
  enableRtl: false,
  suppressColumnVirtualisation: false,
  suppressMaxRenderedRowRestriction: false,
  suppressRowVirtualisation: false,
  rowDragManaged: false,
  refreshAfterGroupEdit: false,
  rowDragInsertDelay: 500,
  suppressRowDrag: false,
  suppressMoveWhenRowDragging: false,
  rowDragEntireRow: false,
  rowDragMultiRow: false,
  embedFullWidthRows: false,
  groupDisplayType: "singleColumn",
  groupDefaultExpanded: 0,
  groupMaintainOrder: false,
  groupSelectsChildren: false,
  groupSuppressBlankHeader: false,
  groupSelectsFiltered: false,
  showOpenedGroup: false,
  groupRemoveSingleChildren: false,
  groupRemoveLowestSingleChildren: false,
  groupHideOpenParents: false,
  groupHideColumnsUntilExpanded: false,
  groupAllowUnbalanced: false,
  rowGroupPanelShow: "never",
  suppressMakeColumnVisibleAfterUnGroup: false,
  treeData: false,
  rowGroupPanelSuppressSort: false,
  suppressGroupRowsSticky: false,
  rowModelType: "clientSide",
  asyncTransactionWaitMillis: 50,
  suppressModelUpdateAfterUpdateTransaction: false,
  cacheOverflowSize: 1,
  infiniteInitialRowCount: 1,
  serverSideInitialRowCount: 1,
  cacheBlockSize: 100,
  maxBlocksInCache: -1,
  maxConcurrentDatasourceRequests: 2,
  blockLoadDebounceMillis: 0,
  purgeClosedRowNodes: false,
  serverSideSortAllLevels: false,
  serverSideOnlyRefreshFilteredGroups: false,
  serverSidePivotResultFieldSeparator: "_",
  viewportRowModelPageSize: 5,
  viewportRowModelBufferSize: 5,
  alwaysShowHorizontalScroll: false,
  alwaysShowVerticalScroll: false,
  debounceVerticalScrollbar: false,
  suppressHorizontalScroll: false,
  suppressScrollOnNewData: false,
  suppressScrollWhenPopupsAreOpen: false,
  suppressAnimationFrame: false,
  suppressMiddleClickScrolls: false,
  suppressPreventDefaultOnMouseWheel: false,
  rowMultiSelectWithClick: false,
  suppressRowDeselection: false,
  suppressRowClickSelection: false,
  suppressCellFocus: false,
  suppressHeaderFocus: false,
  suppressMultiRangeSelection: false,
  enableCellTextSelection: false,
  enableRangeSelection: false,
  enableRangeHandle: false,
  enableFillHandle: false,
  fillHandleDirection: "xy",
  suppressClearOnFillReduction: false,
  accentedSort: false,
  unSortIcon: false,
  suppressMultiSort: false,
  alwaysMultiSort: false,
  suppressMaintainUnsortedOrder: false,
  suppressRowHoverHighlight: false,
  suppressRowTransform: false,
  suppressContentVisibilityAuto: true,
  columnHoverHighlight: false,
  deltaSort: false,
  enableGroupEdit: false,
  groupLockGroupColumns: 0,
  serverSideEnableClientSideSort: false,
  suppressServerSideFullWidthLoadingRow: false,
  pivotMaxGeneratedColumns: -1,
  columnMenu: "new",
  reactiveCustomComponents: true,
  suppressSetFilterByDefault: false,
  enableFilterHandlers: false
};

// packages/ag-grid-community/src/utils/number.ts
function _isFiniteNumber(v) {
  return typeof v === "number" && Number.isFinite(v);
}
function _toFiniteNumber(v) {
  const n = Number(v);
  return Number.isFinite(n) ? n : null;
}
function _clamp(value, min, max) {
  return Math.max(min, Math.min(value, max));
}
function _formatNumberCommas(value, getLocaleTextFunc) {
  if (typeof value !== "number") {
    return "";
  }
  const localeTextFunc = getLocaleTextFunc();
  const thousandSeparator = localeTextFunc("thousandSeparator", ",");
  const decimalSeparator = localeTextFunc("decimalSeparator", ".");
  return value.toString().replace(".", decimalSeparator).replace(/(\d)(?=(\d{3})+(?!\d))/g, `$1${thousandSeparator}`);
}

// packages/ag-grid-community/src/baseUrl.ts
var BASE_URL = "https://www.ag-grid.com";

// packages/ag-grid-community/src/utils/log.ts
import { _doOnce } from "ag-stack";
function _logIfDebug(gos, message, ...args) {
  if (gos.get("debug")) {
    console.log("AG Grid: " + message, ...args);
  }
}
function _warnOnce(msg, ...args) {
  _doOnce(() => _consoleWarn(msg, ...args), msg + args?.join(""));
}
function _errorOnce(msg, ...args) {
  _doOnce(() => _consoleError(msg, ...args), msg + args?.join(""));
}
function _consoleError(msg, ...args) {
  console.error("AG Grid: " + msg, ...args);
}
function _consoleWarn(msg, ...args) {
  console.warn("AG Grid: " + msg, ...args);
}

// packages/ag-grid-community/src/modules/moduleRegistry.ts
var allRegisteredModules = /* @__PURE__ */ new Set();
var globalModulesMap = {};
var gridModulesMap = {};
var currentModuleVersion;
var areGridScopedModules = false;
var isUmd = false;
function isValidModuleVersion(module) {
  const [moduleMajor, moduleMinor] = module.version.split(".") || [];
  const [currentModuleMajor, currentModuleMinor] = currentModuleVersion.split(".") || [];
  return moduleMajor === currentModuleMajor && moduleMinor === currentModuleMinor;
}
function runVersionChecks(module) {
  if (!currentModuleVersion) {
    currentModuleVersion = module.version;
  }
  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.`;
  if (!module.version) {
    _errorOnce(errorMsg(`'${module.moduleName}' is incompatible.`));
  } else if (!isValidModuleVersion(module)) {
    _errorOnce(
      errorMsg(
        `'${module.moduleName}' is version ${module.version} but the other modules are version ${currentModuleVersion}.`
      )
    );
  }
  const result = module.validate?.();
  if (result && !result.isValid) {
    _errorOnce(`${result.message}`);
  }
}
function _registerModule(module, gridId) {
  runVersionChecks(module);
  const rowModels = module.rowModels ?? ["all"];
  allRegisteredModules.add(module);
  let moduleStore;
  if (gridId !== void 0) {
    areGridScopedModules = true;
    if (gridModulesMap[gridId] === void 0) {
      gridModulesMap[gridId] = {};
    }
    moduleStore = gridModulesMap[gridId];
  } else {
    moduleStore = globalModulesMap;
  }
  for (const rowModel of rowModels) {
    if (moduleStore[rowModel] === void 0) {
      moduleStore[rowModel] = {};
    }
    moduleStore[rowModel][module.moduleName] = module;
  }
  if (module.dependsOn) {
    for (const dependency of module.dependsOn) {
      _registerModule(dependency, gridId);
    }
  }
}
function _unRegisterGridModules(gridId) {
  delete gridModulesMap[gridId];
}
function _isModuleRegistered(moduleName, gridId, rowModel) {
  const isRegisteredForRowModel = (model) => !!globalModulesMap[model]?.[moduleName] || !!gridModulesMap[gridId]?.[model]?.[moduleName];
  return isRegisteredForRowModel(rowModel) || isRegisteredForRowModel("all");
}
function _areModulesGridScoped() {
  return areGridScopedModules;
}
function _getRegisteredModules(gridId, rowModel) {
  const gridModules = gridModulesMap[gridId] ?? {};
  return [
    ...Object.values(globalModulesMap["all"] ?? {}),
    ...Object.values(gridModules["all"] ?? {}),
    ...Object.values(globalModulesMap[rowModel] ?? {}),
    ...Object.values(gridModules[rowModel] ?? {})
  ];
}
function _getAllRegisteredModules() {
  return new Set(allRegisteredModules);
}
function _getGridRegisteredModules(gridId, rowModel) {
  const gridModules = gridModulesMap[gridId] ?? {};
  return [...Object.values(gridModules["all"] ?? {}), ...Object.values(gridModules[rowModel] ?? {})];
}
function _isUmd() {
  return isUmd;
}
function _setUmd() {
  isUmd = true;
}
var ModuleRegistry = class {
  /**
   * @deprecated v33 Use `registerModules([module])` instead.
   */
  static register(module) {
    _registerModule(module, void 0);
  }
  /**
   * Globally register the given modules for all grids.
   * @param modules - modules to register
   */
  static registerModules(modules) {
    for (const module of modules) {
      _registerModule(module, void 0);
    }
  }
};
function _findEnterpriseCoreModule(modules) {
  for (const module of modules) {
    if ("setLicenseKey" in module) {
      return module;
    }
    if (module.dependsOn) {
      const found = _findEnterpriseCoreModule(module.dependsOn);
      if (found) {
        return found;
      }
    }
  }
  return void 0;
}

// packages/ag-grid-community/src/version.ts
var VERSION = "36.0.2";

// packages/ag-grid-community/src/validation/logging.ts
var MAX_URL_LENGTH = 2e3;
var MIN_PARAM_LENGTH = 100;
var VERSION_PARAM_NAME = "_version_";
var getConsoleMessage = null;
var baseDocLink = `${BASE_URL}/javascript-data-grid`;
function provideValidationServiceLogger(logger) {
  getConsoleMessage = logger;
}
function setValidationDocLink(docLink) {
  baseDocLink = docLink;
}
function getErrorParts(id, args, defaultMessage) {
  return getConsoleMessage?.(id, args) ?? [minifiedLog(id, args, defaultMessage)];
}
function getMsgOrDefault(logger, id, args, isWarning, defaultMessage) {
  logger(`${isWarning ? "warning" : "error"} #${id}`, ...getErrorParts(id, args, defaultMessage));
}
function stringifyObject(inputObj) {
  if (!inputObj) {
    return String(inputObj);
  }
  const object = {};
  for (const prop of Object.keys(inputObj)) {
    if (typeof inputObj[prop] !== "object" && typeof inputObj[prop] !== "function") {
      object[prop] = inputObj[prop];
    }
  }
  return JSON.stringify(object);
}
function stringifyValue(value) {
  let output = value;
  if (value instanceof Error) {
    output = value.toString();
  } else if (typeof value === "object") {
    output = stringifyObject(value);
  }
  return output;
}
function toStringWithNullUndefined(str) {
  return str === void 0 ? "undefined" : str === null ? "null" : str;
}
function getParamsUrl(baseUrl, params) {
  return `${baseUrl}?${params.toString()}`;
}
function truncateUrl(baseUrl, params, maxLength) {
  const sortedParams = Array.from(params.entries()).sort((a, b) => b[1].length - a[1].length);
  let url = getParamsUrl(baseUrl, params);
  for (const [key, value] of sortedParams) {
    if (key === VERSION_PARAM_NAME) {
      continue;
    }
    const excessLength = url.length - maxLength;
    if (excessLength <= 0) {
      break;
    }
    const ellipse = "...";
    const truncateAmount = excessLength + ellipse.length;
    const truncatedValue = value.length - truncateAmount > MIN_PARAM_LENGTH ? value.slice(0, value.length - truncateAmount) + ellipse : value.slice(0, MIN_PARAM_LENGTH) + ellipse;
    params.set(key, truncatedValue);
    url = getParamsUrl(baseUrl, params);
  }
  return url;
}
function getErrorLink(errorNum, args) {
  const params = new URLSearchParams();
  params.append(VERSION_PARAM_NAME, VERSION);
  if (args) {
    for (const key of Object.keys(args)) {
      params.append(key, stringifyValue(args[key]));
    }
  }
  const baseUrl = `${baseDocLink}/errors/${errorNum}`;
  const url = getParamsUrl(baseUrl, params);
  return url.length <= MAX_URL_LENGTH ? url : truncateUrl(baseUrl, params, MAX_URL_LENGTH);
}
var minifiedLog = (errorNum, args, defaultMessage) => {
  const errorLink = getErrorLink(errorNum, args);
  const prefix = `${defaultMessage ? defaultMessage + " \n" : ""}Visit ${errorLink}`;
  if (_isUmd()) {
    return prefix;
  }
  return `${prefix}${defaultMessage ? "" : " \n  Alternatively register the ValidationModule to see the full message in the console."}`;
};
function _warn(...args) {
  getMsgOrDefault(_warnOnce, args[0], args[1], true);
}
function _error(...args) {
  getMsgOrDefault(_errorOnce, args[0], args[1], false);
}
function _logPreInitErr(id, args, defaultMessage) {
  getMsgOrDefault(_errorOnce, id, args, false, defaultMessage);
}
function _logPreInitWarn(id, args, defaultMessage) {
  getMsgOrDefault(_warnOnce, id, args, true, defaultMessage);
}
function getErrMsg(defaultMessage, args) {
  const id = args[0];
  return `error #${id} ` + getErrorParts(id, args[1], defaultMessage).join(" ");
}
function _errMsg(...args) {
  return getErrMsg(void 0, args);
}
function _preInitErrMsg(...args) {
  return getErrMsg("\n", args);
}

// packages/ag-grid-community/src/gridOptionsUtils.ts
function isRowModelType(gos, rowModelType) {
  return gos.get("rowModelType") === rowModelType;
}
function _isClientSideRowModel(gos, _rowModel) {
  return isRowModelType(gos, "clientSide");
}
function _isServerSideRowModel(gos, _rowModel) {
  return isRowModelType(gos, "serverSide");
}
function _isDomLayout(gos, domLayout) {
  return gos.get("domLayout") === domLayout;
}
function _isRowSelection(gos) {
  return _getRowSelectionMode(gos) !== void 0;
}
function _isGetRowHeightFunction(gos) {
  return typeof gos.get("getRowHeight") === "function";
}
function _shouldMaintainColumnOrder(gos, isPivotColumns) {
  if (isPivotColumns) {
    return !gos.get("enableStrictPivotColumnOrder");
  }
  return gos.get("maintainColumnOrder");
}
function _isRowNumbers({ gos, formula }) {
  const rowNumbers = gos.get("rowNumbers");
  return rowNumbers || !!formula?.active && rowNumbers !== false;
}
function _getRowHeightForNode(beans, rowNode, allowEstimate = false, defaultRowHeight) {
  const { gos, environment } = beans;
  if (defaultRowHeight == null) {
    defaultRowHeight = environment.getDefaultRowHeight();
  }
  if (_isGetRowHeightFunction(gos)) {
    if (allowEstimate) {
      return { height: defaultRowHeight, estimated: true };
    }
    const params = {
      node: rowNode,
      data: rowNode.data
    };
    const height = gos.getCallback("getRowHeight")(params);
    if (_isFiniteNumber(height)) {
      if (height === 0) {
        _warn(23);
      }
      return { height: Math.max(1, height), estimated: false };
    }
  }
  if (rowNode.detail && gos.get("masterDetail")) {
    return getMasterDetailRowHeight(gos);
  }
  const gridOptionsRowHeight = gos.get("rowHeight");
  const rowHeight = gridOptionsRowHeight && _isFiniteNumber(gridOptionsRowHeight) ? gridOptionsRowHeight : defaultRowHeight;
  return { height: rowHeight, estimated: false };
}
function getMasterDetailRowHeight(gos) {
  if (gos.get("detailRowAutoHeight")) {
    return { height: 1, estimated: false };
  }
  const defaultRowHeight = gos.get("detailRowHeight");
  if (_isFiniteNumber(defaultRowHeight)) {
    return { height: defaultRowHeight, estimated: false };
  }
  return { height: 300, estimated: false };
}
function _getRowHeightAsNumber(beans) {
  const { environment, gos } = beans;
  const gridOptionsRowHeight = gos.get("rowHeight");
  if (!gridOptionsRowHeight || _missing(gridOptionsRowHeight)) {
    return environment.getDefaultRowHeight();
  }
  const rowHeight = environment.refreshRowHeightVariable();
  if (rowHeight !== -1) {
    return rowHeight;
  }
  _warn(24);
  return environment.getDefaultRowHeight();
}
function _getDomData(gos, element, key) {
  const domData = element[gos.getDomDataKey()];
  return domData ? domData[key] : void 0;
}
function _setDomData(gos, element, key, value) {
  const domDataKey = gos.getDomDataKey();
  let domData = element[domDataKey];
  if (_missing(domData)) {
    domData = {};
    element[domDataKey] = domData;
  }
  domData[key] = value;
}
function _isAnimateRows(gos) {
  if (gos.get("ensureDomOrder")) {
    return false;
  }
  return gos.get("animateRows");
}
function _isGroupRowsSticky(gos) {
  return !(gos.get("paginateChildRows") || gos.get("groupHideOpenParents") || _isDomLayout(gos, "print"));
}
function _isColumnsSortingCoupledToGroup(gos) {
  const autoGroupColumnDef = gos.get("autoGroupColumnDef");
  return !autoGroupColumnDef?.comparator && !gos.get("treeData");
}
function _getGroupAggFiltering(gos) {
  const userValue = gos.get("groupAggFiltering");
  if (typeof userValue === "function") {
    return gos.getCallback("groupAggFiltering");
  }
  if (userValue === true) {
    return () => true;
  }
  return void 0;
}
function _getGrandTotalRow(gos) {
  return gos.get("grandTotalRow");
}
function _getGrandTotalPinnedFloat(grandTotalRow) {
  switch (grandTotalRow) {
    case "pinnedTop":
      return "top";
    case "pinnedBottom":
      return "bottom";
    default:
      return null;
  }
}
function _getGroupTotalRowCallback(gos) {
  const userValue = gos.get("groupTotalRow");
  if (typeof userValue === "function") {
    return gos.getCallback("groupTotalRow");
  }
  return () => userValue ?? void 0;
}
function _isGroupMultiAutoColumn(gos) {
  const isHideOpenParents = !!gos.get("groupHideOpenParents");
  if (isHideOpenParents) {
    return true;
  }
  return gos.get("groupDisplayType") === "multipleColumns";
}
function _isGroupHideColumnsUntilExpanded(gos) {
  return _isGroupMultiAutoColumn(gos) && gos.get("groupHideColumnsUntilExpanded") && _isClientSideRowModel(gos);
}
function _isGroupUseEntireRow(gos, pivotMode) {
  if (pivotMode) {
    return false;
  }
  return gos.get("groupDisplayType") === "groupRows";
}
function _isFullWidthGroupRow(gos, node, pivotMode) {
  return !!node.group && !node.footer && _isGroupUseEntireRow(gos, pivotMode);
}
function _getRowIdCallback(gos) {
  const getRowId = gos.getCallback("getRowId");
  if (getRowId === void 0) {
    return getRowId;
  }
  return (params) => {
    let id = getRowId(params);
    if (typeof id !== "string") {
      _doOnce2(() => _warn(25, { id }), "getRowIdString");
      id = String(id);
    }
    return id;
  };
}
function _canSkipShowingRowGroup(gos, node) {
  const isSkippingGroups = gos.get("groupHideParentOfSingleChild");
  if (isSkippingGroups === true) {
    return true;
  }
  if (isSkippingGroups === "leafGroupsOnly" && node.leafGroup) {
    return true;
  }
  if (gos.get("groupRemoveSingleChildren")) {
    return true;
  }
  if (gos.get("groupRemoveLowestSingleChildren") && node.leafGroup) {
    return true;
  }
  return false;
}
function _getMaxConcurrentDatasourceRequests(gos) {
  const res = gos.get("maxConcurrentDatasourceRequests");
  return res > 0 ? res : void 0;
}
function _shouldUpdateColVisibilityAfterGroup(gos, isGrouped) {
  const preventVisibilityChanges = gos.get("suppressGroupChangesColumnVisibility");
  if (preventVisibilityChanges === true) {
    return false;
  }
  if (isGrouped && preventVisibilityChanges === "suppressHideOnGroup") {
    return false;
  }
  if (!isGrouped && preventVisibilityChanges === "suppressShowOnUngroup") {
    return false;
  }
  const legacySuppressOnGroup = gos.get("suppressRowGroupHidesColumns");
  if (isGrouped && legacySuppressOnGroup === true) {
    return false;
  }
  const legacySuppressOnUngroup = gos.get("suppressMakeColumnVisibleAfterUnGroup");
  if (!isGrouped && legacySuppressOnUngroup === true) {
    return false;
  }
  return true;
}
function _getCheckboxes(selection) {
  return selection?.checkboxes ?? true;
}
function _getHeaderCheckbox(selection) {
  return selection?.mode === "multiRow" && (selection.headerCheckbox ?? true);
}
function _getCheckboxLocation(rowSelection) {
  if (typeof rowSelection !== "object") {
    return void 0;
  }
  return rowSelection.checkboxLocation ?? "selectionColumn";
}
function _getHideDisabledCheckboxes(selection) {
  return selection?.hideDisabledCheckboxes ?? false;
}
function _isUsingNewRowSelectionAPI(gos) {
  const rowSelection = gos.get("rowSelection");
  return typeof rowSelection !== "string";
}
function _isUsingNewCellSelectionAPI(gos) {
  return gos.get("cellSelection") !== void 0;
}
function _getSuppressMultiRanges(gos) {
  const selection = gos.get("cellSelection");
  const useNewAPI = selection !== void 0;
  if (!useNewAPI) {
    return gos.get("suppressMultiRangeSelection");
  }
  return typeof selection !== "boolean" ? selection?.suppressMultiRanges ?? false : false;
}
function _isCellSelectionEnabled(gos) {
  const selection = gos.get("cellSelection");
  const useNewAPI = selection !== void 0;
  return useNewAPI ? !!selection : gos.get("enableRangeSelection");
}
function _getFillHandle(gos) {
  const selection = gos.get("cellSelection");
  const useNewAPI = selection !== void 0;
  if (!useNewAPI) {
    return {
      mode: "fill",
      setFillValue: gos.get("fillOperation"),
      direction: gos.get("fillHandleDirection"),
      suppressClearOnFillReduction: gos.get("suppressClearOnFillReduction")
    };
  }
  return typeof selection !== "boolean" && selection.handle?.mode === "fill" ? selection.handle : void 0;
}
function _getEnableColumnSelection(gos) {
  const cellSelection = gos.get("cellSelection") ?? false;
  return (typeof cellSelection === "object" && cellSelection.enableColumnSelection) ?? false;
}
function _getEnableClickSelection(gos) {
  const selection = gos.get("rowSelection") ?? "single";
  if (typeof selection === "string") {
    const suppressRowClickSelection = gos.get("suppressRowClickSelection");
    const suppressRowDeselection = gos.get("suppressRowDeselection");
    if (suppressRowClickSelection && suppressRowDeselection) {
      return false;
    } else if (suppressRowClickSelection) {
      return "enableDeselection";
    } else if (suppressRowDeselection) {
      return "enableSelection";
    } else {
      return true;
    }
  }
  return selection.mode === "singleRow" || selection.mode === "multiRow" ? selection.enableClickSelection ?? false : false;
}
function _getEnableSelection(gos) {
  const enableClickSelection = _getEnableClickSelection(gos);
  return enableClickSelection === true || enableClickSelection === "enableSelection";
}
function _getEnableDeselection(gos) {
  const enableClickSelection = _getEnableClickSelection(gos);
  return enableClickSelection === true || enableClickSelection === "enableDeselection";
}
function _getIsRowSelectable(gos) {
  const selection = gos.get("rowSelection");
  if (typeof selection === "string") {
    return gos.get("isRowSelectable");
  }
  return selection?.isRowSelectable;
}
function _getRowSelectionMode(arg) {
  const selection = "beanName" in arg && arg.beanName === "gos" ? arg.get("rowSelection") : arg.rowSelection;
  if (typeof selection === "string") {
    switch (selection) {
      case "multiple":
        return "multiRow";
      case "single":
        return "singleRow";
      default:
        return;
    }
  }
  switch (selection?.mode) {
    case "multiRow":
    case "singleRow":
      return selection.mode;
    default:
      return;
  }
}
function _isMultiRowSelection(arg) {
  const mode = _getRowSelectionMode(arg);
  return mode === "multiRow";
}
function _getEnableSelectionWithoutKeys(gos) {
  const selection = gos.get("rowSelection");
  if (typeof selection === "string") {
    return gos.get("rowMultiSelectWithClick");
  }
  return selection?.enableSelectionWithoutKeys ?? false;
}
function _getGroupSelection(gos) {
  const selection = gos.get("rowSelection");
  if (typeof selection === "string") {
    const groupSelectsChildren = gos.get("groupSelectsChildren");
    const groupSelectsFiltered = gos.get("groupSelectsFiltered");
    if (groupSelectsChildren && groupSelectsFiltered) {
      return "filteredDescendants";
    } else if (groupSelectsChildren) {
      return "descendants";
    } else {
      return "self";
    }
  }
  return selection?.mode === "multiRow" ? selection.groupSelects : void 0;
}
function _getSelectAll(gos, defaultValue = true) {
  const rowSelection = gos.get("rowSelection");
  if (typeof rowSelection !== "object") {
    return defaultValue ? "all" : void 0;
  }
  return rowSelection.mode === "multiRow" ? rowSelection.selectAll : "all";
}
function _getCtrlASelectsRows(gos) {
  const rowSelection = gos.get("rowSelection");
  if (typeof rowSelection === "string") {
    return false;
  }
  return rowSelection?.mode === "multiRow" ? rowSelection.ctrlASelectsRows ?? false : false;
}
function _getGroupSelectsDescendants(gos) {
  const groupSelection = _getGroupSelection(gos);
  return groupSelection === "descendants" || groupSelection === "filteredDescendants";
}
function _getMasterSelects(gos) {
  const rowSelection = gos.get("rowSelection");
  return typeof rowSelection === "object" && rowSelection.masterSelects || "self";
}
function _isSetFilterByDefault(gos) {
  return gos.isModuleRegistered("SetFilter") && !gos.get("suppressSetFilterByDefault");
}
function _isLegacyMenuEnabled(gos) {
  return gos.get("columnMenu") === "legacy";
}
function _isColumnMenuAnchoringEnabled(gos) {
  return !_isLegacyMenuEnabled(gos);
}
function _getCallbackForEvent(eventName) {
  if (!eventName || eventName.length < 2) {
    return eventName;
  }
  return "on" + eventName[0].toUpperCase() + eventName.substring(1);
}
function _combineAttributesAndGridOptions(gridOptions, component, gridOptionsKeys) {
  if (typeof gridOptions !== "object") {
    gridOptions = {};
  }
  const mergedOptions = { ...gridOptions };
  for (const key of gridOptionsKeys) {
    const value = component[key];
    if (typeof value !== "undefined") {
      mergedOptions[key] = value;
    }
  }
  return mergedOptions;
}
function _processOnChange(changes, api) {
  if (!changes) {
    return;
  }
  const gridChanges = {};
  let hasChanges = false;
  for (const key of Object.keys(changes)) {
    gridChanges[key] = changes[key];
    hasChanges = true;
  }
  if (!hasChanges) {
    return;
  }
  const internalUpdateEvent = {
    type: "gridOptionsChanged",
    options: gridChanges
  };
  api.dispatchEvent(internalUpdateEvent);
  const event = {
    type: "componentStateChanged",
    ...gridChanges
  };
  api.dispatchEvent(event);
}
function _addGridCommonParams(gos, params) {
  return gos.addCommon(params);
}
function _getGridOption(providedGridOptions, gridOption) {
  return providedGridOptions[gridOption] ?? providedGridOptions[`gridOptions`]?.[gridOption] ?? _getGlobalGridOption(gridOption) ?? GRID_OPTION_DEFAULTS[gridOption];
}
function _interpretAsRightClick({ gos }, event) {
  return event.button === 2 || event.ctrlKey && gos.get("allowContextMenuWithControlKey");
}

// packages/ag-grid-community/src/columns/colDefUtils.ts
function _createUserColumn(beans, userColDef, colId, isPrimary, buildToken) {
  const merged = _addColumnDefaultAndTypes(beans, userColDef, colId);
  const column = new AgColumn(merged, userColDef, colId, isPrimary, "user");
  column.buildToken = buildToken;
  beans.context.createBean(column);
  return column;
}
function _addColumnDefaultAndTypes(beans, colDef, colId, isAutoCol) {
  const { gos, dataTypeSvc } = beans;
  const res = {};
  const defaultColDef = gos.get("defaultColDef");
  _mergeDeep(res, defaultColDef, false, true);
  const dataTypeDefinitionColumnType = dataTypeSvc?.updateColDefAndGetColumnType(res, colDef, colId);
  const columnTypes = colDef.type ?? dataTypeDefinitionColumnType ?? res.type;
  res.type = columnTypes;
  if (columnTypes) {
    assignColumnTypes(beans, convertColumnTypes(columnTypes), res);
  }
  const cellDataType = res.cellDataType;
  _mergeDeep(res, colDef, false, true);
  if (cellDataType !== void 0) {
    res.cellDataType = cellDataType;
  }
  const autoGroupColDef = gos.get("autoGroupColumnDef");
  if (autoGroupColDef && colDef.rowGroup && _isColumnsSortingCoupledToGroup(gos)) {
    _mergeDeep(
      res,
      { sort: autoGroupColDef.sort, initialSort: autoGroupColDef.initialSort },
      false,
      true
    );
  }
  dataTypeSvc?.postProcess(res);
  dataTypeSvc?.validateColDef(res, colDef, defaultColDef, colId);
  gos.validateColDef(res, colId, isAutoCol);
  return res;
}
function assignColumnTypes(beans, typeKeys, colDefMerged) {
  const typeKeysLen = typeKeys.length;
  if (typeKeysLen === 0) {
    return;
  }
  const userTypes = beans.gos.get("columnTypes");
  if (userTypes == null) {
    mergeTypeKeys(colDefMerged, typeKeys, typeKeysLen, DefaultColumnTypes);
    return;
  }
  const allColumnTypes = { ...DefaultColumnTypes };
  const userKeys = Object.keys(userTypes);
  for (let i = 0, len = userKeys.length; i < len; ++i) {
    const key = userKeys[i];
    const value = userTypes[key];
    if (key in allColumnTypes) {
      _warn(34, { key });
    } else {
      if (value.type) {
        _warn(35);
      }
      allColumnTypes[key] = value;
    }
  }
  mergeTypeKeys(colDefMerged, typeKeys, typeKeysLen, allColumnTypes);
}
function mergeTypeKeys(colDefMerged, typeKeys, typeKeysLen, typeMap) {
  for (let i = 0; i < typeKeysLen; ++i) {
    const t = typeKeys[i].trim();
    const typeColDef = typeMap[t];
    if (typeColDef) {
      _mergeDeep(colDefMerged, typeColDef, false, true);
    } else {
      _warn(36, { t });
    }
  }
}

// packages/ag-grid-community/src/columns/columnStateUtils.ts
import { _areEqual as _areEqual2, _symmetricDiff } from "ag-stack";

// packages/ag-grid-community/src/columnMove/columnMoveUtils.ts
import { _indexMap } from "ag-stack";

// packages/ag-grid-community/src/context/beanStub.ts
import { AgBeanStub } from "ag-stack";
var BeanStub = AgBeanStub;

// packages/ag-grid-community/src/entities/agProvidedColumnGroup.ts
function isProvidedColumnGroup(col) {
  return col instanceof AgProvidedColumnGroup;
}
var AgProvidedColumnGroup = class extends BeanStub {
  constructor(colGroupDef, groupId, padding, level) {
    super();
    this.colGroupDef = colGroupDef;
    this.groupId = groupId;
    this.padding = padding;
    this.level = level;
    this.isColumn = false;
    this.expandable = false;
    this.expanded = false;
    /** Most recent build token that claimed this group — detects "already used in this refresh". */
    this.buildToken = 0;
    /** Packed `AgColumnGroup` display instances by dense per-refresh `partId` (`displayInstances[0]` is primary), lazily allocated and pruned by `columnGroupService`. */
    this.displayInstances = null;
    /** Cache previous `setExpandable` visibility so `AgColumn.setVisible` ancestor walk can stop when unchanged. */
    this.lastVisible = false;
    // stable key for framework (React) rendering and old-vs-new destroy diffing
    this.instanceId = getNextColInstanceId();
    this.expanded = !!colGroupDef?.openByDefault;
  }
  getInstanceId() {
    return this.instanceId;
  }
  getOriginalParent() {
    return this.originalParent;
  }
  getLevel() {
    return this.level;
  }
  /** Visible iff at least one child is visible. */
  isVisible() {
    const children = this.children;
    for (let i = 0, len = children.length; i < len; ++i) {
      if (children[i].isVisible()) {
        return true;
      }
    }
    return false;
  }
  isPadding() {
    return this.padding;
  }
  setExpanded(expanded) {
    expanded = !!expanded;
    if (this.expanded === expanded) {
      return false;
    }
    this.expanded = expanded;
    this.dispatchLocalEvent({ type: "expandedChanged" });
    return true;
  }
  isExpandable() {
    return this.expandable;
  }
  isExpanded() {
    return this.expanded;
  }
  getGroupId() {
    return this.groupId;
  }
  getId() {
    return this.groupId;
  }
  getChildren() {
    return this.children;
  }
  getColGroupDef() {
    return this.colGroupDef;
  }
  getLeafColumns() {
    const result = [];
    this.addLeafColumns(result);
    return result;
  }
  addLeafColumns(leafColumns) {
    const children = this.children;
    for (let i = 0, len = children.length; i < len; ++i) {
      const child = children[i];
      if (child.isColumn) {
        leafColumns.push(child);
      } else {
        child.addLeafColumns(leafColumns);
      }
    }
  }
  getColumnGroupShow() {
    return this.colGroupDef?.columnGroupShow;
  }
  /** Recompute child-driven expandability and return whether `AgColumn.setVisible` should continue ancestor walking. */
  setExpandable() {
    if (this.padding) {
      return true;
    }
    const flags = walkForExpandFlags(this.children, 0);
    const expandable = flags === EXPANDABLE_ALL;
    if (this.expandable !== expandable) {
      this.expandable = expandable;
      this.dispatchLocalEvent({ type: "expandableChanged" });
    }
    const visible = flags !== 0;
    if (this.lastVisible === visible) {
      return false;
    }
    this.lastVisible = visible;
    return true;
  }
};
var FLAG_SHOWING_WHEN_OPEN = 1;
var FLAG_SHOWING_WHEN_CLOSED = 2;
var FLAG_CHANGEABLE = 4;
var EXPANDABLE_ALL = 7;
var walkForExpandFlags = (items, flags) => {
  for (let i = 0, n = items.length; i < n; ++i) {
    const item = items[i];
    if (isProvidedColumnGroup(item) && item.padding) {
      flags = walkForExpandFlags(item.children, flags);
    } else if (item.isVisible()) {
      const show = item.getColumnGroupShow();
      if (show === "open") {
        flags |= FLAG_SHOWING_WHEN_OPEN | FLAG_CHANGEABLE;
      } else if (show === "closed") {
        flags |= FLAG_SHOWING_WHEN_CLOSED | FLAG_CHANGEABLE;
      } else {
        flags |= FLAG_SHOWING_WHEN_OPEN | FLAG_SHOWING_WHEN_CLOSED;
      }
    }
    if (flags === EXPANDABLE_ALL) {
      return flags;
    }
  }
  return flags;
};

// packages/ag-grid-community/src/columnMove/columnMoveUtils.ts
function placeLockedColumns(cols, gos) {
  let leftCount = 0;
  let rightCount = 0;
  const len = cols.length;
  let firstLeftIdx = len;
  let lastLeftIdx = -1;
  let firstRightIdx = len;
  let lastRightIdx = -1;
  for (let i = 0; i < len; ++i) {
    const pos = cols[i].colDef.lockPosition;
    if (pos === "right") {
      ++rightCount;
      if (firstRightIdx === len) {
        firstRightIdx = i;
      }
      lastRightIdx = i;
    } else if (pos === "left" || pos === true) {
      ++leftCount;
      if (firstLeftIdx === len) {
        firstLeftIdx = i;
      }
      lastLeftIdx = i;
    }
  }
  if (leftCount === 0 && rightCount === 0) {
    return cols;
  }
  let leftIdx;
  let normalIdx;
  let rightIdx;
  if (gos.get("enableRtl")) {
    if (lastRightIdx === rightCount - 1 && firstLeftIdx === len - leftCount) {
      return cols;
    }
    rightIdx = 0;
    normalIdx = rightCount;
    leftIdx = len - leftCount;
  } else {
    if (lastLeftIdx === leftCount - 1 && firstRightIdx === len - rightCount) {
      return cols;
    }
    leftIdx = 0;
    normalIdx = leftCount;
    rightIdx = len - rightCount;
  }
  const result = new Array(len);
  for (let i = 0; i < len; ++i) {
    const col = cols[i];
    const pos = col.colDef.lockPosition;
    let idx;
    if (pos === "right") {
      idx = rightIdx++;
    } else if (pos === "left" || pos === true) {
      idx = leftIdx++;
    } else {
      idx = normalIdx++;
    }
    result[idx] = col;
  }
  return result;
}
function doesMovePassMarryChildren(allColumnsCopy, gridBalancedTree) {
  const positionByCol = _indexMap(allColumnsCopy);
  let min = 0;
  let max = 0;
  let count = 0;
  const accumulate = (children) => {
    for (let i = 0, len = children.length; i < len; ++i) {
      const child = children[i];
      if (isProvidedColumnGroup(child)) {
        accumulate(child.children);
        continue;
      }
      const idx = positionByCol.get(child) ?? -1;
      if (count === 0) {
        min = idx;
        max = idx;
      } else if (idx < min) {
        min = idx;
      } else if (idx > max) {
        max = idx;
      }
      ++count;
    }
  };
  const visit = (tree) => {
    for (let i = 0, len = tree.length; i < len; ++i) {
      const child = tree[i];
      if (!isProvidedColumnGroup(child)) {
        continue;
      }
      if (child.colGroupDef?.marryChildren) {
        count = 0;
        accumulate(child.children);
        if (count > 1 && max - min > count - 1) {
          return false;
        }
      }
      if (!visit(child.children)) {
        return false;
      }
    }
    return true;
  };
  return visit(gridBalancedTree);
}

// packages/ag-grid-community/src/columns/columnEventUtils.ts
function getCommonValue(cols, valueGetter) {
  if (!cols || cols.length == 0) {
    return void 0;
  }
  const firstValue = valueGetter(cols[0]);
  for (let i = 1; i < cols.length; i++) {
    if (firstValue !== valueGetter(cols[i])) {
      return void 0;
    }
  }
  return firstValue;
}
function dispatchColumnPinnedEvent(eventSvc, changedColumns, source) {
  if (!changedColumns.length) {
    return;
  }
  const column = changedColumns.length === 1 ? changedColumns[0] : null;
  const pinned = getCommonValue(changedColumns, (col) => col.getPinned());
  eventSvc.dispatchEvent({
    type: "columnPinned",
    // mistake in typing, 'undefined' should be allowed, as 'null' means 'not pinned'
    pinned: pinned != null ? pinned : null,
    columns: changedColumns,
    column,
    source
  });
}
function dispatchColumnVisibleEvent(eventSvc, changedColumns, source) {
  if (!changedColumns.length) {
    return;
  }
  const column = changedColumns.length === 1 ? changedColumns[0] : null;
  const visible = getCommonValue(changedColumns, (col) => col.isVisible());
  eventSvc.dispatchEvent({
    type: "columnVisible",
    visible,
    columns: changedColumns,
    column,
    source
  });
}
function _dispatchColumnChangedEvent(eventSvc, type, columns, source) {
  eventSvc.dispatchEvent({
    type,
    columns,
    column: columns?.length == 1 ? columns[0] : null,
    source
  });
}
function dispatchColumnResizedEvent(eventSvc, columns, finished, source, flexColumns = null) {
  if (columns?.length) {
    eventSvc.dispatchEvent({
      type: "columnResized",
      columns,
      column: columns.length === 1 ? columns[0] : null,
      flexColumns,
      finished,
      source
    });
  }
}

// packages/ag-grid-community/src/columns/columnStateUtils.ts
var updateSomeColumnState = (beans, column, hide, sort, sortIndex, pinned, flex, source) => {
  const { sortSvc, pinnedCols, colFlex } = beans;
  if (hide !== void 0) {
    column.setVisible(!hide, source);
  }
  if (sortSvc) {
    sortSvc.updateColSort(column, sort, source);
    if (sortIndex !== void 0) {
      sortSvc.setColSortIndex(column, sortIndex);
    }
  }
  if (pinned !== void 0) {
    pinnedCols?.setColPinned(column, pinned);
  }
  if (flex !== void 0) {
    colFlex?.setColFlex(column, flex);
  }
};
function _setColsVisible(beans, keys, visible = false, source, filterLockedColumns = false) {
  const colModel = beans.colModel;
  const newVisible = visible === true;
  let changed = null;
  for (let i = 0, len = keys.length; i < len; ++i) {
    const key = keys[i];
    const col = typeof key === "string" ? colModel.getCol(key) : key;
    if (col === void 0 || filterLockedColumns && col.colDef.lockVisible) {
      continue;
    }
    if (col.visible !== newVisible) {
      col.setVisible(newVisible, source);
      changed ?? (changed = []);
      changed.push(col);
    }
  }
  if (changed) {
    const { colAnimation, eventSvc } = beans;
    colAnimation?.start();
    colModel.refreshColsDerivedState();
    beans.visibleCols.refresh(source, false);
    eventSvc.dispatchEvent({ type: "columnEverythingChanged", source });
    dispatchColumnVisibleEvent(eventSvc, changed, source);
    colAnimation?.finish();
  }
}
function _applyColumnState(beans, params, source) {
  const { colModel, colAnimation, calculatedColsSvc } = beans;
  const state = params.state;
  if (state && !Array.isArray(state)) {
    _warn(32);
    return false;
  }
  if (state && calculatedColsSvc?.restoreDynamicColumnDefs(state)) {
    calculatedColsSvc.refreshDynamicColumns(source);
  }
  const providedCols = colModel.colDefList;
  const selectionCol = beans.selectionColSvc?.column;
  if (!providedCols.length && !selectionCol) {
    return false;
  }
  colAnimation?.start();
  const stateChanges = captureColumnStateChanges(beans);
  let unmatched = applyStateToCols(beans, state ?? null, providedCols, params, source, true);
  if (unmatched !== null || params.defaultState) {
    const pivotResultColsList = beans.pivotResultCols?.pivotCols;
    unmatched = applyStateToCols(beans, unmatched, pivotResultColsList, params, source, false);
  }
  finalizeChange(beans, params, source, stateChanges);
  colAnimation?.finish();
  return unmatched === null;
}
function applyStateToCols(beans, states, existingColumns, params, source, primaryPass) {
  const colModel = beans.colModel;
  const defaultState = params.defaultState;
  let autoColStates = null;
  let selectionColStates = null;
  let unmatchedStates = null;
  const matched = defaultState ? /* @__PURE__ */ new Set() : null;
  if (states) {
    for (let i = 0, len = states.length; i < len; ++i) {
      const state = states[i];
      const colId = state.colId;
      let column;
      if (colId != null) {
        if (colId.startsWith(GROUP_AUTO_COLUMN_ID)) {
          autoColStates ?? (autoColStates = []);
          autoColStates.push(state);
          continue;
        }
        if (colId.startsWith(SELECTION_COLUMN_ID)) {
          selectionColStates ?? (selectionColStates = []);
          selectionColStates.push(state);
          continue;
        }
        if (primaryPass) {
          column = colModel.getNonPivotColById(colId);
        } else {
          const col = colModel.getCol(colId);
          column = col?.colDef.pivotKeys == null ? null : col;
        }
      }
      if (!column) {
        unmatchedStates ?? (unmatchedStates = []);
        unmatchedStates.push(state);
      } else {
        applyFieldState(beans, column, state, defaultState, source);
        matched?.add(column);
      }
    }
  }
  if (matched !== null && existingColumns) {
    for (let i = 0, len = existingColumns.length; i < len; ++i) {
      const col = existingColumns[i];
      if (!matched.has(col)) {
        applyFieldState(beans, col, null, defaultState, source);
      }
    }
  }
  if (primaryPass) {
    applyStructuralStateChanges(beans, autoColStates, selectionColStates, defaultState, source);
  }
  return unmatchedStates;
}
function applyStructuralStateChanges(beans, autoColStates, selectionColStates, defaultState, source) {
  const { autoColSvc, selectionColSvc, rowGroupColsSvc, pivotColsSvc, valueColsSvc } = beans;
  rowGroupColsSvc?.sortByPendingState()