intergalactic 15.122.0-prerelease.0 → 15.123.0

package/bulk-textarea/BulkTextarea.d.ts

@@ -0,0 +1,3 @@
+import { BulkTextareaType } from './BulkTextarea.types';
+declare const BulkTextarea: BulkTextareaType;
+export default BulkTextarea;

package/bulk-textarea/BulkTextarea.types.d.ts

@@ -0,0 +1,33 @@
+import { Intergalactic } from 'intergalactic/utils/lib/core';
+import { BoxProps } from 'intergalactic/flex-box';
+import Button from 'intergalactic/button';
+import { InputFieldProps } from './components/InputField/InputField';
+import { CounterProps } from './components/Counter';
+import { ErrorsNavigationProps } from './components/ErrorsNavigation';
+export type BulkTextareaProps = {
+    value?: InputFieldProps['value'];
+    onChange?: InputFieldProps['onBlur'];
+    placeholder?: InputFieldProps['placeholder'];
+    size?: InputFieldProps['size'];
+    state?: InputFieldProps['state'];
+    disabled?: InputFieldProps['disabled'];
+    readonly?: InputFieldProps['readonly'];
+    minRows?: InputFieldProps['minRows'];
+    maxRows?: InputFieldProps['maxRows'];
+    validateOn?: InputFieldProps['validateOn'];
+    lineValidation?: InputFieldProps['lineValidation'];
+    linesDelimiters?: InputFieldProps['linesDelimiters'];
+    pasteProps?: InputFieldProps['pasteProps'];
+    maxLines?: InputFieldProps['maxLines'];
+    lineProcessing?: InputFieldProps['lineProcessing'];
+    errors?: InputFieldProps['errors'];
+    showErrors?: boolean;
+    onErrorsChange?: InputFieldProps['onErrorsChange'];
+    onShowErrorsChange?: InputFieldProps['onShowErrorsChange'];
+};
+export type BulkTextareaType = Intergalactic.Component<'div', BoxProps & BulkTextareaProps> & {
+    InputField: Intergalactic.Component<'div', Pick<InputFieldProps, 'commonErrorMessage' | 'id'> & Partial<BulkTextareaProps>>;
+    Counter: Intergalactic.Component<'div', Partial<CounterProps>>;
+    ClearAll: typeof Button;
+    ErrorsNavigation: Intergalactic.Component<'div', Partial<ErrorsNavigationProps>>;
+};

package/bulk-textarea/components/ClearAll.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { IRootComponentProps } from 'intergalactic/core';
+import { useI18n } from 'intergalactic/utils/lib/enhances/WithI18n';
+export declare function ClearAll(props: IRootComponentProps & {
+    isHidden: boolean;
+    getI18nText: ReturnType<typeof useI18n>;
+}): React.ReactNode;

package/bulk-textarea/components/Counter.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { CounterProps as CounterPropsKit } from 'intergalactic/counter';
+import { useI18n } from 'intergalactic/utils/lib/enhances/WithI18n';
+export type CounterProps = {
+    theme: CounterPropsKit['theme'];
+    linesCount: number;
+    maxLines: number;
+    getI18nText: ReturnType<typeof useI18n>;
+};
+export declare function Counter(props: CounterProps): JSX.Element;

package/bulk-textarea/components/ErrorsNavigation.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { useI18n } from 'intergalactic/utils/lib/enhances/WithI18n';
+export type ErrorsNavigationProps = {
+    errorIndex: number;
+    onPrevError: () => void;
+    onNextError: () => void;
+    errorsCount: number;
+    size: 'm' | 'l';
+    showErrors: boolean;
+    getI18nText: ReturnType<typeof useI18n>;
+    disabled: boolean;
+    nextButtonRef: React.RefObject<HTMLButtonElement>;
+    prevButtonRef: React.RefObject<HTMLButtonElement>;
+};
+export declare function ErrorsNavigation(props: ErrorsNavigationProps): JSX.Element;

package/bulk-textarea/components/InputField/InputField.d.ts

