@mui/x-data-grid-premium 5.13.1 → 5.14.0

package/node/hooks/features/aggregation/wrapColumnWithAggregation.js

@@ -0,0 +1,279 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.wrapColumnWithAggregationValue = exports.unwrapColumnFromAggregation = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _gridAggregationSelectors = require("./gridAggregationSelectors");
+
+var _GridFooterCell = require("../../../components/GridFooterCell");
+
+var _GridAggregationHeader = require("../../../components/GridAggregationHeader");
+
+var _jsxRuntime = require("react/jsx-runtime");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const AGGREGATION_WRAPPABLE_PROPERTIES = ['valueGetter', 'valueFormatter', 'renderCell', 'renderHeader', 'filterOperators'];
+
+const getAggregationValueWrappedValueGetter = ({
+  value: valueGetter,
+  getCellAggregationResult
+}) => {
+  const wrappedValueGetter = params => {
+    const cellAggregationResult = getCellAggregationResult(params.id, params.field);
+
+    if (cellAggregationResult != null) {
+      var _cellAggregationResul;
+
+      return (_cellAggregationResul = cellAggregationResult == null ? void 0 : cellAggregationResult.value) != null ? _cellAggregationResul : null;
+    }
+
+    if (valueGetter) {
+      return valueGetter(params);
+    }
+
+    return params.row[params.field];
+  };
+
+  return wrappedValueGetter;
+};
+
+const getAggregationValueWrappedValueFormatter = ({
+  value: valueFormatter,
+  aggregationRule,
+  getCellAggregationResult
+}) => {
+  // If neither the inline aggregation function nor the footer aggregation function have a custom value formatter,
+  // Then we don't wrap the column value formatter
+  if (!aggregationRule.aggregationFunction.valueFormatter) {
+    return valueFormatter;
+  }
+
+  const wrappedValueFormatter = params => {
+    if (params.id != null) {
+      const cellAggregationResult = getCellAggregationResult(params.id, params.field);
+
+      if (cellAggregationResult != null) {
+        return aggregationRule.aggregationFunction.valueFormatter(params);
+      }
+    }
+
+    if (valueFormatter) {
+      return valueFormatter(params);
+    }
+
+    return params.value;
+  };
+
+  return wrappedValueFormatter;
+};
+
+const getAggregationValueWrappedRenderCell = ({
+  value: renderCell,
+  aggregationRule,
+  getCellAggregationResult
+}) => {
+  const wrappedRenderCell = params => {
+    const cellAggregationResult = getCellAggregationResult(params.id, params.field);
+
+    if (cellAggregationResult != null) {
+      var _aggregationFunction$;
+
+      if (!renderCell) {
+        if (cellAggregationResult.position === 'footer') {
+          return /*#__PURE__*/(0, _jsxRuntime.jsx)(_GridFooterCell.GridFooterCell, (0, _extends2.default)({}, params));
+        }
+
+        return params.formattedValue;
+      }
+
+      const aggregationMeta = {
+        hasCellUnit: (_aggregationFunction$ = aggregationRule.aggregationFunction.hasCellUnit) != null ? _aggregationFunction$ : true,
+        aggregationFunctionName: aggregationRule.aggregationFunctionName
+      };
+      return renderCell((0, _extends2.default)({}, params, {
+        aggregation: aggregationMeta
+      }));
+    }
+
+    if (!renderCell) {
+      return params.formattedValue;
+    }
+
+    return renderCell(params);
+  };
+
+  return wrappedRenderCell;
+};
+/**
+ * Skips the filtering for aggregated rows
+ */
+
+
+const getWrappedFilterOperators = ({
+  value: filterOperators,
+  getCellAggregationResult
+}) => filterOperators.map(operator => {
+  return (0, _extends2.default)({}, operator, {
+    getApplyFilterFn: (filterItem, column) => {
+      const originalFn = operator.getApplyFilterFn(filterItem, column);
+
+      if (!originalFn) {
+        return null;
+      }
+
+      return params => {
+        if (getCellAggregationResult(params.id, params.field) != null) {
+          return true;
+        }
+
+        return originalFn(params);
+      };
+    }
+  });
+});
+/**
+ * Add the aggregation method around the header name
+ */
+
+
+const getWrappedRenderHeader = ({
+  value: renderHeader,
+  aggregationRule
+}) => {
+  const wrappedRenderCell = params => {
+    const aggregationMeta = {
+      aggregationRule
+    };
+
+    if (!renderHeader) {
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(_GridAggregationHeader.GridAggregationHeader, (0, _extends2.default)({}, params, {
+        aggregation: aggregationMeta
+      }));
+    }
+
+    return renderHeader((0, _extends2.default)({}, params, {
+      aggregation: aggregationMeta
+    }));
+  };
+
+  return wrappedRenderCell;
+};
+/**
+ * Add a wrapper around each wrappable property of the column to customize the behavior of the aggregation cells.
+ */
+
+
+const wrapColumnWithAggregationValue = ({
+  column,
+  apiRef,
+  aggregationRule
+}) => {
+  const getCellAggregationResult = (id, field) => {
+    var _parent, _gridAggregationLooku;
+
+    let cellAggregationPosition = null;
+
+    if (id.toString().startsWith('auto-generated-row-')) {
+      cellAggregationPosition = 'inline';
+    } else if (id.toString().startsWith('auto-generated-group-footer-')) {
+      cellAggregationPosition = 'footer';
+    }
+
+    if (cellAggregationPosition == null) {
+      return null;
+    } // TODO: Add custom root id
+
+
+    const groupId = cellAggregationPosition === 'inline' ? id : (_parent = apiRef.current.getRowNode(id).parent) != null ? _parent : '';
+    const aggregationResult = (_gridAggregationLooku = (0, _gridAggregationSelectors.gridAggregationLookupSelector)(apiRef)[groupId]) == null ? void 0 : _gridAggregationLooku[field];
+
+    if (!aggregationResult || aggregationResult.position !== cellAggregationPosition) {
+      return null;
+    }
+
+    return aggregationResult;
+  };
+
+  const aggregationWrappedProperties = {};
+  const wrappedColumn = (0, _extends2.default)({}, column, {
+    aggregationWrappedProperties
+  });
+
+  const wrapColumnProperty = (property, wrapper) => {
+    const originalValue = column[property];
+    const wrappedProperty = wrapper({
+      apiRef,
+      value: originalValue,
+      colDef: column,
+      aggregationRule,
+      getCellAggregationResult
+    });
+
+    if (wrappedProperty !== originalValue) {
+      aggregationWrappedProperties[property] = {
+        original: originalValue,
+        wrapped: wrappedProperty
+      };
+      wrappedColumn[property] = wrappedProperty;
+    }
+  };
+
+  wrapColumnProperty('valueGetter', getAggregationValueWrappedValueGetter);
+  wrapColumnProperty('valueFormatter', getAggregationValueWrappedValueFormatter);
+  wrapColumnProperty('renderCell', getAggregationValueWrappedRenderCell);
+  wrapColumnProperty('renderHeader', getWrappedRenderHeader);
+  wrapColumnProperty('filterOperators', getWrappedFilterOperators);
+
+  if (Object.keys(aggregationWrappedProperties).length === 0) {
+    return column;
+  }
+
+  return wrappedColumn;
+};
+/**
+ * Remove the aggregation wrappers around the wrappable properties of the column.
+ */
+
+
+exports.wrapColumnWithAggregationValue = wrapColumnWithAggregationValue;
+
+const unwrapColumnFromAggregation = ({
+  column
+}) => {
+  if (!column.aggregationWrappedProperties) {
+    return column;
+  }
+
+  const originalProperties = Object.entries(column.aggregationWrappedProperties);
+
+  if (originalProperties.length === 0) {
+    return column;
+  }
+
+  const unwrappedColumn = (0, _extends2.default)({}, column);
+  originalProperties.forEach(([propertyName, {
+    original,
+    wrapped
+  }]) => {
+    // The value changed since we wrapped it
+    if (wrapped !== column[propertyName]) {
+      return;
+    }
+
+    unwrappedColumn[propertyName] = original;
+  });
+  return unwrappedColumn;
+};
+
+exports.unwrapColumnFromAggregation = unwrapColumnFromAggregation;

