@redis-ui/components 49.1.1 → 50.0.1

package/dist/node_modules/memoize-one/dist/memoize-one.esm.js

@@ -0,0 +1,34 @@
+//#region ../../node_modules/memoize-one/dist/memoize-one.esm.js
+var safeIsNaN = Number.isNaN || function ponyfill(value) {
+	return typeof value === "number" && value !== value;
+};
+function isEqual(first, second) {
+	if (first === second) return true;
+	if (safeIsNaN(first) && safeIsNaN(second)) return true;
+	return false;
+}
+function areInputsEqual(newInputs, lastInputs) {
+	if (newInputs.length !== lastInputs.length) return false;
+	for (var i = 0; i < newInputs.length; i++) if (!isEqual(newInputs[i], lastInputs[i])) return false;
+	return true;
+}
+function memoizeOne(resultFn, isEqual) {
+	if (isEqual === void 0) isEqual = areInputsEqual;
+	var lastThis;
+	var lastArgs = [];
+	var lastResult;
+	var calledOnce = false;
+	function memoized() {
+		var newArgs = [];
+		for (var _i = 0; _i < arguments.length; _i++) newArgs[_i] = arguments[_i];
+		if (calledOnce && lastThis === this && isEqual(newArgs, lastArgs)) return lastResult;
+		lastResult = resultFn.apply(this, newArgs);
+		calledOnce = true;
+		lastThis = this;
+		lastArgs = newArgs;
+		return lastResult;
+	}
+	return memoized;
+}
+//#endregion
+export { memoizeOne as default };

package/dist/node_modules/react-window/dist/index.esm.cjs