@@ -0,0 +1,98 @@
+import React from 'react';
+import { Component } from 'intergalactic/core';
+import { PopperContext } from 'intergalactic/popper';
+import { InputFieldProps, ErrorItem } from './InputField.types';
+type IndexKeys = 'keyboardLineIndex' | 'mouseLineIndex';
+type State = {
+    [key in IndexKeys]: number;
+} & {
+    visibleErrorPopper: boolean;
+};
+declare class InputField extends Component<InputFieldProps, {}, State, typeof InputField.enhance> {
+    static displayName: string;
+    static style: {
+        [key: string]: string;
+    };
+    static enhance: readonly [(props: any) => {
+        uid: string;
+    }];
+    static defaultProps: {
+        defaultValue: string;
+        size: string;
+        state: string;
+        minRows: number;
+        maxRows: number;
+        defaultShowErrors: boolean;
+        defaultErrorIndex: number;
+        defaultLinesCount: number;
+    };
+    delimiter: string;
+    skipEmptyLines: boolean;
+    emptyLineValue: string;
+    spaceLineValue: string;
+    containerRef: React.RefObject<HTMLDivElement>;
+    textarea: HTMLDivElement;
+    popper: PopperContext['popper'] | null;
+    setPopperTrigger: PopperContext['setTrigger'] | null;
+    errorByInteraction: 'keyboard' | 'mouse' | null;
+    changeTriggerTimeout: number;
+    isScrolling: boolean;
+    scrollingTimeout: number;
+    toggleErrorsPopperTimeout: number;
+    isFocusing: boolean;
+    linesCountTimeout: number;
+    state: {
+        visibleErrorPopper: boolean;
+        keyboardLineIndex: number;
+        mouseLineIndex: number;
+    };
+    constructor(props: InputFieldProps);
+    uncontrolledProps(): {
+        value: null;
+        linesCount: null;
+        errorIndex: null;
+    };
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: InputFieldProps, prevState: State): void;
+    componentWillUnmount(): void;
+    get isDisabled(): boolean;
+    get popperDescribedId(): string;
+    get errorMessage(): {
+        errorMessage: string | null;
+        isCommonError: boolean;
+    };
+    createContentEditableElement(props: InputFieldProps): HTMLDivElement;
+    handleValueOutChange(): void;
+    handleScroll(): void;
+    handleMouseDown(event: MouseEvent): void;
+    handleMouseMove(event: MouseEvent): void;
+    handleMouseLeave(event: MouseEvent): void;
+    handlePaste(event: ClipboardEvent): void;
+    handleChange(event: Event): void;
+    handleFocus(event: FocusEvent): void;
+    handleBlur(event: Event): void;
+    handleKeyDown(event: KeyboardEvent): void;
+    render(): React.ReactNode;
+    private prepareNodesForPaste;
+    private recalculateErrors;
+    private recalculateLinesCount;
+    private getValues;
+    private toggleErrorsPopperByKeyboard;
+    private toggleErrorsPopper;
+    private toggleAriaInvalid;
+    private handleChangeErrorIndex;
+    private validateLine;
+    private setSelection;
+    private getNodeFromSelection;
+    private handleCursorMovement;
+    private setErrorIndex;
+    private isDeleteKey;
+    private getEmptyParagraph;
+    private addEventListeners;
+    private removeEventListeners;
+    private handleSelectAll;
+    private isRangeSelection;
+    private getSelectionDirection;
+}
+export { InputField };
+export type { InputFieldProps, ErrorItem };

package/bulk-textarea/components/InputField/InputField.types.d.ts

