Added Statistics calculation

Statistics now show calculated values

node_modules/@mui/x-internals/store/Store.d.ts

@@ -0,0 +1,14 @@
+type Listener<T> = (value: T) => void;
+export declare class Store<State> {
+  state: State;
+  private listeners;
+  private updateTick;
+  static create<T>(state: T): Store<T>;
+  constructor(state: State);
+  subscribe: (fn: Listener<State>) => () => void;
+  getSnapshot: () => State;
+  setState(newState: State): void;
+  update(changes: Partial<State>): void;
+  set<T>(key: keyof State, value: T): void;
+}
+export {};

node_modules/@mui/x-internals/store/Store.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Store = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+/* eslint-disable no-cond-assign */
+
+class Store {
+  // HACK: `any` fixes adding listeners that accept partial state.
+
+  // Internal state to handle recursive `setState()` calls
+
+  static create(state) {
+    return new Store(state);
+  }
+  constructor(state) {
+    this.state = state;
+    this.listeners = new Set();
+    this.updateTick = 0;
+  }
+  subscribe = fn => {
+    this.listeners.add(fn);
+    return () => {
+      this.listeners.delete(fn);
+    };
+  };
+  getSnapshot = () => {
+    return this.state;
+  };
+  setState(newState) {
+    this.state = newState;
+    this.updateTick += 1;
+    const currentTick = this.updateTick;
+    const it = this.listeners.values();
+    let result;
+    while (result = it.next(), !result.done) {
+      if (currentTick !== this.updateTick) {
+        // If the tick has changed, a recursive `setState` call has been made,
+        // and it has already notified all listeners.
+        return;
+      }
+      const listener = result.value;
+      listener(newState);
+    }
+  }
+  update(changes) {
+    for (const key in changes) {
+      if (!Object.is(this.state[key], changes[key])) {
+        this.setState((0, _extends2.default)({}, this.state, changes));
+        return;
+      }
+    }
+  }
+  set(key, value) {
+    if (!Object.is(this.state[key], value)) {
+      this.setState((0, _extends2.default)({}, this.state, {
+        [key]: value
+      }));
+    }
+  }
+}
+exports.Store = Store;

node_modules/@mui/x-internals/store/createSelector.d.ts

@@ -0,0 +1,4 @@
+import type { CreateSelectorFunction } from "./createSelectorType.js";
+export type { CreateSelectorFunction } from "./createSelectorType.js";
+export declare const createSelector: CreateSelectorFunction;
+export declare const createSelectorMemoized: CreateSelectorFunction;

node_modules/@mui/x-internals/store/createSelector.js

