@mui/x-data-grid 5.4.0 → 5.6.0

package/lib/createDetectElementResize/index.js

@@ -0,0 +1,168 @@
+/**
+ * Detect Element Resize.
+ * https://github.com/sdecima/javascript-detect-element-resize
+ * Sebastian Decima
+ *
+ * Forked from version 0.5.3; includes the following modifications:
+ * 1) Guard against unsafe 'window' and 'document' references (to support SSR).
+ * 2) Defer initialization code via a top-level function wrapper (to support SSR).
+ * 3) Avoid unnecessary reflows by not measuring size for scroll events bubbling from children.
+ * 4) Add nonce for style element.
+ *
+ * TODO replace with https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver
+ * once browser support allows it.
+ **/
+export default function createDetectElementResize(nonce, hostWindow) {
+  var resetTriggers = function resetTriggers(element) {
+    var triggers = element.__resizeTriggers__,
+        expand = triggers.firstElementChild,
+        contract = triggers.lastElementChild,
+        expandChild = expand.firstElementChild;
+    contract.scrollLeft = contract.scrollWidth;
+    contract.scrollTop = contract.scrollHeight;
+    expandChild.style.width = expand.offsetWidth + 1 + 'px';
+    expandChild.style.height = expand.offsetHeight + 1 + 'px';
+    expand.scrollLeft = expand.scrollWidth;
+    expand.scrollTop = expand.scrollHeight;
+  };
+
+  var checkTriggers = function checkTriggers(element) {
+    return element.offsetWidth != element.__resizeLast__.width || element.offsetHeight != element.__resizeLast__.height;
+  };
+
+  var scrollListener = function scrollListener(e) {
+    // Don't measure (which forces) reflow for scrolls that happen inside of children!
+    if (e.target.className.indexOf('contract-trigger') < 0 && e.target.className.indexOf('expand-trigger') < 0) {
+      return;
+    }
+
+    var element = this;
+    resetTriggers(this);
+
+    if (this.__resizeRAF__) {
+      hostWindow.cancelAnimationFrame(this.__resizeRAF__);
+    }
+
+    this.__resizeRAF__ = hostWindow.requestAnimationFrame(function () {
+      if (checkTriggers(element)) {
+        element.__resizeLast__.width = element.offsetWidth;
+        element.__resizeLast__.height = element.offsetHeight;
+
+        element.__resizeListeners__.forEach(function (fn) {
+          fn.call(element, e);
+        });
+      }
+    });
+  };
+  /* Detect CSS Animations support to detect element display/re-attach */
+
+
+  var animation = false,
+      keyframeprefix = '',
+      animationstartevent = 'animationstart',
+      domPrefixes = 'Webkit Moz O ms'.split(' '),
+      startEvents = 'webkitAnimationStart animationstart oAnimationStart MSAnimationStart'.split(' '),
+      pfx = '';
+  {
+    var elm = document.createElement('fakeelement');
+
+    if (elm.style.animationName !== undefined) {
+      animation = true;
+    }
+
+    if (animation === false) {
+      for (var i = 0; i < domPrefixes.length; i++) {
+        if (elm.style[domPrefixes[i] + 'AnimationName'] !== undefined) {
+          pfx = domPrefixes[i];
+          keyframeprefix = '-' + pfx.toLowerCase() + '-';
+          animationstartevent = startEvents[i];
+          animation = true;
+          break;
+        }
+      }
+    }
+  }
+  var animationName = 'resizeanim';
+  var animationKeyframes = '@' + keyframeprefix + 'keyframes ' + animationName + ' { from { opacity: 0; } to { opacity: 0; } } ';
+  var animationStyle = keyframeprefix + 'animation: 1ms ' + animationName + '; ';
+
+  var createStyles = function createStyles(doc) {
+    if (!doc.getElementById('muiDetectElementResize')) {
+      //opacity:0 works around a chrome bug https://code.google.com/p/chromium/issues/detail?id=286360
+      var css = (animationKeyframes ? animationKeyframes : '') + '.Mui-resizeTriggers { ' + (animationStyle ? animationStyle : '') + 'visibility: hidden; opacity: 0; } ' + '.Mui-resizeTriggers, .Mui-resizeTriggers > div, .contract-trigger:before { content: " "; display: block; position: absolute; top: 0; left: 0; height: 100%; width: 100%; overflow: hidden; z-index: -1; } .Mui-resizeTriggers > div { background: #eee; overflow: auto; } .contract-trigger:before { width: 200%; height: 200%; }',
+          head = doc.head || doc.getElementsByTagName('head')[0],
+          style = doc.createElement('style');
+      style.id = 'muiDetectElementResize';
+      style.type = 'text/css';
+
+      if (nonce != null) {
+        style.setAttribute('nonce', nonce);
+      }
+
+      if (style.styleSheet) {
+        style.styleSheet.cssText = css;
+      } else {
+        style.appendChild(doc.createTextNode(css));
+      }
+
+      head.appendChild(style);
+    }
+  };
+
+  var addResizeListener = function addResizeListener(element, fn) {
+    if (!element.__resizeTriggers__) {
+      var doc = element.ownerDocument;
+      var elementStyle = hostWindow.getComputedStyle(element);
+
+      if (elementStyle && elementStyle.position == 'static') {
+        element.style.position = 'relative';
+      }
+
+      createStyles(doc);
+      element.__resizeLast__ = {};
+      element.__resizeListeners__ = [];
+      (element.__resizeTriggers__ = doc.createElement('div')).className = 'Mui-resizeTriggers';
+      element.__resizeTriggers__.innerHTML = '<div class="expand-trigger"><div></div></div>' + '<div class="contract-trigger"></div>';
+      element.appendChild(element.__resizeTriggers__);
+      resetTriggers(element);
+      element.addEventListener('scroll', scrollListener, true);
+      /* Listen for a css animation to detect element display/re-attach */
+
+      if (animationstartevent) {
+        element.__resizeTriggers__.__animationListener__ = function animationListener(e) {
+          if (e.animationName == animationName) {
+            resetTriggers(element);
+          }
+        };
+
+        element.__resizeTriggers__.addEventListener(animationstartevent, element.__resizeTriggers__.__animationListener__);
+      }
+    }
+
+    element.__resizeListeners__.push(fn);
+  };
+
+  var removeResizeListener = function removeResizeListener(element, fn) {
+    element.__resizeListeners__.splice(element.__resizeListeners__.indexOf(fn), 1);
+
+    if (!element.__resizeListeners__.length) {
+      element.removeEventListener('scroll', scrollListener, true);
+
+      if (element.__resizeTriggers__.__animationListener__) {
+        element.__resizeTriggers__.removeEventListener(animationstartevent, element.__resizeTriggers__.__animationListener__);
+
+        element.__resizeTriggers__.__animationListener__ = null;
+      }
+
+      try {
+        element.__resizeTriggers__ = !element.removeChild(element.__resizeTriggers__);
+      } catch (e) {// Preact compat; see developit/preact-compat/issues/228
+      }
+    }
+  };
+
+  return {
+    addResizeListener,
+    removeResizeListener
+  };
+}

