Liferay.Loader.define("dynamic-data-mapping-form-builder@3.0.70/js/components/RuleList/RuleList.soy", ['module', 'exports', 'require', 'frontend-js-metal-web$metal-component', 'frontend-js-metal-web$metal-soy'], function (module, exports, require) {
  var define = undefined;
  var global = window;
  {
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = exports.templates = exports.LayoutRule = void 0;

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

    var _metalSoy = _interopRequireDefault(require("frontend-js-metal-web$metal-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 _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);
    }

    var templates;
    exports.templates = templates;
    goog.loadModule(function (exports) {
      var soy = goog.require('soy');

      goog.require('soydata');

      // This file was automatically generated from RuleList.soy.
      // Please don't edit this file by hand.

      /**
       * @fileoverview Templates in namespace LayoutRule.
       * @public
       */

      goog.module('LayoutRule.incrementaldom');

      goog.require('goog.soy.data.SanitizedContent');

      goog.require('goog.string');

      var incrementalDom = goog.require('incrementaldom');

      goog.require('soy.asserts');

      var soyIdom = goog.require('soy.idom');

      var $templateAlias2 = _metalSoy.default.getTemplate('ClayActionsDropdown.incrementaldom', 'render');

      var $templateAlias3 = _metalSoy.default.getTemplate('ClayIcon.incrementaldom', 'render');

      var $templateAlias1 = _metalSoy.default.getTemplate('ClayLabel.incrementaldom', 'render');
      /**
       * @param {{
       *  dropdownExpandedIndex: (null|number|undefined),
       *  rules: !Array<{actions: !Array<{action: (!goog.soy.data.SanitizedContent|string), dataProviderName: (?), expression: (?), inputLabel: (?), label: (!goog.soy.data.SanitizedContent|string), outputLabel: (?), target: (!goog.soy.data.SanitizedContent|string)}>, conditions: !Array<{operands: !Array<{label: (!goog.soy.data.SanitizedContent|string), type: (!goog.soy.data.SanitizedContent|string), value: (!goog.soy.data.SanitizedContent|string)}>, operator: (!goog.soy.data.SanitizedContent|string)}>, invalidRule: (?), logicalOperator: (!goog.soy.data.SanitizedContent|string), rulesCardOptions: (?)}>,
       *  spritemap: (!goog.soy.data.SanitizedContent|string),
       *  strings: !Object<!goog.soy.data.SanitizedContent|string,!goog.soy.data.SanitizedContent|string>,
       *  _handleDropdownClicked: *,
       *  _handleRuleCardClicked: *
       * }} opt_data
       * @param {Object<string, *>=} opt_ijData
       * @param {Object<string, *>=} opt_ijData_deprecated
       * @return {void}
       * @suppress {checkTypes}
       */

      function $render(opt_data, opt_ijData, opt_ijData_deprecated) {
        opt_ijData = opt_ijData_deprecated || opt_ijData;
        /** @type {null|number|undefined} */

        soy.asserts.assertType(opt_data.dropdownExpandedIndex == null || goog.isNumber(opt_data.dropdownExpandedIndex), 'dropdownExpandedIndex', opt_data.dropdownExpandedIndex, 'null|number|undefined');
        soy.asserts.assertType(goog.isArray(opt_data.rules), 'rules', opt_data.rules, '!Array<{actions: !Array<{action: (!goog.soy.data.SanitizedContent|string), dataProviderName: (?), expression: (?), inputLabel: (?), label: (!goog.soy.data.SanitizedContent|string), outputLabel: (?), target: (!goog.soy.data.SanitizedContent|string)}>, conditions: !Array<{operands: !Array<{label: (!goog.soy.data.SanitizedContent|string), type: (!goog.soy.data.SanitizedContent|string), value: (!goog.soy.data.SanitizedContent|string)}>, operator: (!goog.soy.data.SanitizedContent|string)}>, invalidRule: (?), logicalOperator: (!goog.soy.data.SanitizedContent|string), rulesCardOptions: (?)}>');
        soy.asserts.assertType(goog.isString(opt_data.spritemap) || opt_data.spritemap instanceof goog.soy.data.SanitizedContent, 'spritemap', opt_data.spritemap, '!goog.soy.data.SanitizedContent|string');
        soy.asserts.assertType(goog.isObject(opt_data.strings), 'strings', opt_data.strings, '!Object<!goog.soy.data.SanitizedContent|string,!goog.soy.data.SanitizedContent|string>');
        opt_data._handleDropdownClicked;
        opt_data._handleRuleCardClicked;

        incrementalDom.elementOpenStart('div');
        incrementalDom.attr('class', 'form-builder-rule-builder-container');
        incrementalDom.elementOpenEnd();
        incrementalDom.elementOpenStart('h1');
        incrementalDom.attr('class', 'form-builder-section-title text-default');
        incrementalDom.elementOpenEnd();
        /** @desc  */

        var MSG_EXTERNAL_3368967445947154698 = Liferay.Language.get('rule-builder');
        incrementalDom.text(goog.string.unescapeEntities(MSG_EXTERNAL_3368967445947154698));
        incrementalDom.elementClose('h1');
        incrementalDom.elementOpenStart('div');
        incrementalDom.attr('class', 'liferay-ddm-form-rule-rules-list-container');
        incrementalDom.elementOpenEnd();
        $rule_list(opt_data, null, opt_ijData);
        incrementalDom.elementClose('div');
        incrementalDom.elementClose('div');
      }

      exports.render = $render;
      /**
       * @typedef {{
       *  dropdownExpandedIndex: (null|number|undefined),
       *  rules: !Array<{actions: !Array<{action: (!goog.soy.data.SanitizedContent|string), dataProviderName: (?), expression: (?), inputLabel: (?), label: (!goog.soy.data.SanitizedContent|string), outputLabel: (?), target: (!goog.soy.data.SanitizedContent|string)}>, conditions: !Array<{operands: !Array<{label: (!goog.soy.data.SanitizedContent|string), type: (!goog.soy.data.SanitizedContent|string), value: (!goog.soy.data.SanitizedContent|string)}>, operator: (!goog.soy.data.SanitizedContent|string)}>, invalidRule: (?), logicalOperator: (!goog.soy.data.SanitizedContent|string), rulesCardOptions: (?)}>,
       *  spritemap: (!goog.soy.data.SanitizedContent|string),
       *  strings: !Object<!goog.soy.data.SanitizedContent|string,!goog.soy.data.SanitizedContent|string>,
       *  _handleDropdownClicked: *,
       *  _handleRuleCardClicked: *
       * }}
       */

      $render.Params;

      if (goog.DEBUG) {
        $render.soyTemplateName = 'LayoutRule.render';
      }
      /**
       * @param {{
       *  rules: !Array<{actions: !Array<{action: (!goog.soy.data.SanitizedContent|string), dataProviderName: (?), expression: (?), inputLabel: (?), label: (!goog.soy.data.SanitizedContent|string), outputLabel: (?), target: (!goog.soy.data.SanitizedContent|string)}>, conditions: !Array<{operands: !Array<{label: (!goog.soy.data.SanitizedContent|string), type: (!goog.soy.data.SanitizedContent|string), value: (?)}>, operator: (!goog.soy.data.SanitizedContent|string)}>, invalidRule: (?), logicalOperator: (!goog.soy.data.SanitizedContent|string), rulesCardOptions: (?)}>,
       *  spritemap: (!goog.soy.data.SanitizedContent|string),
       *  strings: !Object<!goog.soy.data.SanitizedContent|string,!goog.soy.data.SanitizedContent|string>,
       *  _handleDropdownClicked: *,
       *  _handleRuleCardClicked: *,
       *  dropdownExpandedIndex: (null|number|undefined)
       * }} opt_data
       * @param {Object<string, *>=} opt_ijData
       * @param {Object<string, *>=} opt_ijData_deprecated
       * @return {void}
       * @suppress {checkTypes}
       */

      function $rule_list(opt_data, opt_ijData, opt_ijData_deprecated) {
        opt_ijData = opt_ijData_deprecated || opt_ijData;
        /** @type {!Array<{actions: !Array<{action: (!goog.soy.data.SanitizedContent|string), dataProviderName: (?), expression: (?), inputLabel: (?), label: (!goog.soy.data.SanitizedContent|string), outputLabel: (?), target: (!goog.soy.data.SanitizedContent|string)}>, conditions: !Array<{operands: !Array<{label: (!goog.soy.data.SanitizedContent|string), type: (!goog.soy.data.SanitizedContent|string), value: (?)}>, operator: (!goog.soy.data.SanitizedContent|string)}>, invalidRule: (?), logicalOperator: (!goog.soy.data.SanitizedContent|string), rulesCardOptions: (?)}>} */

        var rules = soy.asserts.assertType(goog.isArray(opt_data.rules), 'rules', opt_data.rules, '!Array<{actions: !Array<{action: (!goog.soy.data.SanitizedContent|string), dataProviderName: (?), expression: (?), inputLabel: (?), label: (!goog.soy.data.SanitizedContent|string), outputLabel: (?), target: (!goog.soy.data.SanitizedContent|string)}>, conditions: !Array<{operands: !Array<{label: (!goog.soy.data.SanitizedContent|string), type: (!goog.soy.data.SanitizedContent|string), value: (?)}>, operator: (!goog.soy.data.SanitizedContent|string)}>, invalidRule: (?), logicalOperator: (!goog.soy.data.SanitizedContent|string), rulesCardOptions: (?)}>');
        /** @type {!goog.soy.data.SanitizedContent|string} */

        var spritemap = soy.asserts.assertType(goog.isString(opt_data.spritemap) || opt_data.spritemap instanceof goog.soy.data.SanitizedContent, 'spritemap', opt_data.spritemap, '!goog.soy.data.SanitizedContent|string');
        /** @type {!Object<!goog.soy.data.SanitizedContent|string,!goog.soy.data.SanitizedContent|string>} */

        var strings = soy.asserts.assertType(goog.isObject(opt_data.strings), 'strings', opt_data.strings, '!Object<!goog.soy.data.SanitizedContent|string,!goog.soy.data.SanitizedContent|string>');
        /** @type {*} */

        var _handleDropdownClicked = opt_data._handleDropdownClicked;
        /** @type {*} */

        var _handleRuleCardClicked = opt_data._handleRuleCardClicked;
        /** @type {null|number|undefined} */

        var dropdownExpandedIndex = soy.asserts.assertType(opt_data.dropdownExpandedIndex == null || goog.isNumber(opt_data.dropdownExpandedIndex), 'dropdownExpandedIndex', opt_data.dropdownExpandedIndex, 'null|number|undefined');
        incrementalDom.elementOpenStart('div');
        incrementalDom.attr('class', 'ddm-rule-list-container form-builder-rule-list');
        incrementalDom.elementOpenEnd();

        if (rules.length > 0) {
          incrementalDom.elementOpenStart('ul');
          incrementalDom.attr('class', 'ddm-form-body-content form-builder-rule-builder-rules-list tabular-list-group');
          incrementalDom.elementOpenEnd();
          var rule2439List = rules;
          var rule2439ListLen = rule2439List.length;

          for (var rule2439Index = 0; rule2439Index < rule2439ListLen; rule2439Index++) {
            var rule2439Data = rule2439List[rule2439Index];
            incrementalDom.elementOpenStart('li');
            incrementalDom.attr('class', 'list-group-item');
            incrementalDom.elementOpenEnd();
            incrementalDom.elementOpenStart('div');
            incrementalDom.attr('class', 'clamp-horizontal list-group-item-content');
            incrementalDom.elementOpenEnd();
            incrementalDom.elementOpenStart('p');
            incrementalDom.attr('class', 'form-builder-rule-builder-rule-description text-default');
            incrementalDom.elementOpenEnd();
            incrementalDom.elementOpen('b');
            /** @desc  */

            var MSG_EXTERNAL_5099375131746050090 = Liferay.Language.get('if');
            incrementalDom.text(goog.string.unescapeEntities(MSG_EXTERNAL_5099375131746050090));
            incrementalDom.text(' ');
            incrementalDom.elementClose('b');
            var condition2370List = rule2439Data.conditions;
            var condition2370ListLen = condition2370List.length;

            for (var condition2370Index = 0; condition2370Index < condition2370ListLen; condition2370Index++) {
              var condition2370Data = condition2370List[condition2370Index];
              $condition({
                operandType: condition2370Data.operands[0].type,
                operandValue: condition2370Data.operands[0].value
              }, null, opt_ijData);
              incrementalDom.elementOpenStart('b');
              incrementalDom.attr('class', 'text-lowercase');
              incrementalDom.elementOpenEnd();
              incrementalDom.elementOpen('em');
              incrementalDom.text(' ');
              soyIdom.print(strings[condition2370Data.operator]);
              incrementalDom.text(' ');
              incrementalDom.elementClose('em');
              incrementalDom.elementClose('b');

              if (condition2370Data.operands[1]) {
                $condition({
                  operandLabel: condition2370Data.operands[1].label,
                  operandType: condition2370Data.operands[1].type,
                  operandValue: condition2370Data.operands[1].value
                }, null, opt_ijData);
              }

              if (!(condition2370Index == condition2370ListLen - 1)) {
                incrementalDom.elementOpen('br');
                incrementalDom.elementClose('br');
                incrementalDom.elementOpen('b');
                incrementalDom.text(' ');

                if (rule2439Data.logicalOperator == 'and') {
                  /** @desc  */
                  var MSG_EXTERNAL_3929281485914893910 = Liferay.Language.get('and');
                  incrementalDom.text(goog.string.unescapeEntities(MSG_EXTERNAL_3929281485914893910));
                } else {
                  /** @desc  */
                  var MSG_EXTERNAL_6627551976444260400 = Liferay.Language.get('or');
                  incrementalDom.text(goog.string.unescapeEntities(MSG_EXTERNAL_6627551976444260400));
                }

                incrementalDom.text(' ');
                incrementalDom.elementClose('b');
              }
            }

            incrementalDom.elementOpen('br');
            incrementalDom.elementClose('br');
            var action2391List = rule2439Data.actions;
            var action2391ListLen = action2391List.length;

            for (var action2391Index = 0; action2391Index < action2391ListLen; action2391Index++) {
              var action2391Data = action2391List[action2391Index];
              $action({
                action: action2391Data.action,
                dataProviderName: action2391Data.dataProviderName,
                inputLabel: action2391Data.inputLabel,
                expression: action2391Data.expression,
                label: action2391Data.label,
                logicalOperator: rule2439Data.logicalOperator,
                outputLabel: action2391Data.outputLabel
              }, null, opt_ijData);

              if (!(action2391Index == action2391ListLen - 1)) {
                incrementalDom.text(', ');
                incrementalDom.elementOpen('br');
                incrementalDom.elementClose('br');
                incrementalDom.elementOpen('b');
                incrementalDom.text(' ');
                /** @desc  */

                var MSG_EXTERNAL_3929281485914893910$$1 = Liferay.Language.get('and');
                incrementalDom.text(goog.string.unescapeEntities(MSG_EXTERNAL_3929281485914893910$$1));
                incrementalDom.text(' ');
                incrementalDom.elementClose('b');
              }
            }

            incrementalDom.elementClose('p');
            incrementalDom.elementClose('div');
            incrementalDom.elementOpenStart('div');
            incrementalDom.attr('class', 'list-group-item-field');
            incrementalDom.elementOpenEnd();
            incrementalDom.elementOpenStart('div');
            incrementalDom.attr('class', 'card-col-field');
            incrementalDom.elementOpenEnd();

            if (rule2439Data.invalidRule) {
              var msg_15109__soy15110 = '';
              /** @desc  */

              var MSG_EXTERNAL_6630305234006636350 = Liferay.Language.get('broken-rule');
              msg_15109__soy15110 += MSG_EXTERNAL_6630305234006636350;
              var msg_15106__soy15107 = '';
              /** @desc  */

              var MSG_EXTERNAL_8835804340205883765 = Liferay.Language.get('due-to-missing-fields');
              msg_15106__soy15107 += MSG_EXTERNAL_8835804340205883765;
              var titleMessage__soy2397 = '';
              titleMessage__soy2397 += msg_15106__soy15107;
              var labelMessage__soy2404 = '';
              labelMessage__soy2404 += msg_15109__soy15110;
              incrementalDom.elementOpenStart('div');
              incrementalDom.attr('class', 'invalid-rule');
              incrementalDom.attr('title', titleMessage__soy2397);
              incrementalDom.elementOpenEnd();
              $templateAlias1({
                spritemap: spritemap,
                style: 'danger',
                label: labelMessage__soy2404
              }, null, opt_ijData);
              incrementalDom.elementClose('div');
            }

            incrementalDom.elementOpenStart('div');
            incrementalDom.attr('class', 'dropdown dropdown-action');
            incrementalDom.elementOpenEnd();
            var ruleIndex__soy2419 = rule2439Index;

            incrementalDom.elementOpenStart('div');
            incrementalDom.attr('class', 'ddm-rule-list-settings');
            incrementalDom.attr('data-card-id', ruleIndex__soy2419);
            incrementalDom.elementOpenEnd();
            $templateAlias2({
              items: rule2439Data.rulesCardOptions,
              expanded: dropdownExpandedIndex == ruleIndex__soy2419,
              events: {
                itemClicked: _handleRuleCardClicked
              },
              spritemap: spritemap
            }, null, opt_ijData);
            incrementalDom.elementOpenStart('button');
            incrementalDom.attr('class', 'component-action cursor-pointer dropdown-toggle');
            incrementalDom.attr('data-onclick', _handleDropdownClicked);
            incrementalDom.attr('data-rule-index', ruleIndex__soy2419);
            incrementalDom.elementOpenEnd();
            $templateAlias3({
              spritemap: spritemap,
              symbol: 'ellipsis-v'
            }, null, opt_ijData);
            incrementalDom.elementClose('button');
            incrementalDom.elementClose('div');
            incrementalDom.elementClose('div');
            incrementalDom.elementClose('div');
            incrementalDom.elementClose('div');
            incrementalDom.elementClose('li');
          }

          incrementalDom.elementClose('ul');
        } else {
          var msg_15112__soy15113 = '';
          /** @desc  */

          var MSG_EXTERNAL_669100315437640172 = Liferay.Language.get('there-are-no-rules-yet-click-on-plus-icon-below-to-add-the-first');
          msg_15112__soy15113 += MSG_EXTERNAL_669100315437640172;
          $empty_list({
            message: '' + msg_15112__soy15113
          }, null, opt_ijData);
        }

        incrementalDom.elementClose('div');
      }

      exports.rule_list = $rule_list;
      /**
       * @typedef {{
       *  rules: !Array<{actions: !Array<{action: (!goog.soy.data.SanitizedContent|string), dataProviderName: (?), expression: (?), inputLabel: (?), label: (!goog.soy.data.SanitizedContent|string), outputLabel: (?), target: (!goog.soy.data.SanitizedContent|string)}>, conditions: !Array<{operands: !Array<{label: (!goog.soy.data.SanitizedContent|string), type: (!goog.soy.data.SanitizedContent|string), value: (?)}>, operator: (!goog.soy.data.SanitizedContent|string)}>, invalidRule: (?), logicalOperator: (!goog.soy.data.SanitizedContent|string), rulesCardOptions: (?)}>,
       *  spritemap: (!goog.soy.data.SanitizedContent|string),
       *  strings: !Object<!goog.soy.data.SanitizedContent|string,!goog.soy.data.SanitizedContent|string>,
       *  _handleDropdownClicked: *,
       *  _handleRuleCardClicked: *,
       *  dropdownExpandedIndex: (null|number|undefined)
       * }}
       */

      $rule_list.Params;

      if (goog.DEBUG) {
        $rule_list.soyTemplateName = 'LayoutRule.rule_list';
      }
      /**
       * @param {{
       *  message: (!goog.soy.data.SanitizedContent|null|string|undefined)
       * }} opt_data
       * @param {Object<string, *>=} opt_ijData
       * @param {Object<string, *>=} opt_ijData_deprecated
       * @return {void}
       * @suppress {checkTypes}
       */

      function $empty_list(opt_data, opt_ijData, opt_ijData_deprecated) {
        opt_ijData = opt_ijData_deprecated || opt_ijData;
        opt_data = opt_data || {};
        /** @type {!goog.soy.data.SanitizedContent|null|string|undefined} */

        var message = soy.asserts.assertType(opt_data.message == null || goog.isString(opt_data.message) || opt_data.message instanceof goog.soy.data.SanitizedContent, 'message', opt_data.message, '!goog.soy.data.SanitizedContent|null|string|undefined');
        incrementalDom.elementOpenStart('div');
        incrementalDom.attr('class', 'main-content-body');
        incrementalDom.elementOpenEnd();
        incrementalDom.elementOpenStart('div');
        incrementalDom.attr('class', 'sheet taglib-empty-result-message');
        incrementalDom.elementOpenEnd();
        incrementalDom.elementOpenStart('div');
        incrementalDom.attr('class', 'taglib-empty-result-message-header');
        incrementalDom.elementOpenEnd();
        incrementalDom.elementClose('div');

        if (message) {
          incrementalDom.elementOpenStart('div');
          incrementalDom.attr('class', 'sheet-text text-center text-muted');
          incrementalDom.elementOpenEnd();
          incrementalDom.elementOpenStart('p');
          incrementalDom.attr('class', 'text-default');
          incrementalDom.elementOpenEnd();
          soyIdom.print(message);
          incrementalDom.elementClose('p');
          incrementalDom.elementClose('div');
        }

        incrementalDom.elementClose('div');
        incrementalDom.elementClose('div');
      }

      exports.empty_list = $empty_list;
      /**
       * @typedef {{
       *  message: (!goog.soy.data.SanitizedContent|null|string|undefined)
       * }}
       */

      $empty_list.Params;

      if (goog.DEBUG) {
        $empty_list.soyTemplateName = 'LayoutRule.empty_list';
      }
      /**
       * @param {{
       *  content: (!goog.soy.data.SanitizedContent|null|string|undefined)
       * }} opt_data
       * @param {Object<string, *>=} opt_ijData
       * @param {Object<string, *>=} opt_ijData_deprecated
       * @return {void}
       * @suppress {checkTypes}
       */

      function $label(opt_data, opt_ijData, opt_ijData_deprecated) {
        opt_ijData = opt_ijData_deprecated || opt_ijData;
        opt_data = opt_data || {};
        /** @type {!goog.soy.data.SanitizedContent|null|string|undefined} */

        var content = soy.asserts.assertType(opt_data.content == null || goog.isString(opt_data.content) || opt_data.content instanceof goog.soy.data.SanitizedContent, 'content', opt_data.content, '!goog.soy.data.SanitizedContent|null|string|undefined');
        incrementalDom.elementOpenStart('span');
        incrementalDom.attr('class', 'label label-lg label-secondary');
        incrementalDom.attr('data-original-title', content);
        incrementalDom.attr('title', content);
        incrementalDom.elementOpenEnd();
        incrementalDom.elementOpenStart('span');
        incrementalDom.attr('class', 'text-truncate-inline');
        incrementalDom.elementOpenEnd();
        incrementalDom.elementOpenStart('span');
        incrementalDom.attr('class', 'text-truncate');
        incrementalDom.elementOpenEnd();
        soyIdom.print(content);
        incrementalDom.elementClose('span');
        incrementalDom.elementClose('span');
        incrementalDom.elementClose('span');
      }

      exports.label = $label;
      /**
       * @typedef {{
       *  content: (!goog.soy.data.SanitizedContent|null|string|undefined)
       * }}
       */

      $label.Params;

      if (goog.DEBUG) {
        $label.soyTemplateName = 'LayoutRule.label';
      }
      /**
       * @param {{
       *  operandType: (!goog.soy.data.SanitizedContent|string),
       *  operandLabel: (!goog.soy.data.SanitizedContent|null|string|undefined),
       *  operandValue: (?)
       * }} opt_data
       * @param {Object<string, *>=} opt_ijData
       * @param {Object<string, *>=} opt_ijData_deprecated
       * @return {void}
       * @suppress {checkTypes}
       */

      function $condition(opt_data, opt_ijData, opt_ijData_deprecated) {
        opt_ijData = opt_ijData_deprecated || opt_ijData;
        /** @type {!goog.soy.data.SanitizedContent|string} */

        var operandType = soy.asserts.assertType(goog.isString(opt_data.operandType) || opt_data.operandType instanceof goog.soy.data.SanitizedContent, 'operandType', opt_data.operandType, '!goog.soy.data.SanitizedContent|string');
        /** @type {!goog.soy.data.SanitizedContent|null|string|undefined} */

        var operandLabel = soy.asserts.assertType(opt_data.operandLabel == null || goog.isString(opt_data.operandLabel) || opt_data.operandLabel instanceof goog.soy.data.SanitizedContent, 'operandLabel', opt_data.operandLabel, '!goog.soy.data.SanitizedContent|null|string|undefined');
        /** @type {?} */

        var operandValue = opt_data.operandValue;
        incrementalDom.elementOpenStart('div');
        incrementalDom.attr('class', 'ddm-condition-container');
        incrementalDom.elementOpenEnd();

        if (operandType == 'double' || operandType == 'integer' || operandType == 'json' || operandType == 'option' || operandType == 'string' || operandType == 'text' || operandType == 'numeric') {
          incrementalDom.elementOpen('span');
          /** @desc  */

          var MSG_EXTERNAL_3375720161310377589 = Liferay.Language.get('value');
          incrementalDom.text(goog.string.unescapeEntities(MSG_EXTERNAL_3375720161310377589));
          incrementalDom.text(' ');
          incrementalDom.elementClose('span');
        } else if (operandType == 'user') {
          incrementalDom.elementOpen('span');
          /** @desc  */

          var MSG_EXTERNAL_123010868147850959 = Liferay.Language.get('user');
          incrementalDom.text(goog.string.unescapeEntities(MSG_EXTERNAL_123010868147850959));
          incrementalDom.text(' ');
          incrementalDom.elementClose('span');
        } else if (operandType == 'field') {
          incrementalDom.elementOpen('span');
          /** @desc  */

          var MSG_EXTERNAL_8167904999979308163 = Liferay.Language.get('field');
          incrementalDom.text(goog.string.unescapeEntities(MSG_EXTERNAL_8167904999979308163));
          incrementalDom.text(' ');
          incrementalDom.elementClose('span');
        } else if (operandType == 'list') {
          incrementalDom.elementOpen('span');
          /** @desc  */

          var MSG_EXTERNAL_7246196759043272468 = Liferay.Language.get('list');
          incrementalDom.text(goog.string.unescapeEntities(MSG_EXTERNAL_7246196759043272468));
          incrementalDom.text(' ');
          incrementalDom.elementClose('span');
        }

        if (operandLabel) {
          $label({
            content: operandLabel
          }, null, opt_ijData);
        } else {
          $label({
            content: operandValue
          }, null, opt_ijData);
        }

        incrementalDom.elementClose('div');
      }

      exports.condition = $condition;
      /**
       * @typedef {{
       *  operandType: (!goog.soy.data.SanitizedContent|string),
       *  operandLabel: (!goog.soy.data.SanitizedContent|null|string|undefined),
       *  operandValue: (?)
       * }}
       */

      $condition.Params;

      if (goog.DEBUG) {
        $condition.soyTemplateName = 'LayoutRule.condition';
      }
      /**
       * @param {{
       *  action: (!goog.soy.data.SanitizedContent|string),
       *  dataProviderName: (?),
       *  expression: (?),
       *  label: (?),
       *  outputLabel: (?)
       * }} opt_data
       * @param {Object<string, *>=} opt_ijData
       * @param {Object<string, *>=} opt_ijData_deprecated
       * @return {void}
       * @suppress {checkTypes}
       */

      function $action(opt_data, opt_ijData, opt_ijData_deprecated) {
        opt_ijData = opt_ijData_deprecated || opt_ijData;
        /** @type {!goog.soy.data.SanitizedContent|string} */

        var action = soy.asserts.assertType(goog.isString(opt_data.action) || opt_data.action instanceof goog.soy.data.SanitizedContent, 'action', opt_data.action, '!goog.soy.data.SanitizedContent|string');
        /** @type {?} */

        var dataProviderName = opt_data.dataProviderName;
        /** @type {?} */

        var expression = opt_data.expression;
        /** @type {?} */

        var label = opt_data.label;
        /** @type {?} */

        var outputLabel = opt_data.outputLabel;

        if (action == 'auto-fill') {
          var dataProviderOutputFields__soy2527 = function dataProviderOutputFields__soy2527() {
            var out2537List = outputLabel;
            var out2537ListLen = out2537List.length;

            for (var out2537Index = 0; out2537Index < out2537ListLen; out2537Index++) {
              var out2537Data = out2537List[out2537Index];
              $label({
                content: out2537Data
              }, null, opt_ijData);

              if (!(out2537Index == out2537ListLen - 1)) {
                incrementalDom.text(', ');
              }
            }
          };

          incrementalDom.elementOpen('span');
          incrementalDom.elementOpen('b');
          /** @desc  */

          var MSG_EXTERNAL_8930607439260873448 = Liferay.Language.get('autofill-x-from-data-provider-x');
          MSG_EXTERNAL_8930607439260873448 = MSG_EXTERNAL_8930607439260873448.replace(/{(\d+)}/g, '\x01$1\x01');
          var lastIndex_2541 = 0,
              partRe_2541 = /\x01\d+\x01/g,
              match_2541;

          do {
            match_2541 = partRe_2541.exec(MSG_EXTERNAL_8930607439260873448) || undefined;
            incrementalDom.text(goog.string.unescapeEntities(MSG_EXTERNAL_8930607439260873448.substring(lastIndex_2541, match_2541 && match_2541.index)));
            lastIndex_2541 = partRe_2541.lastIndex;

            switch (match_2541 && match_2541[0]) {
              case "\x011\x01":
                soyIdom.print(dataProviderName);
                break;

              case "\x010\x01":
                dataProviderOutputFields__soy2527();
                break;
            }
          } while (match_2541);

          incrementalDom.elementClose('b');
          incrementalDom.elementClose('span');
        } else if (action == 'calculate') {
          var expressionLabel__soy2552 = function expressionLabel__soy2552() {
            $label({
              content: expression
            }, null, opt_ijData);
          };

          var targetLabel__soy2558 = function targetLabel__soy2558() {
            $label({
              content: label
            }, null, opt_ijData);
          };

          incrementalDom.elementOpen('span');
          incrementalDom.elementOpen('b');
          /** @desc  */

          var MSG_EXTERNAL_3206084286330742941 = Liferay.Language.get('calculate-field-x-as-x');
          MSG_EXTERNAL_3206084286330742941 = MSG_EXTERNAL_3206084286330742941.replace(/{(\d+)}/g, '\x01$1\x01');
          var lastIndex_2564 = 0,
              partRe_2564 = /\x01\d+\x01/g,
              match_2564;

          do {
            match_2564 = partRe_2564.exec(MSG_EXTERNAL_3206084286330742941) || undefined;
            incrementalDom.text(goog.string.unescapeEntities(MSG_EXTERNAL_3206084286330742941.substring(lastIndex_2564, match_2564 && match_2564.index)));
            lastIndex_2564 = partRe_2564.lastIndex;

            switch (match_2564 && match_2564[0]) {
              case "\x011\x01":
                targetLabel__soy2558();
                break;

              case "\x010\x01":
                expressionLabel__soy2552();
                break;
            }
          } while (match_2564);

          incrementalDom.elementClose('b');
          incrementalDom.elementClose('span');
        } else if (action == 'enable') {
          incrementalDom.elementOpen('span');
          incrementalDom.elementOpen('b');
          /** @desc  */

          var MSG_EXTERNAL_6578734339769388749 = Liferay.Language.get('enable');
          incrementalDom.text(goog.string.unescapeEntities(MSG_EXTERNAL_6578734339769388749));
          incrementalDom.text(' ');
          incrementalDom.elementClose('b');
          incrementalDom.elementClose('span');
          $label({
            content: label
          }, null, opt_ijData);
        } else if (action == 'jump-to-page') {
          incrementalDom.elementOpen('span');
          incrementalDom.elementOpen('b');
          /** @desc  */

          var MSG_EXTERNAL_6089475641791297161 = Liferay.Language.get('jump-to-page');
          incrementalDom.text(goog.string.unescapeEntities(MSG_EXTERNAL_6089475641791297161));
          incrementalDom.text(' ');
          incrementalDom.elementClose('b');
          incrementalDom.elementClose('span');
          $label({
            content: label
          }, null, opt_ijData);
        } else if (action == 'require') {
          incrementalDom.elementOpen('span');
          incrementalDom.elementOpen('b');
          /** @desc  */

          var MSG_EXTERNAL_7337980473456458003 = Liferay.Language.get('require');
          incrementalDom.text(goog.string.unescapeEntities(MSG_EXTERNAL_7337980473456458003));
          incrementalDom.text(' ');
          incrementalDom.elementClose('b');
          incrementalDom.elementClose('span');
          $label({
            content: label
          }, null, opt_ijData);
        } else if (action == 'show') {
          incrementalDom.elementOpen('span');
          incrementalDom.elementOpen('b');
          /** @desc  */

          var MSG_EXTERNAL_1504349909398224884 = Liferay.Language.get('show');
          incrementalDom.text(goog.string.unescapeEntities(MSG_EXTERNAL_1504349909398224884));
          incrementalDom.text(' ');
          incrementalDom.elementClose('b');
          incrementalDom.elementClose('span');
          $label({
            content: label
          }, null, opt_ijData);
        }
      }

      exports.action = $action;
      /**
       * @typedef {{
       *  action: (!goog.soy.data.SanitizedContent|string),
       *  dataProviderName: (?),
       *  expression: (?),
       *  label: (?),
       *  outputLabel: (?)
       * }}
       */

      $action.Params;

      if (goog.DEBUG) {
        $action.soyTemplateName = 'LayoutRule.action';
      }

      exports.render.params = ["dropdownExpandedIndex", "rules", "spritemap", "strings", "_handleDropdownClicked", "_handleRuleCardClicked"];
      exports.render.types = {
        "dropdownExpandedIndex": "number",
        "rules": "list<[\n\t\t\tactions: list<[\n\t\t\t\taction: string,\n\t\t\t\tdataProviderName: ?,\n\t\t\t\texpression: ?,\n\t\t\t\tinputLabel: ?,\n\t\t\t\ttarget: string,\n\t\t\t\tlabel: string,\n\t\t\t\toutputLabel: ?\n\t\t\t]>,\n\t\t\tconditions: list<[\n\t\t\t\toperator: string,\n\t\t\t\toperands: list<[\n\t\t\t\t\ttype: string,\n\t\t\t\t\tlabel: string,\n\t\t\t\t\tvalue: string\n\t\t\t\t]>\n\t\t\t]>,\n\t\t\tinvalidRule: ?,\n\t\t\tlogicalOperator: string,\n\t\t\trulesCardOptions: ?\n\t\t]>\n\t",
        "spritemap": "string",
        "strings": "map<string, string>",
        "_handleDropdownClicked": "any",
        "_handleRuleCardClicked": "any"
      };
      exports.rule_list.params = ["rules", "spritemap", "strings", "_handleDropdownClicked", "_handleRuleCardClicked", "dropdownExpandedIndex"];
      exports.rule_list.types = {
        "rules": "list<[\n\t\t\tactions: list<[\n\t\t\t\taction: string,\n\t\t\t\tdataProviderName: ?,\n\t\t\t\texpression: ?,\n\t\t\t\tinputLabel: ?,\n\t\t\t\ttarget: string,\n\t\t\t\tlabel: string,\n\t\t\t\toutputLabel: ?\n\t\t\t]>,\n\t\t\tconditions: list<[\n\t\t\t\toperator: string,\n\t\t\t\toperands: list<[\n\t\t\t\t\ttype: string,\n\t\t\t\t\tlabel: string,\n\t\t\t\t\tvalue: ?\n\t\t\t\t]>\n\t\t\t]>,\n\t\t\tinvalidRule: ?,\n\t\t\tlogicalOperator: string,\n\t\t\trulesCardOptions: ?\n\t\t]>\n\t",
        "spritemap": "string",
        "strings": "map<string, string>",
        "_handleDropdownClicked": "any",
        "_handleRuleCardClicked": "any",
        "dropdownExpandedIndex": "number"
      };
      exports.empty_list.params = ["message"];
      exports.empty_list.types = {
        "message": "string"
      };
      exports.label.params = ["content"];
      exports.label.types = {
        "content": "string"
      };
      exports.condition.params = ["operandType", "operandLabel", "operandValue"];
      exports.condition.types = {
        "operandType": "string",
        "operandLabel": "string",
        "operandValue": "?"
      };
      exports.action.params = ["action", "dataProviderName", "expression", "label", "outputLabel"];
      exports.action.types = {
        "action": "string",
        "dataProviderName": "?",
        "expression": "?",
        "label": "?",
        "outputLabel": "?"
      };
      exports.templates = templates = exports;
      return exports;
    });

    var LayoutRule = /*#__PURE__*/function (_Component) {
      _inherits(LayoutRule, _Component);

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

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

      return LayoutRule;
    }(_metalComponent.default);

    exports.LayoutRule = LayoutRule;

    _metalSoy.default.register(LayoutRule, templates);

    var _default = templates;
    /* jshint ignore:end */

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