package/node/hooks/features/export/serializer/excelSerializer.js

@@ -61,7 +61,8 @@ const serializeRow = (id, columns, api, defaultValueOptionsFormulae) => {
   api.unstable_calculateColSpan({
     rowId: id,
     minFirstColumn: 0,
-    maxLastColumn: columns.length - 1
+    maxLastColumn: columns.length,
+    columns
   });
   columns.forEach((column, colIndex) => {
     const colSpanInfo = api.unstable_getCellColSpanInfo(id, colIndex);

package/node/hooks/features/index.js

@@ -4,6 +4,19 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 
+var _aggregation = require("./aggregation");
+
+Object.keys(_aggregation).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _aggregation[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _aggregation[key];
+    }
+  });
+});
+
 var _rowGrouping = require("./rowGrouping");
 
 Object.keys(_rowGrouping).forEach(function (key) {

package/node/hooks/features/rowGrouping/createGroupingColDef.js

@@ -15,6 +15,8 @@ var React = _interopRequireWildcard(require("react"));
 
 var _xDataGridPro = require("@mui/x-data-grid-pro");
 
+var _GridGroupingColumnFooterCell = require("../../../components/GridGroupingColumnFooterCell");
+
 var _GridGroupingCriteriaCell = require("../../../components/GridGroupingCriteriaCell");
 
 var _GridGroupingColumnLeafCell = require("../../../components/GridGroupingColumnLeafCell");
@@ -173,7 +175,12 @@ const createGroupingColDefForOneGroupingCriteria = ({
   const commonProperties = {
     width: Math.max(((_groupedByColDef$widt = groupedByColDef.width) != null ? _groupedByColDef$widt : _xDataGridPro.GRID_STRING_COL_DEF.width) + 40, (_leafColDef$width = leafColDef == null ? void 0 : leafColDef.width) != null ? _leafColDef$width : 0),
     renderCell: params => {
-      // Render leaves
+      // Render footer
+      if (params.rowNode.position === 'footer') {
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(_GridGroupingColumnFooterCell.GridGroupingColumnFooterCell, (0, _extends2.default)({}, params));
+      } // Render leaves
+
+
       if (params.rowNode.groupingField == null) {
         if (leafColDef) {
           const leafParams = (0, _extends2.default)({}, params.api.getCellParams(params.id, leafField), {
@@ -275,7 +282,12 @@ const createGroupingColDefForAllGroupingCriteria = ({
       return ((_columnsLookup$field$ = columnsLookup[field].width) != null ? _columnsLookup$field$ : _xDataGridPro.GRID_STRING_COL_DEF.width) + 40;
     }), (_leafColDef$width2 = leafColDef == null ? void 0 : leafColDef.width) != null ? _leafColDef$width2 : 0),
     renderCell: params => {
-      // Render the leaves
+      // Render footer
+      if (params.rowNode.position === 'footer') {
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(_GridGroupingColumnFooterCell.GridGroupingColumnFooterCell, (0, _extends2.default)({}, params));
+      } // Render the leaves
+
+
       if (params.rowNode.groupingField == null) {
         if (leafColDef) {
           const leafParams = (0, _extends2.default)({}, params.api.getCellParams(params.id, leafField), {

package/node/hooks/features/rowGrouping/gridRowGroupingUtils.js

@@ -101,13 +101,17 @@ const filterRowTreeFromGroupingColumns = params => {
     visibleRowsLookup[node.id] = shouldPassFilters && areAncestorsExpanded;
     filteredRowsLookup[node.id] = shouldPassFilters;
 
+    if (node.footerId != null) {
+      visibleRowsLookup[node.footerId] = shouldPassFilters && areAncestorsExpanded && !!node.childrenExpanded;
+    }
+
     if (!shouldPassFilters) {
       return 0;
     }
 
     filteredDescendantCountLookup[node.id] = filteredDescendantCount;
 
-    if (!node.children) {
+    if (!node.children && !node.isAutoGenerated) {
       return filteredDescendantCount + 1;
     }
 

package/node/hooks/features/rowGrouping/useGridRowGrouping.js

@@ -31,6 +31,10 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "functio
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
+const Divider = () => /*#__PURE__*/(0, _jsxRuntime.jsx)(_Divider.default, {
+  onClick: event => event.stopPropagation()
+});
+
 const rowGroupingStateInitializer = (state, props, apiRef) => {
   var _ref, _props$rowGroupingMod, _props$initialState, _props$initialState$r;
 
@@ -53,6 +57,8 @@ const rowGroupingStateInitializer = (state, props, apiRef) => {
 exports.rowGroupingStateInitializer = rowGroupingStateInitializer;
 
 const useGridRowGrouping = (apiRef, props) => {
+  var _props$initialState3, _props$initialState3$;
+
   apiRef.current.unstable_registerControlState({
     stateId: 'rowGrouping',
     propModel: props.rowGroupingModel,
@@ -116,16 +122,16 @@ const useGridRowGrouping = (apiRef, props) => {
    * PRE-PROCESSING
    */
 
-  const addColumnMenuButtons = React.useCallback((initialValue, columns) => {
+  const addColumnMenuButtons = React.useCallback((initialValue, column) => {
     if (props.disableRowGrouping) {
       return initialValue;
     }
 
     let menuItems;
 
-    if ((0, _gridRowGroupingUtils.isGroupingColumn)(columns.field)) {
+    if ((0, _gridRowGroupingUtils.isGroupingColumn)(column.field)) {
       menuItems = /*#__PURE__*/(0, _jsxRuntime.jsx)(_GridRowGroupingColumnMenuItems.GridRowGroupingColumnMenuItems, {});
-    } else if (columns.groupable) {
+    } else if (column.groupable) {
       menuItems = /*#__PURE__*/(0, _jsxRuntime.jsx)(_GridRowGroupableColumnMenuItems.GridRowGroupableColumnMenuItems, {});
     } else {
       menuItems = null;
@@ -135,16 +141,19 @@ const useGridRowGrouping = (apiRef, props) => {
       return initialValue;
     }
 
-    return [...initialValue, /*#__PURE__*/(0, _jsxRuntime.jsx)(_Divider.default, {}), menuItems];
+    return [...initialValue, /*#__PURE__*/(0, _jsxRuntime.jsx)(Divider, {}), menuItems];
   }, [props.disableRowGrouping]);
-  const stateExportPreProcessing = React.useCallback(prevState => {
-    if (props.disableRowGrouping) {
-      return prevState;
-    }
+  const stateExportPreProcessing = React.useCallback((prevState, context) => {
+    var _props$initialState2, _props$initialState2$;
 
     const rowGroupingModelToExport = (0, _gridRowGroupingSelector.gridRowGroupingModelSelector)(apiRef);
+    const shouldExportRowGroupingModel = // Always export if the `exportOnlyDirtyModels` property is activated
+    !context.exportOnlyDirtyModels || // Always export if the model is controlled
+    props.rowGroupingModel != null || // Always export if the model has been initialized
+    ((_props$initialState2 = props.initialState) == null ? void 0 : (_props$initialState2$ = _props$initialState2.rowGrouping) == null ? void 0 : _props$initialState2$.model) != null || // Export if the model is not empty
+    Object.keys(rowGroupingModelToExport).length > 0;
 
-    if (rowGroupingModelToExport.length === 0) {
+    if (!shouldExportRowGroupingModel) {
       return prevState;
     }
 
@@ -153,7 +162,7 @@ const useGridRowGrouping = (apiRef, props) => {
         model: rowGroupingModelToExport
       }
     });
-  }, [apiRef, props.disableRowGrouping]);
+  }, [apiRef, props.rowGroupingModel, (_props$initialState3 = props.initialState) == null ? void 0 : (_props$initialState3$ = _props$initialState3.rowGrouping) == null ? void 0 : _props$initialState3$.model]);
   const stateRestorePreProcessing = React.useCallback((params, context) => {
     var _context$stateToResto;
 

package/node/index.js

@@ -1,4 +1,4 @@
-/** @license MUI v5.13.1
+/** @license MUI v5.14.0
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.

package/node/typeOverloads/index.js

@@ -1,5 +1,20 @@
 "use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
 require("@mui/x-data-grid-pro/typeOverloads");
 
-require("./modules");
+var _modules = require("./modules");
+
+Object.keys(_modules).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _modules[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _modules[key];
+    }
+  });
+});

package/node/utils/releaseInfo.js

@@ -8,7 +8,7 @@ exports.getReleaseInfo = void 0;
 var _utils = require("@mui/utils");
 
 const getReleaseInfo = () => {
-  const releaseInfo = "MTY1Nzg1NDAwMDAwMA==";
+  const releaseInfo = "MTY1ODQ0MDgwMDAwMA==";
 
   if (process.env.NODE_ENV !== 'production') {
     // A simple hack to set the value in the test environment (has no build step).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/x-data-grid-premium",
-  "version": "5.13.1",
+  "version": "5.14.0",
   "description": "The Premium plan edition of the data grid component (MUI X).",
   "author": "MUI Team",
   "main": "./node/index.js",
@@ -33,9 +33,9 @@
   "dependencies": {
     "@babel/runtime": "^7.18.6",
     "@mui/utils": "^5.4.1",
-    "@mui/x-data-grid": "5.13.1",
-    "@mui/x-data-grid-pro": "5.13.1",
-    "@mui/x-license-pro": "5.13.1",
+    "@mui/x-data-grid": "5.14.0",
+    "@mui/x-data-grid-pro": "5.14.0",
+    "@mui/x-license-pro": "5.14.0",
     "@types/format-util": "^1.0.2",
     "clsx": "^1.2.1",
     "exceljs": "^4.3.0",

package/typeOverloads/index.d.ts

@@ -1,2 +1,2 @@
 import '@mui/x-data-grid-pro/typeOverloads';
-import './modules';
+export * from './modules';

package/typeOverloads/index.js

@@ -1,2 +1,2 @@
 import '@mui/x-data-grid-pro/typeOverloads';
-import './modules';
+export * from './modules';

package/typeOverloads/modules.d.ts

@@ -1,9 +1,16 @@
 import { GridKeyValue, GridValidRowModel } from '@mui/x-data-grid-pro';
 import type { GridControlledStateEventLookupPro, GridApiCachesPro } from '@mui/x-data-grid-pro/typeOverloads';
 import type { GridGroupingValueGetterParams } from '../models';
-import type { GridRowGroupingModel } from '../hooks';
+import type { GridRowGroupingModel, GridAggregationModel, GridAggregationCellMeta, GridAggregationHeaderMeta } from '../hooks';
 import { GridRowGroupingInternalCache } from '../hooks/features/rowGrouping/gridRowGroupingInterfaces';
+import { GridAggregationInternalCache } from '../hooks/features/aggregation/gridAggregationInterfaces';
 export interface GridControlledStateEventLookupPremium {
+    /**
+     * Fired when the aggregation model changes.
+     */
+    aggregationModelChange: {
+        params: GridAggregationModel;
+    };
     /**
      * Fired when the row grouping model changes.
      */
@@ -12,6 +19,16 @@ export interface GridControlledStateEventLookupPremium {
     };
 }
 export interface GridColDefPremium<R extends GridValidRowModel = any, V = any, F = V> {
+    /**
+     * If `true`, the cells of the column can be aggregated based.
+     * @default true
+     */
+    private_aggregable?: boolean;
+    /**
+     * Limit the aggregation function usable on this column.
+     * By default, the column will have all the aggregation functions that are compatible with its type.
+     */
+    private_availableAggregationFunctions?: string[];
     /**
      * Function that transforms a complex cell value into a key that be used for grouping the rows.
      * @param {GridGroupingValueGetterParams} params Object containing parameters for the getter.
@@ -19,14 +36,27 @@ export interface GridColDefPremium<R extends GridValidRowModel = any, V = any, F
      */
     groupingValueGetter?: (params: GridGroupingValueGetterParams<V, R>) => GridKeyValue | null | undefined;
 }
+export interface GridRenderCellParamsPremium<V = any, R extends GridValidRowModel = any, F = V> {
+    aggregation?: GridAggregationCellMeta;
+}
+export interface GridColumnHeaderParamsPremium<V = any, R extends GridValidRowModel = any, F = V> {
+    aggregation?: GridAggregationHeaderMeta;
+}
 export interface GridApiCachesPremium extends GridApiCachesPro {
     rowGrouping: GridRowGroupingInternalCache;
+    aggregation: GridAggregationInternalCache;
 }
 declare module '@mui/x-data-grid-pro' {
-    interface GridColDef<R extends GridValidRowModel = any, V = any, F = V> extends GridColDefPremium<R, V, F> {
+    interface GridColDef<R, V, F> extends GridColDefPremium<R, V, F> {
     }
     interface GridControlledStateEventLookup extends GridControlledStateEventLookupPro, GridControlledStateEventLookupPremium {
     }
+    interface GridRenderCellParams<V, R, F> extends GridRenderCellParamsPremium<V, R, F> {
+    }
+    interface GridColumnHeaderParams<V, R, F> extends GridColumnHeaderParamsPremium<V, R, F> {
+    }
+    interface GridApiCaches extends GridApiCachesPremium {
+    }
 }
 declare module '@mui/x-data-grid-pro/internals' {
     interface GridApiCaches extends GridApiCachesPremium {

package/utils/releaseInfo.js

@@ -1,6 +1,6 @@
 import { ponyfillGlobal } from '@mui/utils';
 export const getReleaseInfo = () => {
-  const releaseInfo = "MTY1Nzg1NDAwMDAwMA==";
+  const releaseInfo = "MTY1ODQ0MDgwMDAwMA==";
 
   if (process.env.NODE_ENV !== 'production') {
     // A simple hack to set the value in the test environment (has no build step).