@@ -0,0 +1,425 @@
+const require_extends = require("../../@babel/runtime/helpers/esm/extends.cjs");
+const require_assertThisInitialized = require("../../@babel/runtime/helpers/esm/assertThisInitialized.cjs");
+const require_inheritsLoose = require("../../@babel/runtime/helpers/esm/inheritsLoose.cjs");
+const require_memoize_one_esm = require("../../memoize-one/dist/memoize-one.esm.cjs");
+let react = require("react");
+//#region ../../node_modules/react-window/dist/index.esm.js
+var now = typeof performance === "object" && typeof performance.now === "function" ? function() {
+	return performance.now();
+} : function() {
+	return Date.now();
+};
+function cancelTimeout(timeoutID) {
+	cancelAnimationFrame(timeoutID.id);
+}
+function requestTimeout(callback, delay) {
+	var start = now();
+	function tick() {
+		if (now() - start >= delay) callback.call(null);
+		else timeoutID.id = requestAnimationFrame(tick);
+	}
+	var timeoutID = { id: requestAnimationFrame(tick) };
+	return timeoutID;
+}
+var size = -1;
+function getScrollbarSize(recalculate) {
+	if (recalculate === void 0) recalculate = false;
+	if (size === -1 || recalculate) {
+		var div = document.createElement("div");
+		var style = div.style;
+		style.width = "50px";
+		style.height = "50px";
+		style.overflow = "scroll";
+		document.body.appendChild(div);
+		size = div.offsetWidth - div.clientWidth;
+		document.body.removeChild(div);
+	}
+	return size;
+}
+var cachedRTLResult = null;
+function getRTLOffsetType(recalculate) {
+	if (recalculate === void 0) recalculate = false;
+	if (cachedRTLResult === null || recalculate) {
+		var outerDiv = document.createElement("div");
+		var outerStyle = outerDiv.style;
+		outerStyle.width = "50px";
+		outerStyle.height = "50px";
+		outerStyle.overflow = "scroll";
+		outerStyle.direction = "rtl";
+		var innerDiv = document.createElement("div");
+		var innerStyle = innerDiv.style;
+		innerStyle.width = "100px";
+		innerStyle.height = "100px";
+		outerDiv.appendChild(innerDiv);
+		document.body.appendChild(outerDiv);
+		if (outerDiv.scrollLeft > 0) cachedRTLResult = "positive-descending";
+		else {
+			outerDiv.scrollLeft = 1;
+			if (outerDiv.scrollLeft === 0) cachedRTLResult = "negative";
+			else cachedRTLResult = "positive-ascending";
+		}
+		document.body.removeChild(outerDiv);
+		return cachedRTLResult;
+	}
+	return cachedRTLResult;
+}
+if (process.env.NODE_ENV !== "production") {
+	if (typeof window !== "undefined" && typeof window.WeakSet !== "undefined") {}
+}
+var IS_SCROLLING_DEBOUNCE_INTERVAL$1 = 150;
+var defaultItemKey$1 = function defaultItemKey(index, data) {
+	return index;
+};
+var devWarningsDirection = null;
+var devWarningsTagName$1 = null;
+if (process.env.NODE_ENV !== "production") {
+	if (typeof window !== "undefined" && typeof window.WeakSet !== "undefined") {
+		devWarningsDirection = /*#__PURE__*/ new WeakSet();
+		devWarningsTagName$1 = /*#__PURE__*/ new WeakSet();
+	}
+}
+function createListComponent(_ref) {
+	var _class;
+	var getItemOffset = _ref.getItemOffset, getEstimatedTotalSize = _ref.getEstimatedTotalSize, getItemSize = _ref.getItemSize, getOffsetForIndexAndAlignment = _ref.getOffsetForIndexAndAlignment, getStartIndexForOffset = _ref.getStartIndexForOffset, getStopIndexForStartIndex = _ref.getStopIndexForStartIndex, initInstanceProps = _ref.initInstanceProps, shouldResetStyleCacheOnItemSizeChange = _ref.shouldResetStyleCacheOnItemSizeChange, validateProps = _ref.validateProps;
+	return _class = /*#__PURE__*/ function(_PureComponent) {
+		require_inheritsLoose._inheritsLoose(List, _PureComponent);
+		function List(props) {
+			var _this = _PureComponent.call(this, props) || this;
+			_this._instanceProps = initInstanceProps(_this.props, require_assertThisInitialized._assertThisInitialized(_this));
+			_this._outerRef = void 0;
+			_this._resetIsScrollingTimeoutId = null;
+			_this.state = {
+				instance: require_assertThisInitialized._assertThisInitialized(_this),
+				isScrolling: false,
+				scrollDirection: "forward",
+				scrollOffset: typeof _this.props.initialScrollOffset === "number" ? _this.props.initialScrollOffset : 0,
+				scrollUpdateWasRequested: false
+			};
+			_this._callOnItemsRendered = void 0;
+			_this._callOnItemsRendered = require_memoize_one_esm.default(function(overscanStartIndex, overscanStopIndex, visibleStartIndex, visibleStopIndex) {
+				return _this.props.onItemsRendered({
+					overscanStartIndex,
+					overscanStopIndex,
+					visibleStartIndex,
+					visibleStopIndex
+				});
+			});
+			_this._callOnScroll = void 0;
+			_this._callOnScroll = require_memoize_one_esm.default(function(scrollDirection, scrollOffset, scrollUpdateWasRequested) {
+				return _this.props.onScroll({
+					scrollDirection,
+					scrollOffset,
+					scrollUpdateWasRequested
+				});
+			});
+			_this._getItemStyle = void 0;
+			_this._getItemStyle = function(index) {
+				var _this$props = _this.props, direction = _this$props.direction, itemSize = _this$props.itemSize, layout = _this$props.layout;
+				var itemStyleCache = _this._getItemStyleCache(shouldResetStyleCacheOnItemSizeChange && itemSize, shouldResetStyleCacheOnItemSizeChange && layout, shouldResetStyleCacheOnItemSizeChange && direction);
+				var style;
+				if (itemStyleCache.hasOwnProperty(index)) style = itemStyleCache[index];
+				else {
+					var _offset = getItemOffset(_this.props, index, _this._instanceProps);
+					var size = getItemSize(_this.props, index, _this._instanceProps);
+					var isHorizontal = direction === "horizontal" || layout === "horizontal";
+					var isRtl = direction === "rtl";
+					var offsetHorizontal = isHorizontal ? _offset : 0;
+					itemStyleCache[index] = style = {
+						position: "absolute",
+						left: isRtl ? void 0 : offsetHorizontal,
+						right: isRtl ? offsetHorizontal : void 0,
+						top: !isHorizontal ? _offset : 0,
+						height: !isHorizontal ? size : "100%",
+						width: isHorizontal ? size : "100%"
+					};
+				}
+				return style;
+			};
+			_this._getItemStyleCache = void 0;
+			_this._getItemStyleCache = require_memoize_one_esm.default(function(_, __, ___) {
+				return {};
+			});
+			_this._onScrollHorizontal = function(event) {
+				var _event$currentTarget = event.currentTarget, clientWidth = _event$currentTarget.clientWidth, scrollLeft = _event$currentTarget.scrollLeft, scrollWidth = _event$currentTarget.scrollWidth;
+				_this.setState(function(prevState) {
+					if (prevState.scrollOffset === scrollLeft) return null;
+					var direction = _this.props.direction;
+					var scrollOffset = scrollLeft;
+					if (direction === "rtl") switch (getRTLOffsetType()) {
+						case "negative":
+							scrollOffset = -scrollLeft;
+							break;
+						case "positive-descending":
+							scrollOffset = scrollWidth - clientWidth - scrollLeft;
+							break;
+					}
+					scrollOffset = Math.max(0, Math.min(scrollOffset, scrollWidth - clientWidth));
+					return {
+						isScrolling: true,
+						scrollDirection: prevState.scrollOffset < scrollOffset ? "forward" : "backward",
+						scrollOffset,
+						scrollUpdateWasRequested: false
+					};
+				}, _this._resetIsScrollingDebounced);
+			};
+			_this._onScrollVertical = function(event) {
+				var _event$currentTarget2 = event.currentTarget, clientHeight = _event$currentTarget2.clientHeight, scrollHeight = _event$currentTarget2.scrollHeight, scrollTop = _event$currentTarget2.scrollTop;
+				_this.setState(function(prevState) {
+					if (prevState.scrollOffset === scrollTop) return null;
+					var scrollOffset = Math.max(0, Math.min(scrollTop, scrollHeight - clientHeight));
+					return {
+						isScrolling: true,
+						scrollDirection: prevState.scrollOffset < scrollOffset ? "forward" : "backward",
+						scrollOffset,
+						scrollUpdateWasRequested: false
+					};
+				}, _this._resetIsScrollingDebounced);
+			};
+			_this._outerRefSetter = function(ref) {
+				var outerRef = _this.props.outerRef;
+				_this._outerRef = ref;
+				if (typeof outerRef === "function") outerRef(ref);
+				else if (outerRef != null && typeof outerRef === "object" && outerRef.hasOwnProperty("current")) outerRef.current = ref;
+			};
+			_this._resetIsScrollingDebounced = function() {
+				if (_this._resetIsScrollingTimeoutId !== null) cancelTimeout(_this._resetIsScrollingTimeoutId);
+				_this._resetIsScrollingTimeoutId = requestTimeout(_this._resetIsScrolling, IS_SCROLLING_DEBOUNCE_INTERVAL$1);
+			};
+			_this._resetIsScrolling = function() {
+				_this._resetIsScrollingTimeoutId = null;
+				_this.setState({ isScrolling: false }, function() {
+					_this._getItemStyleCache(-1, null);
+				});
+			};
+			return _this;
+		}
+		List.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, prevState) {
+			validateSharedProps$1(nextProps, prevState);
+			validateProps(nextProps);
+			return null;
+		};
+		var _proto = List.prototype;
+		_proto.scrollTo = function scrollTo(scrollOffset) {
+			scrollOffset = Math.max(0, scrollOffset);
+			this.setState(function(prevState) {
+				if (prevState.scrollOffset === scrollOffset) return null;
+				return {
+					scrollDirection: prevState.scrollOffset < scrollOffset ? "forward" : "backward",
+					scrollOffset,
+					scrollUpdateWasRequested: true
+				};
+			}, this._resetIsScrollingDebounced);
+		};
+		_proto.scrollToItem = function scrollToItem(index, align) {
+			if (align === void 0) align = "auto";
+			var _this$props2 = this.props, itemCount = _this$props2.itemCount, layout = _this$props2.layout;
+			var scrollOffset = this.state.scrollOffset;
+			index = Math.max(0, Math.min(index, itemCount - 1));
+			var scrollbarSize = 0;
+			if (this._outerRef) {
+				var outerRef = this._outerRef;
+				if (layout === "vertical") scrollbarSize = outerRef.scrollWidth > outerRef.clientWidth ? getScrollbarSize() : 0;
+				else scrollbarSize = outerRef.scrollHeight > outerRef.clientHeight ? getScrollbarSize() : 0;
+			}
+			this.scrollTo(getOffsetForIndexAndAlignment(this.props, index, align, scrollOffset, this._instanceProps, scrollbarSize));
+		};
+		_proto.componentDidMount = function componentDidMount() {
+			var _this$props3 = this.props, direction = _this$props3.direction, initialScrollOffset = _this$props3.initialScrollOffset, layout = _this$props3.layout;
+			if (typeof initialScrollOffset === "number" && this._outerRef != null) {
+				var outerRef = this._outerRef;
+				if (direction === "horizontal" || layout === "horizontal") outerRef.scrollLeft = initialScrollOffset;
+				else outerRef.scrollTop = initialScrollOffset;
+			}
+			this._callPropsCallbacks();
+		};
+		_proto.componentDidUpdate = function componentDidUpdate() {
+			var _this$props4 = this.props, direction = _this$props4.direction, layout = _this$props4.layout;
+			var _this$state = this.state, scrollOffset = _this$state.scrollOffset;
+			if (_this$state.scrollUpdateWasRequested && this._outerRef != null) {
+				var outerRef = this._outerRef;
+				if (direction === "horizontal" || layout === "horizontal") if (direction === "rtl") switch (getRTLOffsetType()) {
+					case "negative":
+						outerRef.scrollLeft = -scrollOffset;
+						break;
+					case "positive-ascending":
+						outerRef.scrollLeft = scrollOffset;
+						break;
+					default:
+						var clientWidth = outerRef.clientWidth;
+						outerRef.scrollLeft = outerRef.scrollWidth - clientWidth - scrollOffset;
+						break;
+				}
+				else outerRef.scrollLeft = scrollOffset;
+				else outerRef.scrollTop = scrollOffset;
+			}
+			this._callPropsCallbacks();
+		};
+		_proto.componentWillUnmount = function componentWillUnmount() {
+			if (this._resetIsScrollingTimeoutId !== null) cancelTimeout(this._resetIsScrollingTimeoutId);
+		};
+		_proto.render = function render() {
+			var _this$props5 = this.props, children = _this$props5.children, className = _this$props5.className, direction = _this$props5.direction, height = _this$props5.height, innerRef = _this$props5.innerRef, innerElementType = _this$props5.innerElementType, innerTagName = _this$props5.innerTagName, itemCount = _this$props5.itemCount, itemData = _this$props5.itemData, _this$props5$itemKey = _this$props5.itemKey, itemKey = _this$props5$itemKey === void 0 ? defaultItemKey$1 : _this$props5$itemKey, layout = _this$props5.layout, outerElementType = _this$props5.outerElementType, outerTagName = _this$props5.outerTagName, style = _this$props5.style, useIsScrolling = _this$props5.useIsScrolling, width = _this$props5.width;
+			var isScrolling = this.state.isScrolling;
+			var isHorizontal = direction === "horizontal" || layout === "horizontal";
+			var onScroll = isHorizontal ? this._onScrollHorizontal : this._onScrollVertical;
+			var _this$_getRangeToRend = this._getRangeToRender(), startIndex = _this$_getRangeToRend[0], stopIndex = _this$_getRangeToRend[1];
+			var items = [];
+			if (itemCount > 0) for (var _index = startIndex; _index <= stopIndex; _index++) items.push((0, react.createElement)(children, {
+				data: itemData,
+				key: itemKey(_index, itemData),
+				index: _index,
+				isScrolling: useIsScrolling ? isScrolling : void 0,
+				style: this._getItemStyle(_index)
+			}));
+			var estimatedTotalSize = getEstimatedTotalSize(this.props, this._instanceProps);
+			return (0, react.createElement)(outerElementType || outerTagName || "div", {
+				className,
+				onScroll,
+				ref: this._outerRefSetter,
+				style: require_extends._extends({
+					position: "relative",
+					height,
+					width,
+					overflow: "auto",
+					WebkitOverflowScrolling: "touch",
+					willChange: "transform",
+					direction
+				}, style)
+			}, (0, react.createElement)(innerElementType || innerTagName || "div", {
+				children: items,
+				ref: innerRef,
+				style: {
+					height: isHorizontal ? "100%" : estimatedTotalSize,
+					pointerEvents: isScrolling ? "none" : void 0,
+					width: isHorizontal ? estimatedTotalSize : "100%"
+				}
+			}));
+		};
+		_proto._callPropsCallbacks = function _callPropsCallbacks() {
+			if (typeof this.props.onItemsRendered === "function") {
+				if (this.props.itemCount > 0) {
+					var _this$_getRangeToRend2 = this._getRangeToRender(), _overscanStartIndex = _this$_getRangeToRend2[0], _overscanStopIndex = _this$_getRangeToRend2[1], _visibleStartIndex = _this$_getRangeToRend2[2], _visibleStopIndex = _this$_getRangeToRend2[3];
+					this._callOnItemsRendered(_overscanStartIndex, _overscanStopIndex, _visibleStartIndex, _visibleStopIndex);
+				}
+			}
+			if (typeof this.props.onScroll === "function") {
+				var _this$state2 = this.state, _scrollDirection = _this$state2.scrollDirection, _scrollOffset = _this$state2.scrollOffset, _scrollUpdateWasRequested = _this$state2.scrollUpdateWasRequested;
+				this._callOnScroll(_scrollDirection, _scrollOffset, _scrollUpdateWasRequested);
+			}
+		};
+		_proto._getRangeToRender = function _getRangeToRender() {
+			var _this$props6 = this.props, itemCount = _this$props6.itemCount, overscanCount = _this$props6.overscanCount;
+			var _this$state3 = this.state, isScrolling = _this$state3.isScrolling, scrollDirection = _this$state3.scrollDirection, scrollOffset = _this$state3.scrollOffset;
+			if (itemCount === 0) return [
+				0,
+				0,
+				0,
+				0
+			];
+			var startIndex = getStartIndexForOffset(this.props, scrollOffset, this._instanceProps);
+			var stopIndex = getStopIndexForStartIndex(this.props, startIndex, scrollOffset, this._instanceProps);
+			var overscanBackward = !isScrolling || scrollDirection === "backward" ? Math.max(1, overscanCount) : 1;
+			var overscanForward = !isScrolling || scrollDirection === "forward" ? Math.max(1, overscanCount) : 1;
+			return [
+				Math.max(0, startIndex - overscanBackward),
+				Math.max(0, Math.min(itemCount - 1, stopIndex + overscanForward)),
+				startIndex,
+				stopIndex
+			];
+		};
+		return List;
+	}(react.PureComponent), _class.defaultProps = {
+		direction: "ltr",
+		itemData: void 0,
+		layout: "vertical",
+		overscanCount: 2,
+		useIsScrolling: false
+	}, _class;
+}
+var validateSharedProps$1 = function validateSharedProps(_ref2, _ref3) {
+	var children = _ref2.children, direction = _ref2.direction, height = _ref2.height, layout = _ref2.layout, innerTagName = _ref2.innerTagName, outerTagName = _ref2.outerTagName, width = _ref2.width;
+	var instance = _ref3.instance;
+	if (process.env.NODE_ENV !== "production") {
+		if (innerTagName != null || outerTagName != null) {
+			if (devWarningsTagName$1 && !devWarningsTagName$1.has(instance)) {
+				devWarningsTagName$1.add(instance);
+				console.warn("The innerTagName and outerTagName props have been deprecated. Please use the innerElementType and outerElementType props instead.");
+			}
+		}
+		var isHorizontal = direction === "horizontal" || layout === "horizontal";
+		switch (direction) {
+			case "horizontal":
+			case "vertical":
+				if (devWarningsDirection && !devWarningsDirection.has(instance)) {
+					devWarningsDirection.add(instance);
+					console.warn("The direction prop should be either \"ltr\" (default) or \"rtl\". Please use the layout prop to specify \"vertical\" (default) or \"horizontal\" orientation.");
+				}
+				break;
+			case "ltr":
+			case "rtl": break;
+			default: throw Error("An invalid \"direction\" prop has been specified. Value should be either \"ltr\" or \"rtl\". " + ("\"" + direction + "\" was specified."));
+		}
+		switch (layout) {
+			case "horizontal":
+			case "vertical": break;
+			default: throw Error("An invalid \"layout\" prop has been specified. Value should be either \"horizontal\" or \"vertical\". " + ("\"" + layout + "\" was specified."));
+		}
+		if (children == null) throw Error("An invalid \"children\" prop has been specified. Value should be a React component. " + ("\"" + (children === null ? "null" : typeof children) + "\" was specified."));
+		if (isHorizontal && typeof width !== "number") throw Error("An invalid \"width\" prop has been specified. Horizontal lists must specify a number for width. " + ("\"" + (width === null ? "null" : typeof width) + "\" was specified."));
+		else if (!isHorizontal && typeof height !== "number") throw Error("An invalid \"height\" prop has been specified. Vertical lists must specify a number for height. " + ("\"" + (height === null ? "null" : typeof height) + "\" was specified."));
+	}
+};
+var FixedSizeList = /*#__PURE__*/ createListComponent({
+	getItemOffset: function getItemOffset(_ref, index) {
+		return index * _ref.itemSize;
+	},
+	getItemSize: function getItemSize(_ref2, index) {
+		return _ref2.itemSize;
+	},
+	getEstimatedTotalSize: function getEstimatedTotalSize(_ref3) {
+		var itemCount = _ref3.itemCount;
+		return _ref3.itemSize * itemCount;
+	},
+	getOffsetForIndexAndAlignment: function getOffsetForIndexAndAlignment(_ref4, index, align, scrollOffset, instanceProps, scrollbarSize) {
+		var direction = _ref4.direction, height = _ref4.height, itemCount = _ref4.itemCount, itemSize = _ref4.itemSize, layout = _ref4.layout, width = _ref4.width;
+		var size = direction === "horizontal" || layout === "horizontal" ? width : height;
+		var lastItemOffset = Math.max(0, itemCount * itemSize - size);
+		var maxOffset = Math.min(lastItemOffset, index * itemSize);
+		var minOffset = Math.max(0, index * itemSize - size + itemSize + scrollbarSize);
+		if (align === "smart") if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) align = "auto";
+		else align = "center";
+		switch (align) {
+			case "start": return maxOffset;
+			case "end": return minOffset;
+			case "center":
+				var middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
+				if (middleOffset < Math.ceil(size / 2)) return 0;
+				else if (middleOffset > lastItemOffset + Math.floor(size / 2)) return lastItemOffset;
+				else return middleOffset;
+			default: if (scrollOffset >= minOffset && scrollOffset <= maxOffset) return scrollOffset;
+			else if (scrollOffset < minOffset) return minOffset;
+			else return maxOffset;
+		}
+	},
+	getStartIndexForOffset: function getStartIndexForOffset(_ref5, offset) {
+		var itemCount = _ref5.itemCount, itemSize = _ref5.itemSize;
+		return Math.max(0, Math.min(itemCount - 1, Math.floor(offset / itemSize)));
+	},
+	getStopIndexForStartIndex: function getStopIndexForStartIndex(_ref6, startIndex, scrollOffset) {
+		var direction = _ref6.direction, height = _ref6.height, itemCount = _ref6.itemCount, itemSize = _ref6.itemSize, layout = _ref6.layout, width = _ref6.width;
+		var isHorizontal = direction === "horizontal" || layout === "horizontal";
+		var offset = startIndex * itemSize;
+		var numVisibleItems = Math.ceil(((isHorizontal ? width : height) + scrollOffset - offset) / itemSize);
+		return Math.max(0, Math.min(itemCount - 1, startIndex + numVisibleItems - 1));
+	},
+	initInstanceProps: function initInstanceProps(props) {},
+	shouldResetStyleCacheOnItemSizeChange: true,
+	validateProps: function validateProps(_ref7) {
+		var itemSize = _ref7.itemSize;
+		if (process.env.NODE_ENV !== "production") {
+			if (typeof itemSize !== "number") throw Error("An invalid \"itemSize\" prop has been specified. Value should be a number. " + ("\"" + (itemSize === null ? "null" : typeof itemSize) + "\" was specified."));
+		}
+	}
+});
+//#endregion
+exports.FixedSizeList = FixedSizeList;