frontend-admin / Daocheng-Yading

  "use strict";
  'use client';
  
  var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
  var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;
  var React = _interopRequireWildcard(require("react"));
  var _propTypes = _interopRequireDefault(require("prop-types"));
  var _debounce = _interopRequireDefault(require("@mui/utils/debounce"));
  var _useForkRef = _interopRequireDefault(require("@mui/utils/useForkRef"));
  var _useEnhancedEffect = _interopRequireDefault(require("@mui/utils/useEnhancedEffect"));
  var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
  var _ownerWindow = _interopRequireDefault(require("@mui/utils/ownerWindow"));
  var _jsxRuntime = require("react/jsx-runtime");
  function getStyleValue(value) {
    return parseInt(value, 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 isObjectEmpty(object) {
    // eslint-disable-next-line
    for (const _ in object) {
      return false;
    }
    return true;
  }
  function isEmpty(obj) {
    return isObjectEmpty(obj) || obj.outerHeightStyle === 0 && !obj.overflowing;
  }
  
  /**
   *
   * Demos:
   *
   * - [Textarea Autosize](https://mui.com/material-ui/react-textarea-autosize/)
   *
   * API:
   *
   * - [TextareaAutosize API](https://mui.com/material-ui/api/textarea-autosize/)
   */
  const TextareaAutosize = /*#__PURE__*/React.forwardRef(function TextareaAutosize(props, forwardedRef) {
    const {
      onChange,
      maxRows,
      minRows = 1,
      style,
      value,
      ...other
    } = props;
    const {
      current: isControlled
    } = React.useRef(value != null);
    const textareaRef = React.useRef(null);
    const handleRef = (0, _useForkRef.default)(forwardedRef, textareaRef);
    const heightRef = React.useRef(null);
    const hiddenTextareaRef = React.useRef(null);
    const calculateTextareaStyles = React.useCallback(() => {
      const textarea = textareaRef.current;
      const hiddenTextarea = hiddenTextareaRef.current;
      if (!textarea || !hiddenTextarea) {
        return undefined;
      }
      const containerWindow = (0, _ownerWindow.default)(textarea);
      const computedStyle = containerWindow.getComputedStyle(textarea);
  
      // If input's width is shrunk and it's not visible, don't sync height.
      if (computedStyle.width === '0px') {
        return {
          outerHeightStyle: 0,
          overflowing: false
        };
      }
      hiddenTextarea.style.width = computedStyle.width;
      hiddenTextarea.value = textarea.value || props.placeholder || 'x';
      if (hiddenTextarea.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.
        hiddenTextarea.value += ' ';
      }
      const boxSizing = computedStyle.boxSizing;
      const padding = getStyleValue(computedStyle.paddingBottom) + getStyleValue(computedStyle.paddingTop);
      const border = getStyleValue(computedStyle.borderBottomWidth) + getStyleValue(computedStyle.borderTopWidth);
  
      // The height of the inner content
      const innerHeight = hiddenTextarea.scrollHeight;
  
      // Measure height of a textarea with a single row
      hiddenTextarea.value = 'x';
      const singleRowHeight = hiddenTextarea.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 overflowing = Math.abs(outerHeight - innerHeight) <= 1;
      return {
        outerHeightStyle,
        overflowing
      };
    }, [maxRows, minRows, props.placeholder]);
    const didHeightChange = (0, _useEventCallback.default)(() => {
      const textarea = textareaRef.current;
      const textareaStyles = calculateTextareaStyles();
      if (!textarea || !textareaStyles || isEmpty(textareaStyles)) {
        return false;
      }
      const outerHeightStyle = textareaStyles.outerHeightStyle;
      return heightRef.current != null && heightRef.current !== outerHeightStyle;
    });
    const syncHeight = React.useCallback(() => {
      const textarea = textareaRef.current;
      const textareaStyles = calculateTextareaStyles();
      if (!textarea || !textareaStyles || isEmpty(textareaStyles)) {
        return;
      }
      const outerHeightStyle = textareaStyles.outerHeightStyle;
      if (heightRef.current !== outerHeightStyle) {
        heightRef.current = outerHeightStyle;
        textarea.style.height = `${outerHeightStyle}px`;
      }
      textarea.style.overflow = textareaStyles.overflowing ? 'hidden' : '';
    }, [calculateTextareaStyles]);
    const frameRef = React.useRef(-1);
    (0, _useEnhancedEffect.default)(() => {
      const debouncedHandleResize = (0, _debounce.default)(syncHeight);
      const textarea = textareaRef?.current;
      if (!textarea) {
        return undefined;
      }
      const containerWindow = (0, _ownerWindow.default)(textarea);
      containerWindow.addEventListener('resize', debouncedHandleResize);
      let resizeObserver;
      if (typeof ResizeObserver !== 'undefined') {
        resizeObserver = new ResizeObserver(() => {
          if (didHeightChange()) {
            // avoid "ResizeObserver loop completed with undelivered notifications" error
            // by temporarily unobserving the textarea element while manipulating the height
            // and reobserving one frame later
            resizeObserver.unobserve(textarea);
            cancelAnimationFrame(frameRef.current);
            syncHeight();
            frameRef.current = requestAnimationFrame(() => {
              resizeObserver.observe(textarea);
            });
          }
        });
        resizeObserver.observe(textarea);
      }
      return () => {
        debouncedHandleResize.clear();
        cancelAnimationFrame(frameRef.current);
        containerWindow.removeEventListener('resize', debouncedHandleResize);
        if (resizeObserver) {
          resizeObserver.disconnect();
        }
      };
    }, [calculateTextareaStyles, syncHeight, didHeightChange]);
    (0, _useEnhancedEffect.default)(() => {
      syncHeight();
    });
    const handleChange = event => {
      if (!isControlled) {
        syncHeight();
      }
      const textarea = event.target;
      const countOfCharacters = textarea.value.length;
      const isLastCharacterNewLine = textarea.value.endsWith('\n');
      const isEndOfTheLine = textarea.selectionStart === countOfCharacters;
  
      // Set the cursor position to the very end of the text.
      if (isLastCharacterNewLine && isEndOfTheLine) {
        textarea.setSelectionRange(countOfCharacters, countOfCharacters);
      }
      if (onChange) {
        onChange(event);
      }
    };
    return /*#__PURE__*/(0, _jsxRuntime.jsxs)(React.Fragment, {
      children: [/*#__PURE__*/(0, _jsxRuntime.jsx)("textarea", {
        value: value,
        onChange: handleChange,
        ref: handleRef
        // Apply the rows prop to get a "correct" first SSR paint
        ,
        rows: minRows,
        style: style,
        ...other
      }), /*#__PURE__*/(0, _jsxRuntime.jsx)("textarea", {
        "aria-hidden": true,
        className: props.className,
        readOnly: true,
        ref: hiddenTextareaRef,
        tabIndex: -1,
        style: {
          ...styles.shadow,
          ...style,
          paddingTop: 0,
          paddingBottom: 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 TypeScript types and run `pnpm proptypes`. │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * @ignore
     */
    className: _propTypes.default.string,
    /**
     * Maximum number of rows to display.
     */
    maxRows: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.string]),
    /**
     * Minimum number of rows to display.
     * @default 1
     */
    minRows: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.string]),
    /**
     * @ignore
     */
    onChange: _propTypes.default.func,
    /**
     * @ignore
     */
    placeholder: _propTypes.default.string,
    /**
     * @ignore
     */
    style: _propTypes.default.object,
    /**
     * @ignore
     */
    value: _propTypes.default.oneOfType([_propTypes.default.arrayOf(_propTypes.default.string), _propTypes.default.number, _propTypes.default.string])
  } : void 0;
  var _default = exports.default = TextareaAutosize;