@@ -0,0 +1,157 @@
+type PasteProps = {
+    /**
+     * @default '\n'
+     */
+    delimiter?: string;
+    /**
+     * @default row.trim();
+     */
+    lineProcessing?: (line: string) => string;
+    /**
+     * @default true
+     */
+    skipEmptyLines?: boolean;
+};
+export type ErrorItem = {
+    lineIndex: number;
+    lineNode?: Node;
+    errorMessage: string;
+};
+export type InputFieldProps = {
+    /**
+     * Unique id
+     */
+    id?: string;
+    /**
+     * Placeholder for field
+     */
+    placeholder?: string;
+    /**
+     * String to render in textarea. OnChanging value, it will go throw paste pipeline
+     */
+    value: string;
+    /**
+     * This component doesn't have default onChange callback, because we think that you need only the result after every changes/fixes
+     */
+    onBlur: (value: string, e: Event) => void;
+    /**
+     * Size of component
+     * @default m
+     */
+    size: 'm' | 'l';
+    /**
+     * State for show errors or valid(green) borders
+     * @default normal
+     */
+    state: 'normal' | 'valid' | 'invalid';
+    /**
+     * Flag for disabling field
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Flag for readonly field
+     * @default false
+     */
+    readonly?: boolean;
+    /**
+     * Min rows
+     * @default 2
+     */
+    minRows: number;
+    /**
+     * Max rows
+     * @default 10
+     */
+    maxRows: number;
+    /**
+     * List of available points to validate value
+     * @default blur
+     */
+    validateOn: ('blur' | 'blurLine' | 'paste')[];
+    /**
+     * Function to validate line
+     */
+    lineValidation?: (line: string, lines: string[]) => {
+        isValid: boolean;
+        errorMessage: string;
+    };
+    /**
+     * Message for display error about whole field, not only one line
+     */
+    commonErrorMessage: string;
+    /**
+     * Delimiters (event.key) for lines
+     * @default Enter
+     */
+    linesDelimiters?: string[];
+    /**
+     * Count of max lines in badge
+     * @default 100
+     */
+    maxLines: number;
+    /**
+     * Paste props
+     */
+    pasteProps: PasteProps;
+    /**
+     * Function for process line after it was blurred
+     */
+    lineProcessing?: (line: string, lines: string[]) => string;
+    /**
+     * Internal
+     */
+    lastError: ErrorItem;
+    /**
+     * Internal
+     */
+    currentLineIndex: number;
+    /**
+     * Internal
+     */
+    linesCount: number;
+    /**
+     * Internal
+     */
+    onChangeLineIndex: (newIndex: number) => void;
+    /**
+     * Internal
+     */
+    onChangeLinesCount: (rowsCount: number) => void;
+    /**
+     * Internal
+     */
+    showErrors: boolean;
+    /**
+     * Internal
+     * List of errors in rows
+     */
+    errors: ErrorItem[];
+    /**
+     * Internal
+     * Select row with error
+     */
+    errorIndex: number;
+    /**
+     * Internal
+     * Flag for select all row
+     */
+    highlightErrorIndex: boolean;
+    /**
+     * Internal
+     */
+    onErrorsChange: (errors: ErrorItem[]) => void;
+    /**
+     * Internal
+     */
+    onShowErrorsChange: (showErrors: boolean) => void;
+    /**
+     * Internal
+     */
+    onErrorIndexChange: (errorIndex: number) => void;
+    /**
+     * Internal
+     */
+    'aria-describedby'?: string;
+};
+export {};

package/bulk-textarea/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from './BulkTextarea';
+export type { BulkTextareaProps } from './BulkTextarea.types';
+export type { ErrorItem } from './components/InputField/InputField.types';

package/bulk-textarea/index.js

@@ -0,0 +1,8 @@
+"use strict";
+
+module.exports.__esModule = true;
+var item = require("./lib/cjs/index");
+module.exports = item['default'] || {};
+Object.keys(item).forEach(function (key) {
+  module.exports[key] = item[key];
+});

package/bulk-textarea/index.mjs

@@ -0,0 +1,2 @@
+export * from './lib/es6/index.mjs';
+export { default } from './lib/es6/index.mjs';

package/bulk-textarea/lib/cjs/BulkTextarea.js

