@difizen/libro-virtualized 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present Difizen Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/es/auto-sizer/auto-sizer.d.ts

@@ -0,0 +1,56 @@
+import * as React from 'react';
+type Size = {
+    height: number;
+    width: number;
+};
+type Props = {
+    /** Function responsible for rendering children.*/
+    children: (param: Size) => React.ReactNode;
+    /** Optional custom CSS class name to attach to root AutoSizer element.  */
+    className?: string;
+    /** Default height to use for initial render; useful for SSR */
+    defaultHeight?: number;
+    /** Default width to use for initial render; useful for SSR */
+    defaultWidth?: number;
+    /** Disable dynamic :height property */
+    disableHeight: boolean;
+    /** Disable dynamic :width property */
+    disableWidth: boolean;
+    /** Nonce of the inlined stylesheet for Content Security Policy */
+    nonce?: string;
+    /** Callback to be invoked on-resize */
+    onResize: (param: Size) => void;
+    /** Optional inline style */
+    style?: object;
+};
+type State = {
+    height: number;
+    width: number;
+};
+type ResizeHandler = (element: HTMLElement, onResize: () => void) => void;
+type DetectElementResize = {
+    addResizeListener: ResizeHandler;
+    removeResizeListener: ResizeHandler;
+};
+export default class AutoSizer extends React.PureComponent<Props, State> {
+    static defaultProps: {
+        onResize: () => void;
+        disableHeight: boolean;
+        disableWidth: boolean;
+        style: {};
+    };
+    state: {
+        height: number;
+        width: number;
+    };
+    _parentNode?: HTMLElement;
+    _autoSizer: HTMLElement | null;
+    _detectElementResize: DetectElementResize;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    render(): import("react/jsx-runtime").JSX.Element;
+    _onResize: () => void;
+    _setRef: (autoSizer: HTMLElement | null) => void;
+}
+export {};
+//# sourceMappingURL=auto-sizer.d.ts.map

package/es/auto-sizer/auto-sizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-sizer.d.ts","sourceRoot":"","sources":["../../src/auto-sizer/auto-sizer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,KAAK,IAAI,GAAG;IACV,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,KAAK,GAAG;IACX,kDAAkD;IAClD,QAAQ,EAAE,CAAC,KAAK,EAAE,IAAI,KAAK,KAAK,CAAC,SAAS,CAAC;IAE3C,2EAA2E;IAC3E,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,+DAA+D;IAC/D,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,8DAA8D;IAC9D,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,uCAAuC;IACvC,aAAa,EAAE,OAAO,CAAC;IAEvB,sCAAsC;IACtC,YAAY,EAAE,OAAO,CAAC;IAEtB,kEAAkE;IAClE,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,uCAAuC;IACvC,QAAQ,EAAE,CAAC,KAAK,EAAE,IAAI,KAAK,IAAI,CAAC;IAEhC,4BAA4B;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,KAAK,KAAK,GAAG;IACX,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,aAAa,GAAG,CAAC,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;AAE1E,KAAK,mBAAmB,GAAG;IACzB,iBAAiB,EAAE,aAAa,CAAC;IACjC,oBAAoB,EAAE,aAAa,CAAC;CACrC,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,SAAU,SAAQ,KAAK,CAAC,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC;IACtE,MAAM,CAAC,YAAY;;;;;MAOjB;IAEO,KAAK;;;MAGZ;IAEF,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,UAAU,EAAE,WAAW,GAAG,IAAI,CAAC;IAC/B,oBAAoB,EAAE,mBAAmB,CAAC;IAEjC,iBAAiB;IAwBjB,oBAAoB;IAMpB,MAAM;IAkDf,SAAS,aAgCP;IAEF,OAAO,cAAe,WAAW,GAAG,IAAI,UAEtC;CACH"}

package/es/auto-sizer/auto-sizer.js