package/lib/createDetectElementResize/types.d.ts

@@ -0,0 +1,9 @@
+interface DetectElementResize {
+  addResizeListener: any;
+  removeResizeListener: any;
+}
+
+export default function createDetectElementResize(
+  nonce?: string,
+  hostWindow?: Window,
+): DetectElementResize;

package/lib/lodash/_DataView.d.ts

@@ -0,0 +1,2 @@
+export default DataView;
+declare var DataView: any;

package/lib/lodash/_DataView.js

@@ -0,0 +1,8 @@
+import getNative from './_getNative.js';
+import root from './_root.js';
+'use strict';
+/* Built-in method references that are verified to be native. */
+
+
+var DataView = getNative(root, 'DataView');
+export default DataView;

package/lib/lodash/_Hash.d.ts

@@ -0,0 +1,29 @@
+export default Hash;
+/**
+ * Creates a hash object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+declare function Hash(entries?: any[] | undefined): void;
+declare class Hash {
+    /**
+     * Creates a hash object.
+     *
+     * @private
+     * @constructor
+     * @param {Array} [entries] The key-value pairs to cache.
+     */
+    private constructor();
+    clear: typeof hashClear;
+    delete: typeof hashDelete;
+    get: typeof hashGet;
+    has: typeof hashHas;
+    set: typeof hashSet;
+}
+import hashClear from "./_hashClear.js";
+import hashDelete from "./_hashDelete.js";
+import hashGet from "./_hashGet.js";
+import hashHas from "./_hashHas.js";
+import hashSet from "./_hashSet.js";