@@ -0,0 +1,318 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createClass"));
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/assertThisInitialized"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/inherits"));
+var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createSuper"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/defineProperty"));
+var _core = _interopRequireWildcard(require("intergalactic/core"));
+var _react = _interopRequireDefault(require("react"));
+var _flexBox = require("intergalactic/flex-box");
+var _InputField = require("./components/InputField/InputField");
+var _Counter = require("./components/Counter");
+var _ClearAll = require("./components/ClearAll");
+var _ErrorsNavigation = require("./components/ErrorsNavigation");
+var _intergalacticDynamicLocales = require("./translations/__intergalactic-dynamic-locales");
+var _i18nEnhance = _interopRequireDefault(require("intergalactic/utils/lib/enhances/i18nEnhance"));
+var _focusSourceEnhance = _interopRequireDefault(require("intergalactic/utils/lib/enhances/focusSourceEnhance"));
+var _uniqueID = _interopRequireDefault(require("intergalactic/utils/lib/uniqueID"));
+var BulkTextareaRoot = /*#__PURE__*/function (_Component) {
+  (0, _inherits2["default"])(BulkTextareaRoot, _Component);
+  var _super = (0, _createSuper2["default"])(BulkTextareaRoot);
+  function BulkTextareaRoot() {
+    var _this;
+    (0, _classCallCheck2["default"])(this, BulkTextareaRoot);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "inputFieldRef", /*#__PURE__*/_react["default"].createRef());
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "clearAllButtonRef", /*#__PURE__*/_react["default"].createRef());
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "nextButtonRef", /*#__PURE__*/_react["default"].createRef());
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "prevButtonRef", /*#__PURE__*/_react["default"].createRef());
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "counterRef", /*#__PURE__*/_react["default"].createRef());
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "state", {
+      linesCount: 0,
+      isEmptyText: true,
+      errorIndex: -1,
+      highlightErrorIndex: false
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleChangeLinesCount", function (linesCount) {
+      var isEmpty = !linesCount;
+      _this.setState({
+        linesCount: linesCount,
+        isEmptyText: isEmpty
+      });
+      if (isEmpty) {
+        _this.handlers.showErrors(false);
+        _this.handlers.errors([]);
+        _this.handlers.state('normal');
+      }
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleClickClearAll", function (e) {
+      var _this$inputFieldRef$c;
+      _this.handlers.showErrors(false);
+      _this.handlers.errors([]);
+      _this.setState({
+        errorIndex: -1
+      });
+      _this.handlers.value('', e);
+      _this.handlers.state('normal');
+      var textarea = (_this$inputFieldRef$c = _this.inputFieldRef.current) === null || _this$inputFieldRef$c === void 0 ? void 0 : _this$inputFieldRef$c.querySelector('[role="textbox"]');
+      textarea instanceof HTMLDivElement && textarea.focus();
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleChangeErrorIndex", function (amount) {
+      return function () {
+        var _this$asProps$errors = _this.asProps.errors,
+          errors = _this$asProps$errors === void 0 ? [] : _this$asProps$errors;
+        var errorIndex = _this.state.errorIndex;
+        var itemsIndex = errors.length - 1;
+        var newIndex = errorIndex + amount;
+        if (newIndex < 0) {
+          newIndex = amount + itemsIndex + 1;
+        } else if (newIndex > itemsIndex) {
+          newIndex = newIndex - itemsIndex - 1;
+        }
+        if (!errors[newIndex]) {
+          _this.handleChangeErrorIndex(amount < 0 ? amount - 1 : amount + 1)();
+        } else {
+          _this.handlers.showErrors(false);
+          _this.setState({
+            errorIndex: -1
+          });
+          setTimeout(function () {
+            _this.handlers.showErrors(true);
+            _this.setState({
+              errorIndex: newIndex,
+              highlightErrorIndex: true
+            });
+          });
+        }
+      };
+    });
+    return _this;
+  }
+  (0, _createClass2["default"])(BulkTextareaRoot, [{
+    key: "uncontrolledProps",
+    value: function uncontrolledProps() {
+      return {
+        value: null,
+        state: null,
+        showErrors: null,
+        errors: null
+      };
+    }
+  }, {
+    key: "counterId",
+    get: function get() {
+      return "".concat(this.asProps.uid, "_counter");
+    }
+  }, {
+    key: "getInputFieldProps",
+    value: function getInputFieldProps() {
+      var _this2 = this;
+      var _this$asProps = this.asProps,
+        value = _this$asProps.value,
+        size = _this$asProps.size,
+        minRows = _this$asProps.minRows,
+        maxRows = _this$asProps.maxRows,
+        lineValidation = _this$asProps.lineValidation,
+        placeholder = _this$asProps.placeholder,
+        validateOn = _this$asProps.validateOn,
+        onChange = _this$asProps.onChange,
+        linesDelimiters = _this$asProps.linesDelimiters,
+        maxLines = _this$asProps.maxLines,
+        disabled = _this$asProps.disabled,
+        readonly = _this$asProps.readonly,
+        pasteProps = _this$asProps.pasteProps,
+        lineProcessing = _this$asProps.lineProcessing,
+        _this$asProps$errors2 = _this$asProps.errors,
+        errors = _this$asProps$errors2 === void 0 ? [] : _this$asProps$errors2,
+        showErrors = _this$asProps.showErrors;
+      var _this$state = this.state,
+        errorIndex = _this$state.errorIndex,
+        lastError = _this$state.lastError,
+        linesCount = _this$state.linesCount,
+        highlightErrorIndex = _this$state.highlightErrorIndex;
+      return (0, _defineProperty2["default"])({
+        value: value,
+        size: size,
+        state: showErrors && (errors === null || errors === void 0 ? void 0 : errors.length) > 0 ? 'invalid' : 'normal',
+        disabled: disabled,
+        readonly: readonly,
+        minRows: minRows,
+        maxRows: maxRows,
+        maxLines: maxLines,
+        placeholder: placeholder,
+        lastError: lastError,
+        pasteProps: pasteProps,
+        linesCount: linesCount,
+        lineProcessing: lineProcessing,
+        onChangeLinesCount: this.handleChangeLinesCount,
+        onChangeLineIndex: function onChangeLineIndex() {
+          if (validateOn !== null && validateOn !== void 0 && validateOn.includes('blurLine')) {
+            _this2.handlers.showErrors(true);
+          }
+        },
+        onBlur: function onBlur(value, event) {
+          if (validateOn !== null && validateOn !== void 0 && validateOn.includes('blur') && (_this2.asProps.focusSourceRef.current === 'keyboard' || event instanceof FocusEvent && event.relatedTarget !== _this2.clearAllButtonRef.current)) {
+            _this2.handlers.showErrors(true);
+          }
+          if (_this2.asProps.showErrors === false && (validateOn !== null && validateOn !== void 0 && validateOn.includes('blur') || validateOn !== null && validateOn !== void 0 && validateOn.includes('blurLine'))) {
+            setTimeout(function () {
+              var _this2$nextButtonRef$;
+              (_this2$nextButtonRef$ = _this2.nextButtonRef.current) === null || _this2$nextButtonRef$ === void 0 ? void 0 : _this2$nextButtonRef$.focus();
+            }, 250);
+          }
+          onChange === null || onChange === void 0 ? void 0 : onChange(value, event);
+        },
+        showErrors: showErrors,
+        validateOn: validateOn,
+        lineValidation: lineValidation,
+        errors: errors,
+        onErrorsChange: function onErrorsChange(newErrors) {
+          var lastError = newErrors.length === 0 ? errors[0] : undefined;
+          _this2.handlers.errors(newErrors);
+          _this2.setState({
+            lastError: lastError
+          });
+          setTimeout(function () {
+            var _this2$asProps = _this2.asProps,
+              showErrors = _this2$asProps.showErrors,
+              errors = _this2$asProps.errors;
+            if (showErrors) {
+              var newState = newErrors.length === 0 ? 'normal' : 'invalid';
+              _this2.handlers.state(newState);
+            }
+            if ((errors === null || errors === void 0 ? void 0 : errors.length) === 0) {
+              _this2.handlers.showErrors(false);
+              setTimeout(function () {
+                _this2.setState({
+                  lastError: undefined
+                });
+              }, 150);
+            }
+          }, 10); // this timeout to be sure that code will be after state change
+        },
+
+        highlightErrorIndex: highlightErrorIndex,
+        errorIndex: errorIndex,
+        onErrorIndexChange: function onErrorIndexChange(errorIndex) {
+          _this2.setState({
+            errorIndex: errorIndex,
+            highlightErrorIndex: false
+          });
+        },
+        linesDelimiters: linesDelimiters,
+        ref: this.inputFieldRef
+      }, 'aria-describedby', this.counterId);
+    }
+  }, {
+    key: "getCounterProps",
+    value: function getCounterProps() {
+      var _this$asProps2 = this.asProps,
+        maxLines = _this$asProps2.maxLines,
+        getI18nText = _this$asProps2.getI18nText,
+        size = _this$asProps2.size;
+      var _this$state2 = this.state,
+        linesCount = _this$state2.linesCount,
+        isEmptyText = _this$state2.isEmptyText;
+      var counterTheme = '';
+      if (linesCount === maxLines) {
+        counterTheme = 'warning';
+      } else if (linesCount > maxLines) {
+        counterTheme = 'danger';
+      }
+      return {
+        id: this.counterId,
+        ref: this.counterRef,
+        getI18nText: getI18nText,
+        theme: counterTheme,
+        linesCount: isEmptyText ? 0 : linesCount,
+        maxLines: maxLines,
+        size: size
+      };
+    }
+  }, {
+    key: "getClearAllProps",
+    value: function getClearAllProps() {
+      var _this$asProps3 = this.asProps,
+        size = _this$asProps3.size,
+        getI18nText = _this$asProps3.getI18nText,
+        disabled = _this$asProps3.disabled,
+        readonly = _this$asProps3.readonly;
+      return {
+        onClick: this.handleClickClearAll,
+        isHidden: this.state.isEmptyText,
+        size: size,
+        getI18nText: getI18nText,
+        ref: this.clearAllButtonRef,
+        disabled: disabled || readonly
+      };
+    }
+  }, {
+    key: "getErrorsNavigationProps",
+    value: function getErrorsNavigationProps() {
+      var _this$asProps4 = this.asProps,
+        size = _this$asProps4.size,
+        getI18nText = _this$asProps4.getI18nText,
+        disabled = _this$asProps4.disabled,
+        readonly = _this$asProps4.readonly,
+        _this$asProps4$errors = _this$asProps4.errors,
+        errors = _this$asProps4$errors === void 0 ? [] : _this$asProps4$errors,
+        showErrors = _this$asProps4.showErrors;
+      var errorIndex = this.state.errorIndex;
+      return {
+        size: size,
+        getI18nText: getI18nText,
+        errorIndex: errorIndex,
+        onPrevError: this.handleChangeErrorIndex(-1),
+        onNextError: this.handleChangeErrorIndex(1),
+        errorsCount: errors.map(Boolean).length,
+        showErrors: showErrors,
+        disabled: disabled || readonly || false,
+        nextButtonRef: this.nextButtonRef,
+        prevButtonRef: this.prevButtonRef
+      };
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _ref = this.asProps;
+      return /*#__PURE__*/_react["default"].createElement(_flexBox.Box, (0, _core.assignProps)({
+        "__excludeProps": ['onBlur', 'value', 'placeholder']
+      }, _ref));
+    }
+  }]);
+  return BulkTextareaRoot;
+}(_core.Component);
+(0, _defineProperty2["default"])(BulkTextareaRoot, "displayName", 'BulkTextarea');
+(0, _defineProperty2["default"])(BulkTextareaRoot, "defaultProps", {
+  defaultValue: '',
+  size: 'm',
+  defaultState: 'normal',
+  minRows: 2,
+  maxRows: 10,
+  maxLines: 100,
+  validateOn: 'blur',
+  locale: 'en',
+  defaultErrors: [],
+  defaultShowErrors: false
+});
+(0, _defineProperty2["default"])(BulkTextareaRoot, "enhance", [(0, _i18nEnhance["default"])(_intergalacticDynamicLocales.localizedMessages), (0, _focusSourceEnhance["default"])(), (0, _uniqueID["default"])()]);
+var BulkTextarea = (0, _core["default"])(BulkTextareaRoot, {
+  InputField: _InputField.InputField,
+  Counter: _Counter.Counter,
+  ClearAll: _ClearAll.ClearAll,
+  ErrorsNavigation: _ErrorsNavigation.ErrorsNavigation
+});
+var _default = BulkTextarea;
+exports["default"] = _default;
+//# sourceMappingURL=BulkTextarea.js.map