@@ -0,0 +1,157 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import * as React from 'react';
+import createDetectElementResize from "../vendor/detect-element-resize.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+var AutoSizer = /*#__PURE__*/function (_React$PureComponent) {
+  _inherits(AutoSizer, _React$PureComponent);
+  var _super = _createSuper(AutoSizer);
+  function AutoSizer() {
+    var _this;
+    _classCallCheck(this, AutoSizer);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _this.state = {
+      height: _this.props.defaultHeight || 0,
+      width: _this.props.defaultWidth || 0
+    };
+    _this._onResize = function () {
+      var _this$props = _this.props,
+        disableHeight = _this$props.disableHeight,
+        disableWidth = _this$props.disableWidth,
+        onResize = _this$props.onResize;
+      if (_this._parentNode) {
+        // Guard against AutoSizer component being removed from the DOM immediately after being added.
+        // This can result in invalid style values which can result in NaN values if we don't handle them.
+        // See issue #150 for more context.
+
+        var height = _this._parentNode.offsetHeight || 0;
+        var width = _this._parentNode.offsetWidth || 0;
+        var style = window.getComputedStyle(_this._parentNode) || {};
+        var paddingLeft = parseInt(style.paddingLeft, 10) || 0;
+        var paddingRight = parseInt(style.paddingRight, 10) || 0;
+        var paddingTop = parseInt(style.paddingTop, 10) || 0;
+        var paddingBottom = parseInt(style.paddingBottom, 10) || 0;
+        var newHeight = height - paddingTop - paddingBottom;
+        var newWidth = width - paddingLeft - paddingRight;
+        if (!disableHeight && _this.state.height !== newHeight || !disableWidth && _this.state.width !== newWidth) {
+          _this.setState({
+            height: height - paddingTop - paddingBottom,
+            width: width - paddingLeft - paddingRight
+          });
+          onResize({
+            height: height,
+            width: width
+          });
+        }
+      }
+    };
+    _this._setRef = function (autoSizer) {
+      _this._autoSizer = autoSizer;
+    };
+    return _this;
+  }
+  _createClass(AutoSizer, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var nonce = this.props.nonce;
+      if (this._autoSizer && this._autoSizer.parentNode && this._autoSizer.parentNode.ownerDocument && this._autoSizer.parentNode.ownerDocument.defaultView && this._autoSizer.parentNode instanceof this._autoSizer.parentNode.ownerDocument.defaultView.HTMLElement) {
+        // Delay access of parentNode until mount.
+        // This handles edge-cases where the component has already been unmounted before its ref has been set,
+        // As well as libraries like react-lite which have a slightly different lifecycle.
+        this._parentNode = this._autoSizer.parentNode;
+
+        // Defer requiring resize handler in order to support server-side rendering.
+        // See issue #41
+        this._detectElementResize = createDetectElementResize(nonce);
+        this._detectElementResize.addResizeListener(this._parentNode, this._onResize);
+        this._onResize();
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      if (this._detectElementResize && this._parentNode) {
+        this._detectElementResize.removeResizeListener(this._parentNode, this._onResize);
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props2 = this.props,
+        children = _this$props2.children,
+        className = _this$props2.className,
+        disableHeight = _this$props2.disableHeight,
+        disableWidth = _this$props2.disableWidth,
+        style = _this$props2.style;
+      var _this$state = this.state,
+        height = _this$state.height,
+        width = _this$state.width;
+
+      // Outer div should not force width/height since that may prevent containers from shrinking.
+      // Inner component should overflow and use calculated width/height.
+      // See issue #68 for more information.
+      var outerStyle = {
+        overflow: 'visible'
+      };
+      var childParams = {
+        height: 0,
+        width: 0
+      };
+      if (!disableHeight) {
+        outerStyle['height'] = 0;
+        childParams['height'] = height;
+      }
+      if (!disableWidth) {
+        outerStyle['width'] = 0;
+        childParams['width'] = width;
+      }
+
+      /**
+       * TODO: Avoid rendering children before the initial measurements have been collected.
+       * At best this would just be wasting cycles.
+       * Add this check into version 10 though as it could break too many ref callbacks in version 9.
+       * Note that if default width/height props were provided this would still work with SSR.
+      if (
+        height !== 0 &&
+        width !== 0
+      ) {
+        child = children({ height, width })
+      }
+      */
+
+      return /*#__PURE__*/_jsx("div", {
+        className: className,
+        ref: this._setRef,
+        style: _objectSpread(_objectSpread({}, outerStyle), style),
+        children: children(childParams)
+      });
+    }
+  }]);
+  return AutoSizer;
+}(React.PureComponent);
+AutoSizer.defaultProps = {
+  onResize: function onResize() {
+    //
+  },
+  disableHeight: false,
+  disableWidth: false,
+  style: {}
+};
+export { AutoSizer as default };

package/es/auto-sizer/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from './auto-sizer.js';
+export { default as AutoSizer } from './auto-sizer.js';
+//# sourceMappingURL=index.d.ts.map

package/es/auto-sizer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/auto-sizer/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,iBAAiB,CAAC"}

package/es/auto-sizer/index.js

@@ -0,0 +1,2 @@
+export { default } from "./auto-sizer.js";
+export { default as AutoSizer } from "./auto-sizer.js";

