Liferay.Loader.define("commerce-product-content-web@3.0.31/js/CategorySelector.es", ['module', 'exports', 'require', 'frontend-js-metal-web$metal-component', 'frontend-js-metal-web$metal-soy', 'frontend-js-metal-web$metal-state', './CategorySelector.soy'], function (module, exports, require) {
  var define = undefined;
  var global = window;
  {
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = exports.CategorySelector = void 0;

    var _metalComponent = _interopRequireDefault(require("frontend-js-metal-web$metal-component"));

    var _metalSoy = _interopRequireDefault(require("frontend-js-metal-web$metal-soy"));

    var _metalState = require("frontend-js-metal-web$metal-state");

    var _CategorySelector = _interopRequireDefault(require("./CategorySelector.soy"));

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

    function _typeof(obj) {
      "@babel/helpers - typeof";
      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
        _typeof = function _typeof(obj) {
          return typeof obj;
        };
      } else {
        _typeof = function _typeof(obj) {
          return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
        };
      }return _typeof(obj);
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    function _defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
      }
    }

    function _createClass(Constructor, protoProps, staticProps) {
      if (protoProps) _defineProperties(Constructor.prototype, protoProps);if (staticProps) _defineProperties(Constructor, staticProps);return Constructor;
    }

    function _possibleConstructorReturn(self, call) {
      if (call && (_typeof(call) === "object" || typeof call === "function")) {
        return call;
      }return _assertThisInitialized(self);
    }

    function _assertThisInitialized(self) {
      if (self === void 0) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }return self;
    }

    function _getPrototypeOf(o) {
      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
        return o.__proto__ || Object.getPrototypeOf(o);
      };return _getPrototypeOf(o);
    }

    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function");
      }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });if (superClass) _setPrototypeOf(subClass, superClass);
    }

    function _setPrototypeOf(o, p) {
      _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
        o.__proto__ = p;return o;
      };return _setPrototypeOf(o, p);
    }

    /**
     * CategorySelector is a temporary Component wrapping the existing
     * AUI module liferay-commerce-frontend-asset-categories-selector
     */
    var CategorySelector = /*#__PURE__*/function (_Component) {
      _inherits(CategorySelector, _Component);

      function CategorySelector() {
        _classCallCheck(this, CategorySelector);

        return _possibleConstructorReturn(this, _getPrototypeOf(CategorySelector).apply(this, arguments));
      }

      _createClass(CategorySelector, [{
        key: "onEntriesChanged_",

        /**
         * Updates the calculated rule fields for `queryValues` and `categoryIdsTitles`
         * every time a new category entry is added or removed to the selection
         * @protected
         */
        value: function onEntriesChanged_() {
          this.rule.categoryIdsTitles = this.categoriesSelector_.entries.values.map(function (element) {
            return element.value;
          });
          this.rule.queryValues = this.categoriesSelector_.entries.keys.join(',');
        }
        /**
         * @inheritDoc
         */

      }, {
        key: "rendered",
        value: function rendered() {
          var _this = this;

          AUI().use('liferay-commerce-frontend-asset-categories-selector', function () {
            var config = {
              categoryIds: _this.rule.queryValues || '',
              categoryTitles: _this.rule.categoryIdsTitles || [],
              contentBox: _this.element,
              eventName: _this.eventName,
              groupIds: _this.groupIds,
              hiddenInput: "#".concat(_this.refs.hiddenInput.getAttribute('id')),
              portletURL: _this.categorySelectorURL,
              vocabularyIds: _this.vocabularyIds
            };
            _this.categoriesSelector_ = new Liferay.AssetTaglibCategoriesSelector(config);
            var entries = _this.categoriesSelector_.entries;
            entries.after('add', _this.onEntriesChanged_, _this);
            entries.after('remove', _this.onEntriesChanged_, _this);

            _this.categoriesSelector_.render();

            _this.element.parentNode.removeAttribute('tabindex');
          });
        }
      }]);

      return CategorySelector;
    }(_metalComponent.default);

    exports.CategorySelector = CategorySelector;
    CategorySelector.STATE = {
      /**
       * Portlet ID used for selecting categories.
       * For this component it's required because is the only way
       * to select categories.
       */
      categorySelectorURL: _metalState.Config.string().value(''),

      /**
       * Name of the event that will be dispatched when the
       * category selector dialog is closed
       */
      eventName: _metalState.Config.string().value(''),

      /**
       * Array of group ids (sites) where categories will be searched.
       * It defaults to an empty array, which is the current site.
       */
      groupIds: _metalState.Config.string().value(''),

      /**
       * Id of the hidden input used to pass the selected categories
       */
      hiddenInput: _metalState.Config.string().value(''),

      /**
       * Number used for avoiding conflicts between different
       * instances of the component/portlet.
       */
      index: _metalState.Config.number().value(0),

      /**
       * String used for avoiding conflicts between different
       * instances of the component/portlet.
       */
      namespace: _metalState.Config.string().value(''),

      /**
       * Existing information of the form.
       * @prop {string[]} queryValues Categories that are already selected.
       *  This property is updated as the user selects new categories.
       * @prop {string[]} categoryIdsTitles Titles of the categories that are
       * 	already selected. It is kept in sync with `queryValues`
       */
      rule: _metalState.Config.object().value({}),

      /**
       * Ids of the vocabularies parents of the selected categories.
       * Vocabularies are super groups which group a set of categories.
       */
      vocabularyIds: _metalState.Config.string().value('')
    };

    _metalSoy.default.register(CategorySelector, _CategorySelector.default);

    var _default = CategorySelector;
    exports.default = _default;
    //# sourceMappingURL=CategorySelector.es.js.map
  }
});
//# sourceMappingURL=CategorySelector.es.js.map