"use strict";

Liferay.Loader.define("@frontend-taglib-clay$clayui/autocomplete@3.58.0/lib/index", ['module', 'exports', 'require', '@frontend-taglib-clay$clayui/form', 'frontend-js-react-web$react', './Context', './DropDown', './Input', './Item', './LoadingIndicator'], function (module, exports, require) {
  var define = undefined;
  var global = window;
  {
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = void 0;

    var _form = require("@frontend-taglib-clay$clayui/form");

    var _react = _interopRequireDefault(require("frontend-js-react-web$react"));

    var _Context = _interopRequireDefault(require("./Context"));

    var _DropDown = _interopRequireDefault(require("./DropDown"));

    var _Input = _interopRequireDefault(require("./Input"));

    var _Item = _interopRequireDefault(require("./Item"));

    var _LoadingIndicator = _interopRequireDefault(require("./LoadingIndicator"));

    var _excluded = ["children"],
        _excluded2 = ["children", "className", "component"];

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }

    function _slicedToArray(arr, i) {
      return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
    }

    function _nonIterableRest() {
      throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
    }

    function _unsupportedIterableToArray(o, minLen) {
      if (!o) return;if (typeof o === "string") return _arrayLikeToArray(o, minLen);var n = Object.prototype.toString.call(o).slice(8, -1);if (n === "Object" && o.constructor) n = o.constructor.name;if (n === "Map" || n === "Set") return Array.from(o);if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
    }

    function _arrayLikeToArray(arr, len) {
      if (len == null || len > arr.length) len = arr.length;for (var i = 0, arr2 = new Array(len); i < len; i++) {
        arr2[i] = arr[i];
      }return arr2;
    }

    function _iterableToArrayLimit(arr, i) {
      var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];if (_i == null) return;var _arr = [];var _n = true;var _d = false;var _s, _e;try {
        for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
          _arr.push(_s.value);if (i && _arr.length === i) break;
        }
      } catch (err) {
        _d = true;_e = err;
      } finally {
        try {
          if (!_n && _i["return"] != null) _i["return"]();
        } finally {
          if (_d) throw _e;
        }
      }return _arr;
    }

    function _arrayWithHoles(arr) {
      if (Array.isArray(arr)) return arr;
    }

    function _extends() {
      _extends = Object.assign || function (target) {
        for (var i = 1; i < arguments.length; i++) {
          var source = arguments[i];for (var key in source) {
            if (Object.prototype.hasOwnProperty.call(source, key)) {
              target[key] = source[key];
            }
          }
        }return target;
      };return _extends.apply(this, arguments);
    }

    function _objectWithoutProperties(source, excluded) {
      if (source == null) return {};var target = _objectWithoutPropertiesLoose(source, excluded);var key, i;if (Object.getOwnPropertySymbols) {
        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);for (i = 0; i < sourceSymbolKeys.length; i++) {
          key = sourceSymbolKeys[i];if (excluded.indexOf(key) >= 0) continue;if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;target[key] = source[key];
        }
      }return target;
    }

    function _objectWithoutPropertiesLoose(source, excluded) {
      if (source == null) return {};var target = {};var sourceKeys = Object.keys(source);var key, i;for (i = 0; i < sourceKeys.length; i++) {
        key = sourceKeys[i];if (excluded.indexOf(key) >= 0) continue;target[key] = source[key];
      }return target;
    }

    var AutocompleteMarkup = /*#__PURE__*/_react.default.forwardRef(function (_ref, ref) {
      var children = _ref.children,
          otherProps = _objectWithoutProperties(_ref, _excluded);

      return (/*#__PURE__*/_react.default.createElement(_form.ClayInput.Group, _extends({}, otherProps, {
          ref: ref
        }), /*#__PURE__*/_react.default.createElement(_form.ClayInput.GroupItem, null, children))
      );
    });

    AutocompleteMarkup.displayName = 'ClayAutocompleteMarkup';

    var ClayAutocomplete = /*#__PURE__*/_react.default.forwardRef(function (_ref2, _ref3) {
      var children = _ref2.children,
          className = _ref2.className,
          _ref2$component = _ref2.component,
          Component = _ref2$component === void 0 ? AutocompleteMarkup : _ref2$component,
          otherProps = _objectWithoutProperties(_ref2, _excluded2);

      var containerElementRef = _react.default.useRef(null);

      var _React$useState = _react.default.useState(false),
          _React$useState2 = _slicedToArray(_React$useState, 2),
          loading = _React$useState2[0],
          setLoading = _React$useState2[1];

      return (/*#__PURE__*/_react.default.createElement(Component, _extends({}, otherProps, {
          className: className,
          ref: function ref(r) {
            if (r) {
              containerElementRef.current = r;

              if (typeof _ref3 === 'function') {
                _ref3(r);
              } else if (_ref3 !== null) {
                _ref3.current = r;
              }
            }
          }
        }), /*#__PURE__*/_react.default.createElement(_Context.default.Provider, {
          value: {
            containerElementRef: containerElementRef,
            loading: loading,
            onLoadingChange: function onLoadingChange(loading) {
              return setLoading(loading);
            }
          }
        }, children))
      );
    });

    ClayAutocomplete.displayName = 'ClayAutocomplete';

    var _default = Object.assign(ClayAutocomplete, {
      DropDown: _DropDown.default,
      Input: _Input.default,
      Item: _Item.default,
      LoadingIndicator: _LoadingIndicator.default
    });

    exports.default = _default;
  }
});
//# sourceMappingURL=index.js.map