@hitachivantara/uikit-react-core 3.52.5

package/dist/TextArea/TextArea.js

@@ -0,0 +1,634 @@
+"use strict";
+
+require("core-js/modules/es.object.keys.js");
+
+require("core-js/modules/es.array.filter.js");
+
+require("core-js/modules/es.object.to-string.js");
+
+require("core-js/modules/es.object.get-own-property-descriptor.js");
+
+require("core-js/modules/web.dom-collections.for-each.js");
+
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+
+require("core-js/modules/es.array.iterator.js");
+
+require("core-js/modules/es.string.iterator.js");
+
+require("core-js/modules/es.weak-map.js");
+
+require("core-js/modules/web.dom-collections.iterator.js");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("core-js/modules/es.function.name.js");
+
+require("core-js/modules/es.symbol.js");
+
+require("core-js/modules/es.symbol.description.js");
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _isNil = _interopRequireDefault(require("lodash/isNil"));
+
+var _clsx = _interopRequireDefault(require("clsx"));
+
+var _core = require("@material-ui/core");
+
+var _utils = require("../utils");
+
+var _ = require("..");
+
+var _validationStates = _interopRequireWildcard(require("../Forms/FormElement/validationStates"));
+
+var _validations = require("../BaseInput/validations");
+
+var _styles = _interopRequireDefault(require("./styles"));
+
+var _excluded = ["classes", "className", "id", "name", "value", "defaultValue", "required", "readOnly", "disabled", "label", "aria-label", "aria-labelledby", "description", "aria-describedby", "onChange", "status", "statusMessage", "aria-errormessage", "placeholder", "autoFocus", "middleCountLabel", "rows", "resizable", "autoScroll", "hideCounter", "validationMessages", "maxCharQuantity", "minCharQuantity", "validation", "blockMax", "inputRef", "onBlur", "onFocus", "inputProps", "countCharProps"];
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+/**
+ * A text area is a multiline text input box, with an optional character counter when there is a length limit.
+ */
+var HvTextArea = function HvTextArea(props) {
+  var classes = props.classes,
+      className = props.className,
+      id = props.id,
+      name = props.name,
+      valueProp = props.value,
+      _props$defaultValue = props.defaultValue,
+      defaultValue = _props$defaultValue === void 0 ? "" : _props$defaultValue,
+      _props$required = props.required,
+      required = _props$required === void 0 ? false : _props$required,
+      _props$readOnly = props.readOnly,
+      readOnly = _props$readOnly === void 0 ? false : _props$readOnly,
+      _props$disabled = props.disabled,
+      disabled = _props$disabled === void 0 ? false : _props$disabled,
+      label = props.label,
+      ariaLabel = props["aria-label"],
+      ariaLabelledBy = props["aria-labelledby"],
+      description = props.description,
+      ariaDescribedBy = props["aria-describedby"],
+      onChange = props.onChange,
+      status = props.status,
+      statusMessage = props.statusMessage,
+      ariaErrorMessage = props["aria-errormessage"],
+      placeholder = props.placeholder,
+      _props$autoFocus = props.autoFocus,
+      autoFocus = _props$autoFocus === void 0 ? false : _props$autoFocus,
+      _props$middleCountLab = props.middleCountLabel,
+      middleCountLabel = _props$middleCountLab === void 0 ? "/" : _props$middleCountLab,
+      _props$rows = props.rows,
+      rows = _props$rows === void 0 ? 1 : _props$rows,
+      _props$resizable = props.resizable,
+      resizable = _props$resizable === void 0 ? false : _props$resizable,
+      _props$autoScroll = props.autoScroll,
+      autoScroll = _props$autoScroll === void 0 ? false : _props$autoScroll,
+      _props$hideCounter = props.hideCounter,
+      hideCounter = _props$hideCounter === void 0 ? false : _props$hideCounter,
+      validationMessages = props.validationMessages,
+      maxCharQuantity = props.maxCharQuantity,
+      minCharQuantity = props.minCharQuantity,
+      validation = props.validation,
+      _props$blockMax = props.blockMax,
+      blockMax = _props$blockMax === void 0 ? false : _props$blockMax,
+      inputRefProp = props.inputRef,
+      onBlur = props.onBlur,
+      onFocus = props.onFocus,
+      _props$inputProps = props.inputProps,
+      inputProps = _props$inputProps === void 0 ? {} : _props$inputProps,
+      _props$countCharProps = props.countCharProps,
+      countCharProps = _props$countCharProps === void 0 ? {} : _props$countCharProps,
+      others = (0, _objectWithoutProperties2.default)(props, _excluded);
+  var elementId = (0, _.useUniqueId)(id, "hvtextarea");
+  var inputRefOwn = (0, _react.useRef)(null);
+  var inputRef = inputRefProp || inputRefOwn;
+
+  var _React$useState = _react.default.useState(false),
+      _React$useState2 = (0, _slicedToArray2.default)(_React$useState, 2),
+      focused = _React$useState2[0],
+      setFocused = _React$useState2[1]; // signals that the user has manually edited the input value
+
+
+  var isDirty = (0, _react.useRef)(false); // value related state
+
+  var _useControlled = (0, _utils.useControlled)(valueProp, defaultValue),
+      _useControlled2 = (0, _slicedToArray2.default)(_useControlled, 2),
+      value = _useControlled2[0],
+      setValue = _useControlled2[1];
+
+  var isEmptyValue = value == null || value === ""; // validation related state
+
+  var _useControlled3 = (0, _utils.useControlled)(status, _validationStates.default.standBy),
+      _useControlled4 = (0, _slicedToArray2.default)(_useControlled3, 2),
+      validationState = _useControlled4[0],
+      setValidationState = _useControlled4[1];
+
+  var _useControlled5 = (0, _utils.useControlled)(statusMessage, ""),
+      _useControlled6 = (0, _slicedToArray2.default)(_useControlled5, 2),
+      validationMessage = _useControlled6[0],
+      setValidationMessage = _useControlled6[1]; // validationMessages reference tends to change, as users will not memoize/useState for it;
+  // dependencies must be more explicit so we set
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+
+
+  var errorMessages = (0, _react.useMemo)(function () {
+    return _objectSpread(_objectSpread({}, _validations.DEFAULT_ERROR_MESSAGES), validationMessages);
+  }, // eslint-disable-next-line react-hooks/exhaustive-deps
+  [validationMessages === null || validationMessages === void 0 ? void 0 : validationMessages.error, validationMessages === null || validationMessages === void 0 ? void 0 : validationMessages.requiredError, validationMessages === null || validationMessages === void 0 ? void 0 : validationMessages.minCharError, validationMessages === null || validationMessages === void 0 ? void 0 : validationMessages.maxCharError]);
+
+  var isOverflow = function isOverflow(currentValue) {
+    return (0, _isNil.default)(maxCharQuantity) ? false : currentValue.length > maxCharQuantity;
+  }; // validates the input, sets the status and the statusMessage accordingly (if uncontrolled)
+  // and returns the validity state of the input.
+
+
+  var performValidation = (0, _react.useCallback)(function () {
+    var inputValidity = (0, _validations.validateInput)(inputRef.current, value, required, minCharQuantity, maxCharQuantity, _validations.validationTypes.none, validation); // this will only run if status is uncontrolled
+
+    setValidationState((0, _validations.computeValidationState)(inputValidity, isEmptyValue)); // this will only run if statusMessage is uncontrolled
+
+    setValidationMessage((0, _validations.computeValidationMessage)(inputValidity, errorMessages));
+    return inputValidity;
+  }, [errorMessages, inputRef, isEmptyValue, maxCharQuantity, minCharQuantity, required, setValidationMessage, setValidationState, validation, value]);
+  /**
+   * Limit the string to the maxCharQuantity length.
+   *
+   * @param value - string to evaluate
+   * @returns {string|*} - string according the limit
+   */
+
+  var limitValue = function limitValue(currentValue) {
+    if (currentValue === undefined || !blockMax) return currentValue;
+    return !isOverflow(currentValue) ? currentValue : currentValue.substring(0, maxCharQuantity);
+  };
+
+  var _useState = (0, _react.useState)(autoScroll),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      autoScrolling = _useState2[0],
+      setAutoScrolling = _useState2[1];
+
+  var isScrolledDown = (0, _react.useCallback)(function () {
+    var el = inputRef.current;
+    return el == null || el.scrollHeight - el.scrollTop === el.clientHeight;
+  }, [inputRef]);
+  var scrollDown = (0, _react.useCallback)(function () {
+    var el = inputRef.current;
+
+    if (el != null) {
+      el.scrollTop = el.scrollHeight - el.clientHeight;
+    }
+  }, [inputRef]);
+  var addScrollListener = (0, _react.useCallback)(function () {
+    var scrollHandler = {
+      handleEvent: function handleEvent() {
+        setAutoScrolling(isScrolledDown());
+      }
+    };
+    inputRef.current.addEventListener("scroll", scrollHandler);
+  }, [inputRef, isScrolledDown]);
+  /**
+   * Validates the text area updating the state and modifying the warning text, also executes
+   * the user provided onBlur passing the current validation status and value.
+   *
+   * @returns {undefined}
+   */
+
+  var onContainerBlurHandler = function onContainerBlurHandler(event) {
+    setFocused(false);
+    var inputValidity = performValidation();
+    onBlur === null || onBlur === void 0 ? void 0 : onBlur(event, value, inputValidity);
+  };
+  /**
+   * Updates the state putting again the value from the state because the input value is
+   * not automatically manage, it also executes the onFocus function from the user passing the value
+   */
+
+
+  var onFocusHandler = function onFocusHandler(event) {
+    setFocused(true); // reset validation status to standBy (only when status is uncontrolled)
+
+    setValidationState(_validationStates.default.standBy);
+    onFocus === null || onFocus === void 0 ? void 0 : onFocus(event, value);
+  };
+  /**
+   * Updates the length of the string while is being inputted, also executes the user onChange
+   * allowing the customization of the input if required.
+   *
+   * @param {String} value - The value provided by the HvInput
+   */
+
+
+  var onChangeHandler = function onChangeHandler(event, currentValue) {
+    isDirty.current = true;
+    var limitedValue = blockMax ? limitValue(currentValue) : currentValue; // set the input value (only when value is uncontrolled)
+
+    setValue(limitedValue);
+    onChange === null || onChange === void 0 ? void 0 : onChange(event, limitedValue);
+  };
+
+  (0, _react.useEffect)(function () {
+    if (autoScroll) {
+      addScrollListener();
+      scrollDown();
+    }
+
+    if (autoScrolling) {
+      scrollDown();
+    }
+  }, [addScrollListener, autoScroll, autoScrolling, scrollDown]); // run initial validation after first render
+  // and also when any validation condition changes
+
+  (0, _react.useEffect)(function () {
+    if (focused || !isDirty.current && isEmptyValue) {
+      // skip validation if currently focused or if empty and
+      // the user never manually edited the input value
+      return;
+    }
+
+    performValidation();
+  }, [focused, isEmptyValue, performValidation]);
+  var hasLabel = label != null;
+  var hasDescription = description != null;
+  var hasCounter = maxCharQuantity != null && !hideCounter; // the error message area will only be created if:
+  // - an external element that provides an error message isn't identified via aria-errormessage AND
+  //   - both status and statusMessage properties are being controlled OR
+  //   - status is uncontrolled and any of the built-in validations are active
+
+  var canShowError = ariaErrorMessage == null && (status !== undefined && statusMessage !== undefined || status === undefined && (0, _validations.hasBuiltInValidations)(required, _validations.validationTypes.none, minCharQuantity, // if blockMax is true maxCharQuantity will never produce an error
+  // unless the value is controlled, so we can't prevent it to overflow maxCharQuantity
+  maxCharQuantity != null && (blockMax !== true || value != null) ? maxCharQuantity : null, validation, inputProps));
+  var isStateInvalid = (0, _validationStates.isInvalid)(validationState);
+  var errorMessageId;
+
+  if (isStateInvalid) {
+    errorMessageId = canShowError ? (0, _utils.setId)(elementId, "error") : ariaErrorMessage;
+  }
+
+  return /*#__PURE__*/_react.default.createElement(_.HvFormElement, {
+    id: id,
+    name: name,
+    status: validationState,
+    disabled: disabled,
+    required: required,
+    readOnly: readOnly,
+    className: (0, _clsx.default)(classes.root, className, resizable && classes.resizable, disabled && classes.disabled, isStateInvalid && classes.invalid),
+    onBlur: onContainerBlurHandler
+  }, (hasLabel || hasDescription) && /*#__PURE__*/_react.default.createElement("div", {
+    className: classes.labelContainer
+  }, hasLabel && /*#__PURE__*/_react.default.createElement(_.HvLabel, {
+    className: classes.label,
+    id: (0, _utils.setId)(id, "label"),
+    htmlFor: (0, _utils.setId)(elementId, "input"),
+    label: label
+  }), hasDescription && /*#__PURE__*/_react.default.createElement(_.HvInfoMessage, {
+    className: classes.description,
+    id: (0, _utils.setId)(elementId, "description")
+  }, description)), hasCounter && /*#__PURE__*/_react.default.createElement(_.HvCharCounter, (0, _extends2.default)({
+    id: (0, _utils.setId)(elementId, "charCounter"),
+    className: classes.characterCounter,
+    separator: middleCountLabel,
+    currentCharQuantity: value.length,
+    maxCharQuantity: maxCharQuantity
+  }, countCharProps)), /*#__PURE__*/_react.default.createElement(_.HvBaseInput, (0, _extends2.default)({
+    classes: {
+      root: classes.baseInput,
+      input: classes.input,
+      inputResizable: classes.inputResizable
+    },
+    id: hasLabel ? (0, _utils.setId)(elementId, "input") : (0, _utils.setId)(id, "input"),
+    name: name,
+    value: value,
+    required: required,
+    readOnly: readOnly,
+    disabled: disabled,
+    onChange: onChangeHandler,
+    autoFocus: autoFocus,
+    onFocus: onFocusHandler,
+    placeholder: placeholder,
+    invalid: isStateInvalid,
+    resizable: resizable,
+    multiline: true,
+    rows: rows,
+    inputProps: _objectSpread({
+      "aria-label": ariaLabel,
+      "aria-labelledby": ariaLabelledBy,
+      "aria-invalid": isStateInvalid ? true : undefined,
+      "aria-errormessage": errorMessageId,
+      "aria-describedby": ariaDescribedBy != null ? ariaDescribedBy : description && (0, _utils.setId)(elementId, "description"),
+      "aria-controls": maxCharQuantity ? (0, _utils.setId)(elementId, "charCounter") : undefined
+    }, inputProps),
+    inputRef: inputRef
+  }, others)), canShowError && /*#__PURE__*/_react.default.createElement(_.HvWarningText, {
+    id: (0, _utils.setId)(elementId, "error"),
+    className: classes.error,
+    disableBorder: true
+  }, validationMessage));
+};
+
+HvTextArea.propTypes = {
+  /**
+   * Class names to be applied.
+   */
+  className: _propTypes.default.string,
+
+  /**
+   * A Jss Object used to override or extend the component styles applied.
+   */
+  classes: _propTypes.default.PropTypes.shape({
+    /**
+     * Styles applied to the root container of the textarea.
+     */
+    root: _propTypes.default.string,
+
+    /**
+     * Style applied to the root when resizable is `true`.
+     */
+    disabled: _propTypes.default.string,
+
+    /**
+     * Style applied to the root when resizable is `true`.
+     */
+    resizable: _propTypes.default.string,
+
+    /**
+     * Style applied to the root when resizable is `true`.
+     */
+    invalid: _propTypes.default.string,
+
+    /**
+     * Styles applied to the base input root which is comprising of everything but the labels and descriptions.
+     */
+    baseInput: _propTypes.default.string,
+
+    /**
+     * Style applied on the text area element.
+     */
+    input: _propTypes.default.string,
+
+    /**
+     * Styles applied to text area element element when it is resizable. Can be used to set max/min width.
+     */
+    inputResizable: _propTypes.default.string,
+
+    /**
+     * Styles applied to text area container that holds the label, description and counter.
+     */
+    labelContainer: _propTypes.default.string,
+
+    /**
+     * Styles applied to the label element.
+     */
+    label: _propTypes.default.string,
+
+    /**
+     * Styles applied to the label element.
+     */
+    description: _propTypes.default.string,
+
+    /**
+     * Style applied on the character counter.
+     */
+    characterCounter: _propTypes.default.string,
+
+    /**
+     * Styles applied to the error area.
+     */
+    error: _propTypes.default.string
+  }).isRequired,
+
+  /**
+   * Id to be applied to the form element root node.
+   */
+  id: _propTypes.default.string,
+
+  /**
+   * The form element name.
+   */
+  name: _propTypes.default.string,
+
+  /**
+   * The value of the form element.
+   */
+  value: _propTypes.default.string,
+
+  /**
+   * When uncontrolled, defines the initial input value.
+   */
+  defaultValue: _propTypes.default.string,
+
+  /**
+   * The label of the form element.
+   *
+   * The form element must be labeled for accessibility reasons.
+   * If not provided, an aria-label or aria-labelledby must be inputted via inputProps.
+   */
+  label: _propTypes.default.node,
+
+  /**
+   * @ignore
+   */
+  "aria-label": _propTypes.default.string,
+
+  /**
+   * @ignore
+   */
+  "aria-labelledby": _propTypes.default.string,
+
+  /**
+   * Provide additional descriptive text for the form element.
+   */
+  description: _propTypes.default.node,
+
+  /**
+   * @ignore
+   */
+  "aria-describedby": _propTypes.default.string,
+
+  /**
+   * Indicates that the form element is disabled.
+   */
+  disabled: _propTypes.default.bool,
+
+  /**
+   * Indicates that the form element is not editable.
+   */
+  readOnly: _propTypes.default.bool,
+
+  /**
+   * Indicates that user input is required on the form element.
+   */
+  required: _propTypes.default.bool,
+
+  /**
+   * The status of the form element.
+   *
+   * Valid is correct, invalid is incorrect and standBy means no validations have run.
+   *
+   * When uncontrolled and unspecified it will default to "standBy" and change to either "valid"
+   * or "invalid" after any change to `checked`, depending of the values of both `required` and `checked`.
+   */
+  status: _propTypes.default.oneOf(["standBy", "valid", "invalid"]),
+
+  /**
+   * The error message to show when `status` is "invalid".
+   */
+  statusMessage: _propTypes.default.string,
+
+  /**
+   * Identifies the element that provides an error message for the textarea.
+   *
+   * Will only be used when the validation status is invalid.
+   */
+  "aria-errormessage": _propTypes.default.string,
+
+  /**
+   * The function that will be executed onChange.
+   */
+  onChange: _propTypes.default.func,
+
+  /**
+   * The placeholder value of the input.
+   */
+  placeholder: _propTypes.default.string,
+
+  /**
+   * Text between the current char counter and max value.
+   */
+  middleCountLabel: _propTypes.default.string,
+
+  /**
+   * An Object containing the various texts associated with the input.
+   */
+  validationMessages: _propTypes.default.shape({
+    /**
+     * The value when a validation fails.
+     */
+    error: _propTypes.default.string,
+
+    /**
+     * The message that appears when there are too many characters.
+     */
+    maxCharError: _propTypes.default.string,
+
+    /**
+     * The message that appears when there are too few characters.
+     */
+    minCharError: _propTypes.default.string,
+
+    /**
+     * The message that appears when the input is empty and required.
+     */
+    requiredError: _propTypes.default.string
+  }),
+
+  /**
+   * Attributes applied to the input element.
+   */
+  inputProps: _propTypes.default.instanceOf(Object),
+
+  /**
+   * Allows passing a ref to the underlying input
+   */
+  inputRef: _utils.refType,
+
+  /**
+   * The function that will be executed onBlur, allows checking the validation state,
+   * it receives the value and the validation state (`invalid`, `valid`).
+   */
+  onBlur: _propTypes.default.func,
+
+  /**
+   * The function that will be executed onBlur, allows checking the value state,
+   * it receives the value.
+   */
+  onFocus: _propTypes.default.func,
+
+  /**
+   * The custom validation function, it receives the value and must return
+   * either `true` for valid or `false` for invalid, default validations would only
+   * occur if this function is null or undefined
+   */
+  validation: _propTypes.default.func,
+
+  /**
+   * If `true` it should autofocus.
+   */
+  autoFocus: _propTypes.default.bool,
+
+  /**
+   * The maximum allowed length of the characters, if this value is null no check
+   * will be performed.
+   */
+  maxCharQuantity: _propTypes.default.number,
+
+  /**
+   * The minimum allowed length of the characters, if this value is null no check
+   * will be perform.
+   */
+  minCharQuantity: _propTypes.default.number,
+
+  /**
+   * The number of rows of the text area
+   */
+  rows: _propTypes.default.number,
+
+  /**
+   * If `true` the component is resizable.
+   */
+  resizable: _propTypes.default.bool,
+
+  /**
+   * Auto-scroll: automatically scroll to the end on value changes.
+   * Will stop if the user scrolls up and resume if scrolled to the bottom.
+   */
+  autoScroll: _propTypes.default.bool,
+
+  /**
+   * If `true` it isn't possible to have more characters than the `maxCharQuantity`
+   */
+  blockMax: _propTypes.default.bool,
+
+  /**
+   * If `true` the character counter isn't shown even if maxCharQuantity is set.
+   */
+  hideCounter: _propTypes.default.bool,
+
+  /**
+   * Props passed to the HvCharCount component.
+   */
+  countCharProps: _propTypes.default.instanceOf(Object)
+};
+
+var _default = (0, _core.withStyles)(_styles.default, {
+  name: "HvTextArea"
+})(HvTextArea);
+
+exports.default = _default;
+//# sourceMappingURL=TextArea.js.map