Diffusion Open Access Compliance Check Tool (OACCT) (issn4frontend) Browse

rOACCT/node_modules/@mui/base/modern/TextareaAutosize/TextareaAutosize.js
49c99f97fe9aissn4frontend

TextareaAutosize.js
View Options

			import _extends from "@babel/runtime/helpers/esm/extends";
			import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
			const _excluded = ["onChange", "maxRows", "minRows", "style", "value"];
			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;
			}
			const 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;
			}
			const TextareaAutosize = /#__PURE__/React.forwardRef(function TextareaAutosize(props, ref) {
			const {
			onChange,
			maxRows,
			minRows = 1,
			style,
			value
			} = props,
			other = _objectWithoutPropertiesLoose(props, _excluded);
			const {
			current: isControlled
			} = React.useRef(value != null);
			const inputRef = React.useRef(null);
			const handleRef = useForkRef(ref, inputRef);
			const shadowRef = React.useRef(null);
			const renders = React.useRef(0);
			const [state, setState] = React.useState({});
			const getUpdatedState = React.useCallback(() => {
			const input = inputRef.current;
			const containerWindow = ownerWindow(input);
			const computedStyle = containerWindow.getComputedStyle(input);

			// If input's width is shrunk and it's not visible, don't sync height.
			if (computedStyle.width === '0px') {
			return {};
			}
			const 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 += ' ';
			}
			const boxSizing = computedStyle['box-sizing'];
			const padding = getStyleValue(computedStyle, 'padding-bottom') + getStyleValue(computedStyle, 'padding-top');
			const border = getStyleValue(computedStyle, 'border-bottom-width') + getStyleValue(computedStyle, 'border-top-width');

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

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

			// The height of the outer content
			let 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.
			const outerHeightStyle = outerHeight + (boxSizing === 'border-box' ? padding + border : 0);
			const overflow = Math.abs(outerHeight - innerHeight) <= 1;
			return {
			outerHeightStyle,
			overflow
			};
			}, [maxRows, minRows, props.placeholder]);
			const updateState = (prevState, newState) => {
			const {
			outerHeightStyle,
			overflow
			} = newState;
			// 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,
			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;
			};
			const syncHeight = React.useCallback(() => {
			const newState = getUpdatedState();
			if (isEmpty(newState)) {
			return;
			}
			setState(prevState => {
			return updateState(prevState, newState);
			});
			}, [getUpdatedState]);
			const syncHeightWithFlushSycn = () => {
			const 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(() => {
			setState(prevState => {
			return updateState(prevState, newState);
			});
			});
			};
			React.useEffect(() => {
			const handleResize = debounce(() => {
			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();
			}
			});
			const containerWindow = ownerWindow(inputRef.current);
			containerWindow.addEventListener('resize', handleResize);
			let resizeObserver;
			if (typeof ResizeObserver !== 'undefined') {
			resizeObserver = new ResizeObserver(handleResize);
			resizeObserver.observe(inputRef.current);
			}
			return () => {
			handleResize.clear();
			containerWindow.removeEventListener('resize', handleResize);
			if (resizeObserver) {
			resizeObserver.disconnect();
			}
			};
			});
			useEnhancedEffect(() => {
			syncHeight();
			});
			React.useEffect(() => {
			renders.current = 0;
			}, [value]);
			const 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;