package/lib/lodash/_Hash.js

@@ -0,0 +1,33 @@
+import hashClear from './_hashClear.js';
+import hashDelete from './_hashDelete.js';
+import hashGet from './_hashGet.js';
+import hashHas from './_hashHas.js';
+import hashSet from './_hashSet.js';
+'use strict';
+/**
+ * Creates a hash object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+
+
+function Hash(entries) {
+  var index = -1,
+      length = entries == null ? 0 : entries.length;
+  this.clear();
+
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+} // Add methods to `Hash`.
+
+
+Hash.prototype.clear = hashClear;
+Hash.prototype['delete'] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+export default Hash;

package/lib/lodash/_ListCache.d.ts

@@ -0,0 +1,29 @@
+export default ListCache;
+/**
+ * Creates an list cache object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+declare function ListCache(entries?: any[] | undefined): void;
+declare class ListCache {
+    /**
+     * Creates an list cache object.
+     *
+     * @private
+     * @constructor
+     * @param {Array} [entries] The key-value pairs to cache.
+     */
+    private constructor();
+    clear: typeof listCacheClear;
+    delete: typeof listCacheDelete;
+    get: typeof listCacheGet;
+    has: typeof listCacheHas;
+    set: typeof listCacheSet;
+}
+import listCacheClear from "./_listCacheClear.js";
+import listCacheDelete from "./_listCacheDelete.js";
+import listCacheGet from "./_listCacheGet.js";
+import listCacheHas from "./_listCacheHas.js";
+import listCacheSet from "./_listCacheSet.js";

package/lib/lodash/_ListCache.js

@@ -0,0 +1,33 @@
+import listCacheClear from './_listCacheClear.js';
+import listCacheDelete from './_listCacheDelete.js';
+import listCacheGet from './_listCacheGet.js';
+import listCacheHas from './_listCacheHas.js';
+import listCacheSet from './_listCacheSet.js';
+'use strict';
+/**
+ * Creates an list cache object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+
+
+function ListCache(entries) {
+  var index = -1,
+      length = entries == null ? 0 : entries.length;
+  this.clear();
+
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+} // Add methods to `ListCache`.
+
+
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype['delete'] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+export default ListCache;

package/lib/lodash/_Map.d.ts

@@ -0,0 +1,2 @@
+export default Map;
+declare var Map: any;

package/lib/lodash/_Map.js

@@ -0,0 +1,8 @@
+import getNative from './_getNative.js';
+import root from './_root.js';
+'use strict';
+/* Built-in method references that are verified to be native. */
+
+
+var Map = getNative(root, 'Map');
+export default Map;

package/lib/lodash/_MapCache.d.ts