package/es/cell-measurer/cell-measurer-cache.d.ts

@@ -0,0 +1,52 @@
+/** @flow */
+import type { CellMeasureCache } from './types.js';
+export declare const DEFAULT_HEIGHT = 30;
+export declare const DEFAULT_WIDTH = 100;
+type KeyMapper = (rowIndex: number, columnIndex: number) => any;
+type CellMeasurerCacheParams = {
+    defaultHeight?: number;
+    defaultWidth?: number;
+    fixedHeight?: boolean;
+    fixedWidth?: boolean;
+    minHeight?: number;
+    minWidth?: number;
+    keyMapper?: KeyMapper;
+};
+type Cache = Record<any, number>;
+type IndexParam = {
+    index: number;
+};
+/**
+ * Caches measurements for a given cell.
+ */
+export default class CellMeasurerCache implements CellMeasureCache {
+    _cellHeightCache: Cache;
+    _cellWidthCache: Cache;
+    _columnWidthCache: Cache;
+    _rowHeightCache: Cache;
+    _defaultHeight: number;
+    _defaultWidth: number;
+    _minHeight: number;
+    _minWidth: number;
+    _keyMapper: KeyMapper;
+    _hasFixedHeight: boolean;
+    _hasFixedWidth: boolean;
+    _columnCount: number;
+    _rowCount: number;
+    constructor(params?: CellMeasurerCacheParams);
+    clear(rowIndex: number, columnIndex?: number): void;
+    clearAll(): void;
+    columnWidth: ({ index }: IndexParam) => number;
+    get defaultHeight(): number;
+    get defaultWidth(): number;
+    hasFixedHeight(): boolean;
+    hasFixedWidth(): boolean;
+    getHeight(rowIndex: number, columnIndex?: number): number;
+    getWidth(rowIndex: number, columnIndex?: number): number;
+    has(rowIndex: number, columnIndex?: number): boolean;
+    rowHeight: ({ index }: IndexParam) => number;
+    set(rowIndex: number, columnIndex: number, width: number, height: number): void;
+    _updateCachedColumnAndRowSizes(rowIndex: number, columnIndex: number): void;
+}
+export {};
+//# sourceMappingURL=cell-measurer-cache.d.ts.map

package/es/cell-measurer/cell-measurer-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cell-measurer-cache.d.ts","sourceRoot":"","sources":["../../src/cell-measurer/cell-measurer-cache.ts"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,eAAO,MAAM,cAAc,KAAK,CAAC;AACjC,eAAO,MAAM,aAAa,MAAM,CAAC;AAIjC,KAAK,SAAS,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,GAAG,CAAC;AAEhE,KAAK,uBAAuB,GAAG;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,KAAK,KAAK,GAAG,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;AAEjC,KAAK,UAAU,GAAG;IAChB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,iBAAkB,YAAW,gBAAgB;IAChE,gBAAgB,EAAE,KAAK,CAAM;IAC7B,eAAe,EAAE,KAAK,CAAM;IAC5B,iBAAiB,EAAE,KAAK,CAAM;IAC9B,eAAe,EAAE,KAAK,CAAM;IAC5B,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,SAAS,CAAC;IACtB,eAAe,EAAE,OAAO,CAAC;IACzB,cAAc,EAAE,OAAO,CAAC;IACxB,YAAY,SAAK;IACjB,SAAS,SAAK;gBAEF,MAAM,GAAE,uBAA4B;IAmDhD,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,SAAI;IASvC,QAAQ;IASR,WAAW,cAAe,UAAU,YAMlC;IAEF,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,cAAc,IAAI,OAAO;IAIzB,aAAa,IAAI,OAAO;IAIxB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,SAAI,GAAG,MAAM;IAYpD,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,SAAI,GAAG,MAAM;IAYnD,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,SAAI,GAAG,OAAO;IAM/C,SAAS,cAAe,UAAU,YAMhC;IAEF,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAiB/E,8BAA8B,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;CAsBrE"}

package/es/cell-measurer/cell-measurer-cache.js

