Diffusion Open Access Compliance Check Tool (OACCT) (paginated-inlines) Browse

rOACCT/node_modules/@mui/base/legacy/TextareaAutosize/TextareaAutosize.js
f646e1f695a7paginated-inlines

TextareaAutosize.js
View Options

			import _extends from "@babel/runtime/helpers/esm/extends";
			import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
			import * as React from 'react';
			import PropTypes from 'prop-types';
			import { flushSync } from 'react-dom';
			import { unstable_debounce as debounce, unstable_useForkRef as useForkRef, unstable_useEnhancedEffect as useEnhancedEffect, unstable_ownerWindow as ownerWindow } from '@mui/utils';
			import { jsx as _jsx } from "react/jsx-runtime";
			import { jsxs as _jsxs } from "react/jsx-runtime";
			function getStyleValue(computedStyle, property) {
			return parseInt(computedStyle[property], 10) \|\| 0;
			}
			var styles = {
			shadow: {
			// Visibility needed to hide the extra text area on iPads
			visibility: 'hidden',
			// Remove from the content flow
			position: 'absolute',
			// Ignore the scrollbar width
			overflow: 'hidden',
			height: 0,
			top: 0,
			left: 0,
			// Create a new layer, increase the isolation of the computed values
			transform: 'translateZ(0)'
			}
			};
			function isEmpty(obj) {
			return obj === undefined \|\| obj === null \|\| Object.keys(obj).length === 0;
			}
			var TextareaAutosize = /#__PURE__/React.forwardRef(function TextareaAutosize(props, ref) {
			var onChange = props.onChange,
			maxRows = props.maxRows,
			_props$minRows = props.minRows,
			minRows = _props$minRows === void 0 ? 1 : _props$minRows,
			style = props.style,
			value = props.value,
			other = _objectWithoutProperties(props, ["onChange", "maxRows", "minRows", "style", "value"]);
			var _React$useRef = React.useRef(value != null),
			isControlled = _React$useRef.current;
			var inputRef = React.useRef(null);
			var handleRef = useForkRef(ref, inputRef);
			var shadowRef = React.useRef(null);
			var renders = React.useRef(0);
			var _React$useState = React.useState({}),
			state = _React$useState[0],
			setState = _React$useState[1];
			var getUpdatedState = React.useCallback(function () {
			var input = inputRef.current;
			var containerWindow = ownerWindow(input);
			var computedStyle = containerWindow.getComputedStyle(input);

			// If input's width is shrunk and it's not visible, don't sync height.
			if (computedStyle.width === '0px') {
			return {};
			}
			var inputShallow = shadowRef.current;
			inputShallow.style.width = computedStyle.width;
			inputShallow.value = input.value \|\| props.placeholder \|\| 'x';
			if (inputShallow.value.slice(-1) === '\n') {
			// Certain fonts which overflow the line height will cause the textarea
			// to report a different scrollHeight depending on whether the last line
			// is empty. Make it non-empty to avoid this issue.
			inputShallow.value += ' ';
			}
			var boxSizing = computedStyle['box-sizing'];
			var padding = getStyleValue(computedStyle, 'padding-bottom') + getStyleValue(computedStyle, 'padding-top');
			var border = getStyleValue(computedStyle, 'border-bottom-width') + getStyleValue(computedStyle, 'border-top-width');

			// The height of the inner content
			var innerHeight = inputShallow.scrollHeight;

			// Measure height of a textarea with a single row
			inputShallow.value = 'x';
			var singleRowHeight = inputShallow.scrollHeight;

			// The height of the outer content
			var outerHeight = innerHeight;
			if (minRows) {
			outerHeight = Math.max(Number(minRows) * singleRowHeight, outerHeight);
			}
			if (maxRows) {
			outerHeight = Math.min(Number(maxRows) * singleRowHeight, outerHeight);
			}
			outerHeight = Math.max(outerHeight, singleRowHeight);

			// Take the box sizing into account for applying this value as a style.
			var outerHeightStyle = outerHeight + (boxSizing === 'border-box' ? padding + border : 0);
			var overflow = Math.abs(outerHeight - innerHeight) <= 1;
			return {
			outerHeightStyle: outerHeightStyle,
			overflow: overflow
			};
			}, [maxRows, minRows, props.placeholder]);
			var updateState = function updateState(prevState, newState) {
			var outerHeightStyle = newState.outerHeightStyle,
			overflow = newState.overflow; // Need a large enough difference to update the height.
			// This prevents infinite rendering loop.
			if (renders.current < 20 && (outerHeightStyle > 0 && Math.abs((prevState.outerHeightStyle \|\| 0) - outerHeightStyle) > 1 \|\| prevState.overflow !== overflow)) {
			renders.current += 1;
			return {
			overflow: overflow,
			outerHeightStyle: outerHeightStyle
			};
			}
			if (process.env.NODE_ENV !== 'production') {
			if (renders.current === 20) {
			console.error(['MUI: Too many re-renders. The layout is unstable.', 'TextareaAutosize limits the number of renders to prevent an infinite loop.'].join('\n'));
			}
			}
			return prevState;
			};
			var syncHeight = React.useCallback(function () {
			var newState = getUpdatedState();
			if (isEmpty(newState)) {
			return;
			}
			setState(function (prevState) {
			return updateState(prevState, newState);
			});
			}, [getUpdatedState]);
			var syncHeightWithFlushSycn = function syncHeightWithFlushSycn() {
			var newState = getUpdatedState();
			if (isEmpty(newState)) {
			return;
			}

			// In React 18, state updates in a ResizeObserver's callback are happening after the paint which causes flickering
			// when doing some visual updates in it. Using flushSync ensures that the dom will be painted after the states updates happen
			// Related issue - https://github.com/facebook/react/issues/24331
			flushSync(function () {
			setState(function (prevState) {
			return updateState(prevState, newState);
			});
			});
			};
			React.useEffect(function () {
			var handleResize = debounce(function () {
			renders.current = 0;

			// If the TextareaAutosize component is replaced by Suspense with a fallback, the last
			// ResizeObserver's handler that runs because of the change in the layout is trying to
			// access a dom node that is no longer there (as the fallback component is being shown instead).
			// See https://github.com/mui/material-ui/issues/32640
			if (inputRef.current) {
			syncHeightWithFlushSycn();
			}
			});
			var containerWindow = ownerWindow(inputRef.current);
			containerWindow.addEventListener('resize', handleResize);
			var resizeObserver;
			if (typeof ResizeObserver !== 'undefined') {
			resizeObserver = new ResizeObserver(handleResize);
			resizeObserver.observe(inputRef.current);
			}
			return function () {
			handleResize.clear();
			containerWindow.removeEventListener('resize', handleResize);
			if (resizeObserver) {
			resizeObserver.disconnect();
			}
			};
			});
			useEnhancedEffect(function () {
			syncHeight();
			});
			React.useEffect(function () {
			renders.current = 0;
			}, [value]);
			var handleChange = function handleChange(event) {
			renders.current = 0;
			if (!isControlled) {
			syncHeight();
			}
			if (onChange) {
			onChange(event);
			}
			};
			return /#__PURE__/_jsxs(React.Fragment, {
			children: [/#__PURE__/_jsx("textarea", _extends({
			value: value,
			onChange: handleChange,
			ref: handleRef
			// Apply the rows prop to get a "correct" first SSR paint
			,
			rows: minRows,
			style: _extends({
			height: state.outerHeightStyle,
			// Need a large enough difference to allow scrolling.
			// This prevents infinite rendering loop.
			overflow: state.overflow ? 'hidden' : null
			}, style)
			}, other)), /#__PURE__/_jsx("textarea", {
			"aria-hidden": true,
			className: props.className,
			readOnly: true,
			ref: shadowRef,
			tabIndex: -1,
			style: _extends({}, styles.shadow, style, {
			padding: 0
			})
			})]
			});
			});
			process.env.NODE_ENV !== "production" ? TextareaAutosize.propTypes /* remove-proptypes */ = {
			// ----------------------------- Warning --------------------------------
			// \| These PropTypes are generated from the TypeScript type definitions \|
			// \| To update them edit the d.ts file and run "yarn proptypes" \|
			// ----------------------------------------------------------------------
			/**
			* @ignore
			*/
			className: PropTypes.string,
			/**
			* Maximum number of rows to display.
			*/
			maxRows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
			/**
			* Minimum number of rows to display.
			* @default 1
			*/
			minRows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
			/**
			* @ignore
			*/
			onChange: PropTypes.func,
			/**
			* @ignore
			*/
			placeholder: PropTypes.string,
			/**
			* @ignore
			*/
			style: PropTypes.object,
			/**
			* @ignore
			*/
			value: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.string), PropTypes.number, PropTypes.string])
			} : void 0;
			export default TextareaAutosize;