@@ -0,0 +1,29 @@
+export default MapCache;
+/**
+ * Creates a map cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+declare function MapCache(entries?: any[] | undefined): void;
+declare class MapCache {
+    /**
+     * Creates a map cache object to store key-value pairs.
+     *
+     * @private
+     * @constructor
+     * @param {Array} [entries] The key-value pairs to cache.
+     */
+    private constructor();
+    clear: typeof mapCacheClear;
+    delete: typeof mapCacheDelete;
+    get: typeof mapCacheGet;
+    has: typeof mapCacheHas;
+    set: typeof mapCacheSet;
+}
+import mapCacheClear from "./_mapCacheClear.js";
+import mapCacheDelete from "./_mapCacheDelete.js";
+import mapCacheGet from "./_mapCacheGet.js";
+import mapCacheHas from "./_mapCacheHas.js";
+import mapCacheSet from "./_mapCacheSet.js";

package/lib/lodash/_MapCache.js

@@ -0,0 +1,33 @@
+import mapCacheClear from './_mapCacheClear.js';
+import mapCacheDelete from './_mapCacheDelete.js';
+import mapCacheGet from './_mapCacheGet.js';
+import mapCacheHas from './_mapCacheHas.js';
+import mapCacheSet from './_mapCacheSet.js';
+'use strict';
+/**
+ * Creates a map cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+
+
+function MapCache(entries) {
+  var index = -1,
+      length = entries == null ? 0 : entries.length;
+  this.clear();
+
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+} // Add methods to `MapCache`.
+
+
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype['delete'] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+export default MapCache;

package/lib/lodash/_Promise.d.ts

@@ -0,0 +1,2 @@
+export default Promise;
+declare var Promise: any;

package/lib/lodash/_Promise.js

@@ -0,0 +1,8 @@
+import getNative from './_getNative.js';
+import root from './_root.js';
+'use strict';
+/* Built-in method references that are verified to be native. */
+
+
+var Promise = getNative(root, 'Promise');
+export default Promise;

package/lib/lodash/_Set.d.ts

@@ -0,0 +1,2 @@
+export default Set;
+declare var Set: any;

package/lib/lodash/_Set.js

@@ -0,0 +1,8 @@
+import getNative from './_getNative.js';
+import root from './_root.js';
+'use strict';
+/* Built-in method references that are verified to be native. */
+
+
+var Set = getNative(root, 'Set');
+export default Set;

package/lib/lodash/_SetCache.d.ts

@@ -0,0 +1,28 @@
+export default SetCache;
+/**
+ *
+ * Creates an array cache object to store unique values.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [values] The values to cache.
+ */
+declare function SetCache(values?: any[] | undefined): void;
+declare class SetCache {
+    /**
+     *
+     * Creates an array cache object to store unique values.
+     *
+     * @private
+     * @constructor
+     * @param {Array} [values] The values to cache.
+     */
+    private constructor();
+    __data__: MapCache;
+    add: typeof setCacheAdd;
+    push: typeof setCacheAdd;
+    has: typeof setCacheHas;
+}
+import MapCache from "./_MapCache.js";
+import setCacheAdd from "./_setCacheAdd.js";
+import setCacheHas from "./_setCacheHas.js";

package/lib/lodash/_SetCache.js

@@ -0,0 +1,28 @@
+import MapCache from './_MapCache.js';
+import setCacheAdd from './_setCacheAdd.js';
+import setCacheHas from './_setCacheHas.js';
+'use strict';
+/**
+ *
+ * Creates an array cache object to store unique values.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [values] The values to cache.
+ */
+
+
+function SetCache(values) {
+  var index = -1,
+      length = values == null ? 0 : values.length;
+  this.__data__ = new MapCache();
+
+  while (++index < length) {
+    this.add(values[index]);
+  }
+} // Add methods to `SetCache`.
+
+
+SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+SetCache.prototype.has = setCacheHas;
+export default SetCache;

package/lib/lodash/_Stack.d.ts