@@ -0,0 +1,176 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+export var DEFAULT_HEIGHT = 30;
+export var DEFAULT_WIDTH = 100;
+
+// Enables more intelligent mapping of a given column and row index to an item ID.
+// This prevents a cell cache from being invalidated when its parent collection is modified.
+/**
+ * Caches measurements for a given cell.
+ */
+var CellMeasurerCache = /*#__PURE__*/function () {
+  function CellMeasurerCache() {
+    var _this = this;
+    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, CellMeasurerCache);
+    this._cellHeightCache = {};
+    this._cellWidthCache = {};
+    this._columnWidthCache = {};
+    this._rowHeightCache = {};
+    this._columnCount = 0;
+    this._rowCount = 0;
+    this.columnWidth = function (_ref) {
+      var index = _ref.index;
+      var key = _this._keyMapper(0, index);
+      return Object.prototype.hasOwnProperty.call(_this._columnWidthCache, key) ? _this._columnWidthCache[key] : _this._defaultWidth;
+    };
+    this.rowHeight = function (_ref2) {
+      var index = _ref2.index;
+      var key = _this._keyMapper(index, 0);
+      return Object.prototype.hasOwnProperty.call(_this._rowHeightCache, key) ? _this._rowHeightCache[key] : _this._defaultHeight;
+    };
+    var defaultHeight = params.defaultHeight,
+      defaultWidth = params.defaultWidth,
+      fixedHeight = params.fixedHeight,
+      fixedWidth = params.fixedWidth,
+      keyMapper = params.keyMapper,
+      minHeight = params.minHeight,
+      minWidth = params.minWidth;
+    this._hasFixedHeight = fixedHeight === true;
+    this._hasFixedWidth = fixedWidth === true;
+    this._minHeight = minHeight || 0;
+    this._minWidth = minWidth || 0;
+    this._keyMapper = keyMapper || defaultKeyMapper;
+    this._defaultHeight = Math.max(this._minHeight, typeof defaultHeight === 'number' ? defaultHeight : DEFAULT_HEIGHT);
+    this._defaultWidth = Math.max(this._minWidth, typeof defaultWidth === 'number' ? defaultWidth : DEFAULT_WIDTH);
+    if (process.env['NODE_ENV'] !== 'production') {
+      if (this._hasFixedHeight === false && this._hasFixedWidth === false) {
+        console.warn("CellMeasurerCache should only measure a cell's width or height. " + 'You have configured CellMeasurerCache to measure both. ' + 'This will result in poor performance.');
+      }
+      if (this._hasFixedHeight === false && this._defaultHeight === 0) {
+        console.warn('Fixed height CellMeasurerCache should specify a :defaultHeight greater than 0. ' + 'Failing to do so will lead to unnecessary layout and poor performance.');
+      }
+      if (this._hasFixedWidth === false && this._defaultWidth === 0) {
+        console.warn('Fixed width CellMeasurerCache should specify a :defaultWidth greater than 0. ' + 'Failing to do so will lead to unnecessary layout and poor performance.');
+      }
+    }
+  }
+  _createClass(CellMeasurerCache, [{
+    key: "clear",
+    value: function clear(rowIndex) {
+      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      var key = this._keyMapper(rowIndex, columnIndex);
+      delete this._cellHeightCache[key];
+      delete this._cellWidthCache[key];
+      this._updateCachedColumnAndRowSizes(rowIndex, columnIndex);
+    }
+  }, {
+    key: "clearAll",
+    value: function clearAll() {
+      this._cellHeightCache = {};
+      this._cellWidthCache = {};
+      this._columnWidthCache = {};
+      this._rowHeightCache = {};
+      this._rowCount = 0;
+      this._columnCount = 0;
+    }
+  }, {
+    key: "defaultHeight",
+    get: function get() {
+      return this._defaultHeight;
+    }
+  }, {
+    key: "defaultWidth",
+    get: function get() {
+      return this._defaultWidth;
+    }
+  }, {
+    key: "hasFixedHeight",
+    value: function hasFixedHeight() {
+      return this._hasFixedHeight;
+    }
+  }, {
+    key: "hasFixedWidth",
+    value: function hasFixedWidth() {
+      return this._hasFixedWidth;
+    }
+  }, {
+    key: "getHeight",
+    value: function getHeight(rowIndex) {
+      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      if (this._hasFixedHeight) {
+        return this._defaultHeight;
+      } else {
+        var key = this._keyMapper(rowIndex, columnIndex);
+        return Object.prototype.hasOwnProperty.call(this._cellHeightCache, key) ? Math.max(this._minHeight, this._cellHeightCache[key]) : this._defaultHeight;
+      }
+    }
+  }, {
+    key: "getWidth",
+    value: function getWidth(rowIndex) {
+      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      if (this._hasFixedWidth) {
+        return this._defaultWidth;
+      } else {
+        var key = this._keyMapper(rowIndex, columnIndex);
+        return Object.prototype.hasOwnProperty.call(this._cellWidthCache, key) ? Math.max(this._minWidth, this._cellWidthCache[key]) : this._defaultWidth;
+      }
+    }
+  }, {
+    key: "has",
+    value: function has(rowIndex) {
+      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      var key = this._keyMapper(rowIndex, columnIndex);
+      return Object.prototype.hasOwnProperty.call(this._cellHeightCache, key);
+    }
+  }, {
+    key: "set",
+    value: function set(rowIndex, columnIndex, width, height) {
+      var key = this._keyMapper(rowIndex, columnIndex);
+      if (columnIndex >= this._columnCount) {
+        this._columnCount = columnIndex + 1;
+      }
+      if (rowIndex >= this._rowCount) {
+        this._rowCount = rowIndex + 1;
+      }
+
+      // Size is cached per cell so we don't have to re-measure if cells are re-ordered.
+      this._cellHeightCache[key] = height;
+      this._cellWidthCache[key] = width;
+      this._updateCachedColumnAndRowSizes(rowIndex, columnIndex);
+    }
+  }, {
+    key: "_updateCachedColumnAndRowSizes",
+    value: function _updateCachedColumnAndRowSizes(rowIndex, columnIndex) {
+      // :columnWidth and :rowHeight are derived based on all cells in a column/row.
+      // Pre-cache these derived values for faster lookup later.
+      // Reads are expected to occur more frequently than writes in this case.
+      // Only update non-fixed dimensions though to avoid doing unnecessary work.
+      if (!this._hasFixedWidth) {
+        var columnWidth = 0;
+        for (var i = 0; i < this._rowCount; i++) {
+          columnWidth = Math.max(columnWidth, this.getWidth(i, columnIndex));
+        }
+        var columnKey = this._keyMapper(0, columnIndex);
+        this._columnWidthCache[columnKey] = columnWidth;
+      }
+      if (!this._hasFixedHeight) {
+        var rowHeight = 0;
+        for (var _i = 0; _i < this._columnCount; _i++) {
+          rowHeight = Math.max(rowHeight, this.getHeight(rowIndex, _i));
+        }
+        var rowKey = this._keyMapper(rowIndex, 0);
+        this._rowHeightCache[rowKey] = rowHeight;
+      }
+    }
+  }]);
+  return CellMeasurerCache;
+}();
+export { CellMeasurerCache as default };
+function defaultKeyMapper(rowIndex, columnIndex) {
+  return "".concat(rowIndex, "-").concat(columnIndex);
+}