@@ -0,0 +1,146 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSelectorMemoized = exports.createSelector = void 0;
+var _reselect = require("reselect");
+/* eslint-disable no-underscore-dangle */ // __cacheKey__
+
+const reselectCreateSelector = (0, _reselect.createSelectorCreator)({
+  memoize: _reselect.lruMemoize,
+  memoizeOptions: {
+    maxSize: 1,
+    equalityCheck: Object.is
+  }
+});
+/* eslint-disable id-denylist */
+const createSelector = (a, b, c, d, e, f, ...other) => {
+  if (other.length > 0) {
+    throw new Error('Unsupported number of selectors');
+  }
+  let selector;
+  if (a && b && c && d && e && f) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      const vb = b(state, a1, a2, a3);
+      const vc = c(state, a1, a2, a3);
+      const vd = d(state, a1, a2, a3);
+      const ve = e(state, a1, a2, a3);
+      return f(va, vb, vc, vd, ve, a1, a2, a3);
+    };
+  } else if (a && b && c && d && e) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      const vb = b(state, a1, a2, a3);
+      const vc = c(state, a1, a2, a3);
+      const vd = d(state, a1, a2, a3);
+      return e(va, vb, vc, vd, a1, a2, a3);
+    };
+  } else if (a && b && c && d) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      const vb = b(state, a1, a2, a3);
+      const vc = c(state, a1, a2, a3);
+      return d(va, vb, vc, a1, a2, a3);
+    };
+  } else if (a && b && c) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      const vb = b(state, a1, a2, a3);
+      return c(va, vb, a1, a2, a3);
+    };
+  } else if (a && b) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      return b(va, a1, a2, a3);
+    };
+  } else if (a) {
+    selector = a;
+  } else {
+    throw new Error('Missing arguments');
+  }
+  return selector;
+};
+/* eslint-enable id-denylist */
+exports.createSelector = createSelector;
+const createSelectorMemoized = (...inputs) => {
+  const cache = new WeakMap();
+  let nextCacheId = 1;
+  const combiner = inputs[inputs.length - 1];
+  const nSelectors = inputs.length - 1 || 1;
+  // (s1, s2, ..., sN, a1, a2, a3) => { ... }
+  const argsLength = Math.max(combiner.length - nSelectors, 0);
+  if (argsLength > 3) {
+    throw new Error('Unsupported number of arguments');
+  }
+
+  // prettier-ignore
+  const selector = (state, a1, a2, a3) => {
+    let cacheKey = state.__cacheKey__;
+    if (!cacheKey) {
+      cacheKey = {
+        id: nextCacheId
+      };
+      state.__cacheKey__ = cacheKey;
+      nextCacheId += 1;
+    }
+    let fn = cache.get(cacheKey);
+    if (!fn) {
+      const selectors = inputs.length === 1 ? [x => x, combiner] : inputs;
+      let reselectArgs = inputs;
+      const selectorArgs = [undefined, undefined, undefined];
+      switch (argsLength) {
+        case 0:
+          break;
+        case 1:
+          {
+            reselectArgs = [...selectors.slice(0, -1), () => selectorArgs[0], combiner];
+            break;
+          }
+        case 2:
+          {
+            reselectArgs = [...selectors.slice(0, -1), () => selectorArgs[0], () => selectorArgs[1], combiner];
+            break;
+          }
+        case 3:
+          {
+            reselectArgs = [...selectors.slice(0, -1), () => selectorArgs[0], () => selectorArgs[1], () => selectorArgs[2], combiner];
+            break;
+          }
+        default:
+          throw new Error('Unsupported number of arguments');
+      }
+      fn = reselectCreateSelector(...reselectArgs);
+      fn.selectorArgs = selectorArgs;
+      cache.set(cacheKey, fn);
+    }
+
+    /* eslint-disable no-fallthrough */
+
+    switch (argsLength) {
+      case 3:
+        fn.selectorArgs[2] = a3;
+      case 2:
+        fn.selectorArgs[1] = a2;
+      case 1:
+        fn.selectorArgs[0] = a1;
+      case 0:
+      default:
+    }
+    switch (argsLength) {
+      case 0:
+        return fn(state);
+      case 1:
+        return fn(state, a1);
+      case 2:
+        return fn(state, a1, a2);
+      case 3:
+        return fn(state, a1, a2, a3);
+      default:
+        throw new Error('unreachable');
+    }
+  };
+  return selector;
+};
+exports.createSelectorMemoized = createSelectorMemoized;

node_modules/@mui/x-internals/store/createSelectorType.d.ts

@@ -0,0 +1,9 @@
+import type { Selector } from 'reselect';
+export type CreateSelectorFunction = <const Args extends any[], const Selectors extends ReadonlyArray<Selector<any>>, const Combiner extends (...args: readonly [...ReturnTypes<Selectors>, ...Args]) => any>(...items: [...Selectors, Combiner]) => (...args: Selectors['length'] extends 0 ? MergeParams<ReturnTypes<Selectors>, Parameters<Combiner>> : [StateFromSelectorList<Selectors>, ...MergeParams<ReturnTypes<Selectors>, Parameters<Combiner>>]) => ReturnType<Combiner>;
+type StateFromSelectorList<Selectors extends readonly any[]> = Selectors extends [f: infer F, ...other: infer R] ? StateFromSelector<F> extends StateFromSelectorList<R> ? StateFromSelector<F> : StateFromSelectorList<R> : {};
+type StateFromSelector<T> = T extends ((first: infer F, ...args: any[]) => any) ? F : never;
+type Fn = (...args: any[]) => any;
+type ReturnTypes<FunctionsArray extends readonly Fn[]> = { [Index in keyof FunctionsArray]: FunctionsArray[Index] extends FunctionsArray[number] ? ReturnType<FunctionsArray[Index]> : never };
+type MergeParams<STypes extends readonly unknown[], CTypes extends readonly unknown[]> = STypes['length'] extends 0 ? CTypes : MergeParams<DropFirst<STypes>, DropFirst<CTypes>>;
+type DropFirst<T> = T extends [any, ...infer Xs] ? Xs : [];
+export {};