@@ -0,0 +1,32 @@
+export default Stack;
+/**
+ * Creates a stack cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+declare function Stack(entries?: any[] | undefined): void;
+declare class Stack {
+    /**
+     * Creates a stack cache object to store key-value pairs.
+     *
+     * @private
+     * @constructor
+     * @param {Array} [entries] The key-value pairs to cache.
+     */
+    private constructor();
+    __data__: ListCache;
+    size: any;
+    clear: typeof stackClear;
+    delete: typeof stackDelete;
+    get: typeof stackGet;
+    has: typeof stackHas;
+    set: typeof stackSet;
+}
+import ListCache from "./_ListCache.js";
+import stackClear from "./_stackClear.js";
+import stackDelete from "./_stackDelete.js";
+import stackGet from "./_stackGet.js";
+import stackHas from "./_stackHas.js";
+import stackSet from "./_stackSet.js";

package/lib/lodash/_Stack.js

@@ -0,0 +1,28 @@
+import ListCache from './_ListCache.js';
+import stackClear from './_stackClear.js';
+import stackDelete from './_stackDelete.js';
+import stackGet from './_stackGet.js';
+import stackHas from './_stackHas.js';
+import stackSet from './_stackSet.js';
+'use strict';
+/**
+ * Creates a stack cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+
+
+function Stack(entries) {
+  var data = this.__data__ = new ListCache(entries);
+  this.size = data.size;
+} // Add methods to `Stack`.
+
+
+Stack.prototype.clear = stackClear;
+Stack.prototype['delete'] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+export default Stack;

package/lib/lodash/_Symbol.d.ts

@@ -0,0 +1,3 @@
+export default Symbol;
+/** Built-in value references. */
+declare var Symbol: any;

package/lib/lodash/_Symbol.js

@@ -0,0 +1,7 @@
+import root from './_root.js';
+'use strict';
+/** Built-in value references. */
+
+
+var Symbol = root.Symbol;
+export default Symbol;

package/lib/lodash/_Uint8Array.d.ts

@@ -0,0 +1,3 @@
+export default Uint8Array;
+/** Built-in value references. */
+declare var Uint8Array: any;

package/lib/lodash/_Uint8Array.js

@@ -0,0 +1,7 @@
+import root from './_root.js';
+'use strict';
+/** Built-in value references. */
+
+
+var Uint8Array = root.Uint8Array;
+export default Uint8Array;

package/lib/lodash/_WeakMap.d.ts

@@ -0,0 +1,2 @@
+export default WeakMap;
+declare var WeakMap: any;

package/lib/lodash/_WeakMap.js

@@ -0,0 +1,8 @@
+import getNative from './_getNative.js';
+import root from './_root.js';
+'use strict';
+/* Built-in method references that are verified to be native. */
+
+
+var WeakMap = getNative(root, 'WeakMap');
+export default WeakMap;

package/lib/lodash/_arrayFilter.d.ts

@@ -0,0 +1,11 @@
+export default arrayFilter;
+/**
+ * A specialized version of `_.filter` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {Array} Returns the new filtered array.
+ */
+declare function arrayFilter(array?: any[] | undefined, predicate: Function): any[];

package/lib/lodash/_arrayFilter.js

@@ -0,0 +1,29 @@
+'use strict';
+/**
+ * A specialized version of `_.filter` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {Array} Returns the new filtered array.
+ */
+
+function arrayFilter(array, predicate) {
+  var index = -1,
+      length = array == null ? 0 : array.length,
+      resIndex = 0,
+      result = [];
+
+  while (++index < length) {
+    var value = array[index];
+
+    if (predicate(value, index, array)) {
+      result[resIndex++] = value;
+    }
+  }
+
+  return result;
+}
+
+export default arrayFilter;

package/lib/lodash/_arrayLikeKeys.d.ts

@@ -0,0 +1,10 @@
+export default arrayLikeKeys;
+/**
+ * Creates an array of the enumerable property names of the array-like `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @param {boolean} inherited Specify returning inherited property names.
+ * @returns {Array} Returns the array of property names.
+ */
+declare function arrayLikeKeys(value: any, inherited: boolean): any[];