package/es/cell-measurer/cell-measurer.d.ts

@@ -0,0 +1,39 @@
+import * as React from 'react';
+import type { CellMeasureCache } from './types.js';
+type Children = (params: {
+    measure: () => void;
+}) => React.ReactNode;
+type Cell = {
+    columnIndex: number;
+    rowIndex: number;
+};
+type Props = {
+    cache: CellMeasureCache;
+    children: Children | React.ReactNode;
+    columnIndex?: number;
+    index?: number;
+    parent: {
+        invalidateCellSizeAfterRender?: (cell: Cell) => void;
+        recomputeGridSize?: (cell: Cell) => void;
+    };
+    rowIndex?: number;
+};
+/**
+ * Wraps a cell and measures its rendered content.
+ * Measurements are stored in a per-cell cache.
+ * Cached-content is not be re-measured.
+ */
+export default class CellMeasurer extends React.PureComponent<Props> {
+    static __internalCellMeasurerFlag: boolean;
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    render(): React.ReactNode;
+    _getCellMeasurements(): {
+        height: number;
+        width: number;
+    };
+    _maybeMeasureCell(): void;
+    _measure: () => void;
+}
+export {};
+//# sourceMappingURL=cell-measurer.d.ts.map

package/es/cell-measurer/cell-measurer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cell-measurer.d.ts","sourceRoot":"","sources":["../../src/cell-measurer/cell-measurer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,KAAK,QAAQ,GAAG,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,MAAM,IAAI,CAAA;CAAE,KAAK,KAAK,CAAC,SAAS,CAAC;AAErE,KAAK,IAAI,GAAG;IACV,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,KAAK,KAAK,GAAG;IACX,KAAK,EAAE,gBAAgB,CAAC;IACxB,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC,SAAS,CAAC;IACrC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,EAAE;QACN,6BAA6B,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;QACrD,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;KAC1C,CAAC;IACF,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,KAAK,CAAC,aAAa,CAAC,KAAK,CAAC;IAClE,MAAM,CAAC,0BAA0B,UAAS;IAEjC,iBAAiB;IAIjB,kBAAkB;IAIlB,MAAM;IAQf,oBAAoB;;;;IAkDpB,iBAAiB;IAuBjB,QAAQ,aAuBN;CACH"}