node_modules/@mui/x-internals/store/createSelectorType.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

node_modules/@mui/x-internals/store/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./createSelector.js";
+export * from "./useStore.js";
+export * from "./useStoreEffect.js";
+export * from "./Store.js";

node_modules/@mui/x-internals/store/index.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _createSelector = require("./createSelector");
+Object.keys(_createSelector).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _createSelector[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _createSelector[key];
+    }
+  });
+});
+var _useStore = require("./useStore");
+Object.keys(_useStore).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _useStore[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useStore[key];
+    }
+  });
+});
+var _useStoreEffect = require("./useStoreEffect");
+Object.keys(_useStoreEffect).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _useStoreEffect[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useStoreEffect[key];
+    }
+  });
+});
+var _Store = require("./Store");
+Object.keys(_Store).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Store[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Store[key];
+    }
+  });
+});

node_modules/@mui/x-internals/store/useStore.d.ts

@@ -0,0 +1,5 @@
+import type { Store } from "./Store.js";
+export declare function useStore<State, Value>(store: Store<State>, selector: (state: State) => Value): Value;
+export declare function useStore<State, Value, A1>(store: Store<State>, selector: (state: State, a1: A1) => Value, a1: A1): Value;
+export declare function useStore<State, Value, A1, A2>(store: Store<State>, selector: (state: State, a1: A1, a2: A2) => Value, a1: A1, a2: A2): Value;
+export declare function useStore<State, Value, A1, A2, A3>(store: Store<State>, selector: (state: State, a1: A1, a2: A2, a3: A3) => Value, a1: A1, a2: A2, a3: A3): Value;

node_modules/@mui/x-internals/store/useStore.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useStore = useStore;
+var _withSelector = require("use-sync-external-store/shim/with-selector");
+/* We need to import the shim because React 17 does not support the `useSyncExternalStore` API.
+ * More info: https://github.com/mui/mui-x/issues/18303#issuecomment-2958392341 */
+
+function useStore(store, selector, a1, a2, a3) {
+  const selectorWithArgs = state => selector(state, a1, a2, a3);
+  return (0, _withSelector.useSyncExternalStoreWithSelector)(store.subscribe, store.getSnapshot, store.getSnapshot, selectorWithArgs);
+}

node_modules/@mui/x-internals/store/useStoreEffect.d.ts

@@ -0,0 +1,6 @@
+import type { Store } from "./Store.js";
+/**
+ * An Effect implementation for the Store. This should be used for side-effects only. To
+ * compute and store derived state, use `createSelectorMemoized` instead.
+ */
+export declare function useStoreEffect<State, Value>(store: Store<State>, selector: (state: State) => Value, effect: (previous: Value, next: Value) => void): void;

node_modules/@mui/x-internals/store/useStoreEffect.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useStoreEffect = useStoreEffect;
+var _useLazyRef = _interopRequireDefault(require("@mui/utils/useLazyRef"));
+var _useOnMount = _interopRequireDefault(require("@mui/utils/useOnMount"));
+const noop = () => {};
+
+/**
+ * An Effect implementation for the Store. This should be used for side-effects only. To
+ * compute and store derived state, use `createSelectorMemoized` instead.
+ */
+function useStoreEffect(store, selector, effect) {
+  const instance = (0, _useLazyRef.default)(initialize, {
+    store,
+    selector
+  }).current;
+  instance.effect = effect;
+  (0, _useOnMount.default)(instance.onMount);
+}
+
+// `useLazyRef` typings are incorrect, `params` should not be optional
+function initialize(params) {
+  const {
+    store,
+    selector
+  } = params;
+  let previousState = selector(store.state);
+  const instance = {
+    effect: noop,
+    dispose: null,
+    // We want a single subscription done right away and cleared on unmount only,
+    // but React triggers `useOnMount` multiple times in dev, so we need to manage
+    // the subscription anyway.
+    subscribe: () => {
+      instance.dispose ?? (instance.dispose = store.subscribe(state => {
+        const nextState = selector(state);
+        instance.effect(previousState, nextState);
+        previousState = nextState;
+      }));
+    },
+    onMount: () => {
+      instance.subscribe();
+      return () => {
+        instance.dispose?.();
+        instance.dispose = null;
+      };
+    }
+  };
+  instance.subscribe();
+  return instance;
+}