starh-comp-common/dist/index.js

Libreria di componenti React specifica per la piattaforma StarH.

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var React = require('react');
var inputtext = require('primereact/inputtext');
var utils = require('primereact/utils');
var PropTypes = require('prop-types');
var reactHookForm = require('react-hook-form');
var moment = require('moment');
var yup = require('@hookform/resolvers/yup');
var dropdown = require('primereact/dropdown');
var axios = require('axios');
var reactIntl = require('react-intl');
var blockui = require('primereact/blockui');
var picklist = require('primereact/picklist');
var multiselect = require('primereact/multiselect');
var chips = require('primereact/chips');
var calendar = require('primereact/calendar');
var button = require('primereact/button');
var checkbox = require('primereact/checkbox');
var inputnumber = require('primereact/inputnumber');
var password = require('primereact/password');
var inputswitch = require('primereact/inputswitch');
var inputtextarea = require('primereact/inputtextarea');
var tristatecheckbox = require('primereact/tristatecheckbox');
var autocomplete = require('primereact/autocomplete');
var _ = require('lodash');
var fileupload = require('primereact/fileupload');
var datatable = require('primereact/datatable');
var column = require('primereact/column');
var sidebar = require('primereact/sidebar');
var overlaypanel = require('primereact/overlaypanel');
var tabview = require('primereact/tabview');
var dialog = require('primereact/dialog');
var multistatecheckbox = require('primereact/multistatecheckbox');
var splitbutton = require('primereact/splitbutton');
var scrollpanel = require('primereact/scrollpanel');
var yup$1 = require('yup');
var panel = require('primereact/panel');
var reactRouterDom = require('react-router-dom');
var selectbutton = require('primereact/selectbutton');
var bundle_css = require('./bundle.css');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

function _interopNamespace(e) {
  if (e && e.__esModule) return e;
  var n = Object.create(null);
  if (e) {
    Object.keys(e).forEach(function (k) {
      if (k !== 'default') {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(n, k, d.get ? d : {
          enumerable: true,
          get: function () { return e[k]; }
        });
      }
    });
  }
  n["default"] = e;
  return Object.freeze(n);
}

var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
var PropTypes__default = /*#__PURE__*/_interopDefaultLegacy(PropTypes);
var PropTypes__namespace = /*#__PURE__*/_interopNamespace(PropTypes);
var moment__default = /*#__PURE__*/_interopDefaultLegacy(moment);
var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
var ___default = /*#__PURE__*/_interopDefaultLegacy(_);
var yup__namespace = /*#__PURE__*/_interopNamespace(yup$1);

function _arrayLikeToArray(r, a) {
  (null == a || a > r.length) && (a = r.length);
  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
  return n;
}
function _arrayWithHoles(r) {
  if (Array.isArray(r)) return r;
}
function _arrayWithoutHoles(r) {
  if (Array.isArray(r)) return _arrayLikeToArray(r);
}
function _createForOfIteratorHelper(r, e) {
  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
  if (!t) {
    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
      t && (r = t);
      var n = 0,
        F = function () {};
      return {
        s: F,
        n: function () {
          return n >= r.length ? {
            done: !0
          } : {
            done: !1,
            value: r[n++]
          };
        },
        e: function (r) {
          throw r;
        },
        f: F
      };
    }
    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }
  var o,
    a = !0,
    u = !1;
  return {
    s: function () {
      t = t.call(r);
    },
    n: function () {
      var r = t.next();
      return a = r.done, r;
    },
    e: function (r) {
      u = !0, o = r;
    },
    f: function () {
      try {
        a || null == t.return || t.return();
      } finally {
        if (u) throw o;
      }
    }
  };
}
function _defineProperty(e, r, t) {
  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
    value: t,
    enumerable: !0,
    configurable: !0,
    writable: !0
  }) : e[r] = t, e;
}
function _extends() {
  return _extends = Object.assign ? Object.assign.bind() : function (n) {
    for (var e = 1; e < arguments.length; e++) {
      var t = arguments[e];
      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
    }
    return n;
  }, _extends.apply(null, arguments);
}
function _iterableToArray(r) {
  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
}
function _iterableToArrayLimit(r, l) {
  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
  if (null != t) {
    var e,
      n,
      i,
      u,
      a = [],
      f = !0,
      o = !1;
    try {
      if (i = (t = t.call(r)).next, 0 === l) {
        if (Object(t) !== t) return;
        f = !1;
      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
    } catch (r) {
      o = !0, n = r;
    } finally {
      try {
        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
      } finally {
        if (o) throw n;
      }
    }
    return a;
  }
}
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 _nonIterableSpread() {
  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function ownKeys(e, r) {
  var t = Object.keys(e);
  if (Object.getOwnPropertySymbols) {
    var o = Object.getOwnPropertySymbols(e);
    r && (o = o.filter(function (r) {
      return Object.getOwnPropertyDescriptor(e, r).enumerable;
    })), t.push.apply(t, o);
  }
  return t;
}
function _objectSpread2(e) {
  for (var r = 1; r < arguments.length; r++) {
    var t = null != arguments[r] ? arguments[r] : {};
    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
      _defineProperty(e, r, t[r]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
    });
  }
  return e;
}
function _slicedToArray(r, e) {
  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
}
function _toConsumableArray(r) {
  return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
}
function _toPrimitive(t, r) {
  if ("object" != typeof t || !t) return t;
  var e = t[Symbol.toPrimitive];
  if (void 0 !== e) {
    var i = e.call(t, r || "default");
    if ("object" != typeof i) return i;
    throw new TypeError("@@toPrimitive must return a primitive value.");
  }
  return ("string" === r ? String : Number)(t);
}
function _toPropertyKey(t) {
  var i = _toPrimitive(t, "string");
  return "symbol" == typeof i ? i : i + "";
}
function _unsupportedIterableToArray(r, a) {
  if (r) {
    if ("string" == typeof r) return _arrayLikeToArray(r, a);
    var t = {}.toString.call(r).slice(8, -1);
    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
  }
}

var FormContext = /*#__PURE__*/React__default["default"].createContext(null);
var FormItemContext = /*#__PURE__*/React__default["default"].createContext(null);

var CondionalControllerWrapper = function CondionalControllerWrapper(props) {
  if (props.wrap) {
    return /*#__PURE__*/React__default["default"].createElement(reactHookForm.Controller, {
      control: props.control,
      name: props.name,
      defaultValue: props.defaultValue,
      render: function render(_ref) {
        var field = _ref.field;
        return /*#__PURE__*/React__default["default"].createElement(FormItemContext.Provider, {
          value: field
        }, props.children);
      }
    });
  } else {
    return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, props.children);
  }
};
CondionalControllerWrapper.propTypes = {
  wrap: PropTypes__default["default"].bool.isRequired,
  control: PropTypes__default["default"].object,
  name: PropTypes__default["default"].string.isRequired,
  defaultValue: PropTypes__default["default"].any
};
CondionalControllerWrapper.defaultProps = {
  wrap: true
};

var onlyInteger = function onlyInteger(evt) {
  var theEvent = evt || window.event;
  // Handle key press
  var key = theEvent.keyCode || theEvent.which;
  key = String.fromCharCode(key);
  var regex = /^[0-9]*$/gm;
  if (!regex.test(key)) {
    theEvent.returnValue = false;
    if (theEvent.preventDefault) theEvent.preventDefault();
  }
};
var onlyFloat = function onlyFloat(evt) {
  var theEvent = evt || window.event;
  // Handle key press
  var key = theEvent.keyCode || theEvent.which;
  key = String.fromCharCode(key);
  var regex = /[0-9]|,/;
  if (!regex.test(key)) {
    theEvent.returnValue = false;
    if (theEvent.preventDefault) theEvent.preventDefault();
  }
};
var checkDateOverlap = function checkDateOverlap(dateRanges) {
  var sortedRanges = dateRanges.sort(function (previous, current) {
    // get the start date from previous and current
    var previousTime = previous.dateStart.getTime();
    var currentTime = current.dateStart.getTime();

    // if the previous is earlier than the current
    if (previousTime < currentTime) {
      return -1;
    }

    // if the previous time is the same as the current time
    if (previousTime === currentTime) {
      return 0;
    }

    // if the previous time is later than the current time
    return 1;
  });
  var result = sortedRanges.reduce(function (result, current, idx, arr) {
    // get the previous range
    if (idx === 0) {
      return result;
    }
    var previous = arr[idx - 1];

    // check for any overlap
    var previousEnd = previous.dateEnd.getTime();
    var currentStart = current.dateStart.getTime();
    var overlap = previousEnd >= currentStart;

    // store the result
    if (overlap) {
      // yes, there is overlap
      result.overlap = true;
      // store the specific ranges that overlap
      result.ranges.push({
        previous: previous,
        current: current
      });
    }
    return result;

    // seed the reduce
  }, {
    overlap: false,
    ranges: []
  });

  // return the final results
  return result;
};
var getGravatar = function getGravatar(email, size) {
  // MD5 (Message-Digest Algorithm) by WebToolkit
  //
  var MD5 = function MD5(s) {
    function L(k, d) {
      return k << d | k >>> 32 - d;
    }
    function K(G, k) {
      var I, d, F, H, x;
      F = G & 2147483648;
      H = k & 2147483648;
      I = G & 1073741824;
      d = k & 1073741824;
      x = (G & 1073741823) + (k & 1073741823);
      if (I & d) {
        return x ^ 2147483648 ^ F ^ H;
      }
      if (I | d) {
        if (x & 1073741824) {
          return x ^ 3221225472 ^ F ^ H;
        } else {
          return x ^ 1073741824 ^ F ^ H;
        }
      } else {
        return x ^ F ^ H;
      }
    }
    function r(d, F, k) {
      return d & F | ~d & k;
    }
    function q(d, F, k) {
      return d & k | F & ~k;
    }
    function p(d, F, k) {
      return d ^ F ^ k;
    }
    function n(d, F, k) {
      return F ^ (d | ~k);
    }
    function u(G, F, aa, Z, k, H, I) {
      G = K(G, K(K(r(F, aa, Z), k), I));
      return K(L(G, H), F);
    }
    function f(G, F, aa, Z, k, H, I) {
      G = K(G, K(K(q(F, aa, Z), k), I));
      return K(L(G, H), F);
    }
    function D(G, F, aa, Z, k, H, I) {
      G = K(G, K(K(p(F, aa, Z), k), I));
      return K(L(G, H), F);
    }
    function t(G, F, aa, Z, k, H, I) {
      G = K(G, K(K(n(F, aa, Z), k), I));
      return K(L(G, H), F);
    }
    function e(G) {
      var Z;
      var F = G.length;
      var x = F + 8;
      var k = (x - x % 64) / 64;
      var I = (k + 1) * 16;
      var aa = Array(I - 1);
      var d = 0;
      var H = 0;
      while (H < F) {
        Z = (H - H % 4) / 4;
        d = H % 4 * 8;
        aa[Z] = aa[Z] | G.charCodeAt(H) << d;
        H++;
      }
      Z = (H - H % 4) / 4;
      d = H % 4 * 8;
      aa[Z] = aa[Z] | 128 << d;
      aa[I - 2] = F << 3;
      aa[I - 1] = F >>> 29;
      return aa;
    }
    function B(x) {
      var k = '',
        F = '',
        G,
        d;
      for (d = 0; d <= 3; d++) {
        G = x >>> d * 8 & 255;
        F = '0' + G.toString(16);
        k = k + F.substr(F.length - 2, 2);
      }
      return k;
    }
    function J(k) {
      k = k.replace(/rn/g, 'n');
      var d = '';
      for (var F = 0; F < k.length; F++) {
        var x = k.charCodeAt(F);
        if (x < 128) {
          d += String.fromCharCode(x);
        } else {
          if (x > 127 && x < 2048) {
            d += String.fromCharCode(x >> 6 | 192);
            d += String.fromCharCode(x & 63 | 128);
          } else {
            d += String.fromCharCode(x >> 12 | 224);
            d += String.fromCharCode(x >> 6 & 63 | 128);
            d += String.fromCharCode(x & 63 | 128);
          }
        }
      }
      return d;
    }
    var C = [];
    var P, h, E, v, g, Y, X, W, V;
    var S = 7,
      Q = 12,
      N = 17,
      M = 22;
    var A = 5,
      z = 9,
      y = 14,
      w = 20;
    var o = 4,
      m = 11,
      l = 16,
      j = 23;
    var U = 6,
      T = 10,
      R = 15,
      O = 21;
    s = J(s);
    C = e(s);
    Y = 1732584193;
    X = 4023233417;
    W = 2562383102;
    V = 271733878;
    for (P = 0; P < C.length; P += 16) {
      h = Y;
      E = X;
      v = W;
      g = V;
      Y = u(Y, X, W, V, C[P + 0], S, 3614090360);
      V = u(V, Y, X, W, C[P + 1], Q, 3905402710);
      W = u(W, V, Y, X, C[P + 2], N, 606105819);
      X = u(X, W, V, Y, C[P + 3], M, 3250441966);
      Y = u(Y, X, W, V, C[P + 4], S, 4118548399);
      V = u(V, Y, X, W, C[P + 5], Q, 1200080426);
      W = u(W, V, Y, X, C[P + 6], N, 2821735955);
      X = u(X, W, V, Y, C[P + 7], M, 4249261313);
      Y = u(Y, X, W, V, C[P + 8], S, 1770035416);
      V = u(V, Y, X, W, C[P + 9], Q, 2336552879);
      W = u(W, V, Y, X, C[P + 10], N, 4294925233);
      X = u(X, W, V, Y, C[P + 11], M, 2304563134);
      Y = u(Y, X, W, V, C[P + 12], S, 1804603682);
      V = u(V, Y, X, W, C[P + 13], Q, 4254626195);
      W = u(W, V, Y, X, C[P + 14], N, 2792965006);
      X = u(X, W, V, Y, C[P + 15], M, 1236535329);
      Y = f(Y, X, W, V, C[P + 1], A, 4129170786);
      V = f(V, Y, X, W, C[P + 6], z, 3225465664);
      W = f(W, V, Y, X, C[P + 11], y, 643717713);
      X = f(X, W, V, Y, C[P + 0], w, 3921069994);
      Y = f(Y, X, W, V, C[P + 5], A, 3593408605);
      V = f(V, Y, X, W, C[P + 10], z, 38016083);
      W = f(W, V, Y, X, C[P + 15], y, 3634488961);
      X = f(X, W, V, Y, C[P + 4], w, 3889429448);
      Y = f(Y, X, W, V, C[P + 9], A, 568446438);
      V = f(V, Y, X, W, C[P + 14], z, 3275163606);
      W = f(W, V, Y, X, C[P + 3], y, 4107603335);
      X = f(X, W, V, Y, C[P + 8], w, 1163531501);
      Y = f(Y, X, W, V, C[P + 13], A, 2850285829);
      V = f(V, Y, X, W, C[P + 2], z, 4243563512);
      W = f(W, V, Y, X, C[P + 7], y, 1735328473);
      X = f(X, W, V, Y, C[P + 12], w, 2368359562);
      Y = D(Y, X, W, V, C[P + 5], o, 4294588738);
      V = D(V, Y, X, W, C[P + 8], m, 2272392833);
      W = D(W, V, Y, X, C[P + 11], l, 1839030562);
      X = D(X, W, V, Y, C[P + 14], j, 4259657740);
      Y = D(Y, X, W, V, C[P + 1], o, 2763975236);
      V = D(V, Y, X, W, C[P + 4], m, 1272893353);
      W = D(W, V, Y, X, C[P + 7], l, 4139469664);
      X = D(X, W, V, Y, C[P + 10], j, 3200236656);
      Y = D(Y, X, W, V, C[P + 13], o, 681279174);
      V = D(V, Y, X, W, C[P + 0], m, 3936430074);
      W = D(W, V, Y, X, C[P + 3], l, 3572445317);
      X = D(X, W, V, Y, C[P + 6], j, 76029189);
      Y = D(Y, X, W, V, C[P + 9], o, 3654602809);
      V = D(V, Y, X, W, C[P + 12], m, 3873151461);
      W = D(W, V, Y, X, C[P + 15], l, 530742520);
      X = D(X, W, V, Y, C[P + 2], j, 3299628645);
      Y = t(Y, X, W, V, C[P + 0], U, 4096336452);
      V = t(V, Y, X, W, C[P + 7], T, 1126891415);
      W = t(W, V, Y, X, C[P + 14], R, 2878612391);
      X = t(X, W, V, Y, C[P + 5], O, 4237533241);
      Y = t(Y, X, W, V, C[P + 12], U, 1700485571);
      V = t(V, Y, X, W, C[P + 3], T, 2399980690);
      W = t(W, V, Y, X, C[P + 10], R, 4293915773);
      X = t(X, W, V, Y, C[P + 1], O, 2240044497);
      Y = t(Y, X, W, V, C[P + 8], U, 1873313359);
      V = t(V, Y, X, W, C[P + 15], T, 4264355552);
      W = t(W, V, Y, X, C[P + 6], R, 2734768916);
      X = t(X, W, V, Y, C[P + 13], O, 1309151649);
      Y = t(Y, X, W, V, C[P + 4], U, 4149444226);
      V = t(V, Y, X, W, C[P + 11], T, 3174756917);
      W = t(W, V, Y, X, C[P + 2], R, 718787259);
      X = t(X, W, V, Y, C[P + 9], O, 3951481745);
      Y = K(Y, h);
      X = K(X, E);
      W = K(W, v);
      V = K(V, g);
    }
    var i = B(Y) + B(X) + B(W) + B(V);
    return i.toLowerCase();
  };
  size = size || 80;
  return 'https://www.gravatar.com/avatar/' + MD5(email) + '.jpg?s=' + size + '&d=mp';
};
var getSessionStorageOrDefault = function getSessionStorageOrDefault(key, defaultValue) {
  var stored = window.sessionStorage.getItem(key);
  if (!stored) {
    return defaultValue;
  }
  return JSON.parse(stored);
};
var setSessionStorage = function setSessionStorage(key, value) {
  window.sessionStorage.setItem(key, JSON.stringify(value));
};
var getLocalStorageOrDefault = function getLocalStorageOrDefault(key, defaultValue) {
  var stored = window.localStorage.getItem(key);
  if (!stored) {
    return defaultValue;
  }
  return JSON.parse(stored);
};
var setLocalStorage = function setLocalStorage(key, value) {
  window.localStorage.setItem(key, JSON.stringify(value));
};

// export const formatDate = (string) => {
//   var options = { year: 'numeric', month: '2-digit', day: '2-digit' };
//   return string ? new Date(string).toLocaleDateString([], options) : null;
// };

var getBlob = function getBlob(b64Data) {
  var contentType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
  var sliceSize = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 512;
  var byteCharacters = atob(b64Data);
  var byteArrays = [];
  for (var offset = 0; offset < byteCharacters.length; offset += sliceSize) {
    var slice = byteCharacters.slice(offset, offset + sliceSize);
    var byteNumbers = new Array(slice.length);
    for (var i = 0; i < slice.length; i++) {
      byteNumbers[i] = slice.charCodeAt(i);
    }
    var byteArray = new Uint8Array(byteNumbers);
    byteArrays.push(byteArray);
  }
  var blob = new Blob(byteArrays, {
    type: contentType
  });
  return blob;
};
var formatStringToDate = function formatStringToDate(value) {
  return moment__default["default"](value, 'YYYY-MM-DD').utc().toDate();
};
var formatStringToDateTime = function formatStringToDateTime(value) {
  return moment__default["default"](value, 'YYYY-MM-DD HH:mm').utc().toDate();
};
var formatDateToString = function formatDateToString(value) {
  return moment__default["default"](value).utc().format('YYYY-MM-DD');
};
var formatDateTimeToString = function formatDateTimeToString(value) {
  return moment__default["default"](value).utc().format('YYYY-MM-DD HH:mm');
};
var formatDateTimeToStringWithoutUTC = function formatDateTimeToStringWithoutUTC(value) {
  return moment__default["default"](value).format('YYYY-MM-DD HH:mm');
};
var dateTimeWithFormatToString = function dateTimeWithFormatToString(value, format) {
  return moment__default["default"](value).utc().format(format);
};
var hasError = function hasError(errors, name) {
  var value = name.split('.').reduce(function (prev, key) {
    if (prev !== undefined && key in prev) {
      return prev[key];
    }
    return undefined;
  }, errors);
  return value;
};

var Input = function Input(props) {
  var _ref = React.useContext(FormContext) || {
      control: {}
    },
    control = _ref.control;
  return /*#__PURE__*/React__default["default"].createElement(CondionalControllerWrapper, {
    name: props.name,
    wrap: props.withController,
    control: control,
    defaultValue: props.defaultValue
  }, /*#__PURE__*/React__default["default"].createElement(FormItemContext.Consumer, null, function (field) {
    return /*#__PURE__*/React__default["default"].createElement(InnerInput, props);
  }));
};
function InnerInput(props) {
  var _hasError;
  var initValue = '';
  var _ref2 = React.useContext(FormContext) || {
      register: function register() {},
      control: {},
      errors: {}
    },
    errors = _ref2.errors;
  var field = React.useContext(FormItemContext) || {
    field: {}
  };
  var _useState = React.useState(initValue),
    _useState2 = _slicedToArray(_useState, 2),
    value = _useState2[0],
    setValue = _useState2[1];
  var applyValue = function applyValue(newVal) {
    if (newVal !== undefined || newVal !== null) {
      setValue(newVal);
      return newVal;
    } else {
      setValue(initValue);
      return initValue;
    }
  };
  React.useEffect(function () {
    if (props.withController) {
      applyValue(field.value);
    } else {
      applyValue(props.value);
    }
  }, [props.value, field.value, props.withController]);
  var onChange = function onChange(e) {
    var newVal = applyValue(e.target.value);
    if (props.withController) {
      field.onChange(newVal);
    }
    props.onChange(newVal);
  };
  return /*#__PURE__*/React__default["default"].createElement("div", {
    className: "p-field"
  }, props.type !== 'hidden' && /*#__PURE__*/React__default["default"].createElement("label", {
    htmlFor: props.name,
    className: utils.classNames('block', {
      'p-error': hasError(errors, props.name)
    })
  }, props.label), /*#__PURE__*/React__default["default"].createElement("div", {
    className: "p-inputgroup"
  }, props.inputGroupAddonBefore && /*#__PURE__*/React__default["default"].createElement("span", {
    className: "p-inputgroup-addon"
  }, props.inputGroupAddonBefore), /*#__PURE__*/React__default["default"].createElement(inputtext.InputText, _extends({
    type: props.type,
    disabled: props.readonly,
    id: props.name,
    value: value,
    onChange: onChange,
    step: props.step,
    style: props.style,
    placeholder: props.placeholder,
    className: utils.classNames({
      'p-invalid': hasError(errors, props.name)
    })
  }, props.customProps)), props.inputGroupAddonAfter && /*#__PURE__*/React__default["default"].createElement("span", {
    className: "p-inputgroup-addon"
  }, props.inputGroupAddonAfter)), props.type !== 'hidden' && /*#__PURE__*/React__default["default"].createElement("small", {
    style: {
      display: 'block'
    },
    className: "p-error"
  }, (_hasError = hasError(errors, props.name)) === null || _hasError === void 0 ? void 0 : _hasError.message));
}
Input.propTypes = {
  placeholder: PropTypes__default["default"].string,
  label: PropTypes__default["default"].string,
  name: PropTypes__default["default"].string.isRequired,
  withController: PropTypes__default["default"].bool.isRequired,
  onChange: PropTypes__default["default"].func,
  inputGroupAddonBefore: PropTypes__default["default"].string,
  inputGroupAddonAfter: PropTypes__default["default"].string,
  readonly: PropTypes__default["default"].bool,
  value: PropTypes__default["default"].string,
  type: PropTypes__default["default"].string,
  step: PropTypes__default["default"].string,
  defaultValue: PropTypes__default["default"].any,
  customProps: PropTypes__default["default"].object
};
Input.defaultProps = {
  readonly: false,
  type: 'text',
  step: 'any',
  onChange: function onChange() {},
  defaultValue: ''
};

var Form = function Form(props) {
  var _useForm = reactHookForm.useForm({
      resolver: yup.yupResolver(props.schema),
      defaultValues: props.defaultValues
    }),
    register = _useForm.register,
    control = _useForm.control,
    handleSubmit = _useForm.handleSubmit,
    reset = _useForm.reset,
    setValue = _useForm.setValue,
    watch = _useForm.watch,
    errors = _useForm.formState.errors;
  React.useEffect(function () {
    reset(props.defaultValues);
  }, [props.defaultValues]);
  React.useEffect(function () {
    reset();
  }, [props.reset]);
  React.useEffect(function () {
    if (Object.keys(props.values).length === 0) {
      reset();
    }
    for (var p in props.values) {
      setValue(p, props.values[p]);
    }
  }, [props.values]);
  var checkKeyDown = function checkKeyDown(e) {
    if (e.key === 'Enter') e.preventDefault();
  };

  // useEffect(() => {
  //   if (props.onChange) {
  //       props.onChange(watch());
  //   }
  // }, [watch]);

  React.useEffect(function () {
    var subscription = watch(function (data, _ref) {
      _ref.name;
        _ref.type;
      if (props.onChange) {
        props.onChange(data);
      }
    });
    return function () {
      return subscription.unsubscribe();
    };
  }, [watch]);
  return /*#__PURE__*/React__default["default"].createElement("form", {
    id: props.id,
    className: props.className,
    onSubmit: handleSubmit(props.onSubmit),
    onKeyDown: function onKeyDown(e) {
      return checkKeyDown(e);
    }
  }, /*#__PURE__*/React__default["default"].createElement(FormContext.Provider, {
    value: {
      register: register,
      control: control,
      errors: errors,
      reset: reset,
      watch: watch,
      setValue: setValue,
      handleSubmit: handleSubmit
    }
  }, props.children));
};
Form.propTypes = {
  children: PropTypes__default["default"].node.isRequired,
  onSubmit: PropTypes__default["default"].func.isRequired,
  schema: PropTypes__default["default"].object.isRequired,
  defaultValues: PropTypes__default["default"].object,
  values: PropTypes__default["default"].object,
  reset: PropTypes__default["default"].bool,
  id: PropTypes__default["default"].string,
  className: PropTypes__default["default"].string,
  onChange: PropTypes__default["default"].func
};
Form.defaultProps = {
  reset: false,
  values: {},
  defaultValues: {}
};

var Translate = function Translate(props) {
  var key = props.value ? [props.value] : [props.children];
  var data = _objectSpread2(_objectSpread2({}, props.data), {}, {
    b: function b(chunks) {
      return /*#__PURE__*/React__default["default"].createElement("b", null, chunks);
    }
  });
  return /*#__PURE__*/React__default["default"].createElement(reactIntl.FormattedMessage, {
    id: key,
    defaultMessage: key,
    values: data,
    description: ''
  });
};
Translate.propTypes = {
  value: PropTypes__namespace.string,
  data: PropTypes__namespace.object
};
Translate.defaultProps = {
  value: null,
  data: {}
};

var AjaxDropdown = function AjaxDropdown(props) {
  var _ref = React.useContext(FormContext) || {
      control: {}
    },
    control = _ref.control;
  return /*#__PURE__*/React__default["default"].createElement(CondionalControllerWrapper, {
    name: props.name,
    wrap: props.withController,
    control: control
  }, /*#__PURE__*/React__default["default"].createElement(FormItemContext.Consumer, null, function (field) {
    return /*#__PURE__*/React__default["default"].createElement(AjaxDropdownInner, props);
  }));
};
var AjaxDropdownInner = function AjaxDropdownInner(props) {
  var _hasError;
  var initValue = undefined;
  var _ref2 = React.useContext(FormContext) || {
      register: function register() {},
      control: {},
      errors: {}
    },
    errors = _ref2.errors;
  var field = React.useContext(FormItemContext) || {
    field: {}
  };
  var _useState = React.useState(initValue),
    _useState2 = _slicedToArray(_useState, 2),
    value = _useState2[0],
    setValue = _useState2[1];
  var _useState3 = React.useState([]),
    _useState4 = _slicedToArray(_useState3, 2),
    items = _useState4[0],
    setItems = _useState4[1];
  var _useState5 = React.useState(false),
    _useState6 = _slicedToArray(_useState5, 2),
    loading = _useState6[0],
    setLoading = _useState6[1];
  React.useImperativeHandle(props.innerRef, function () {
    return {
      reload: function reload() {
        load();
      }
    };
  });
  var applyValue = function applyValue(newVal) {
    if (newVal != null || newVal !== undefined) {
      setValue(newVal);
      return newVal;
    } else {
      setValue(initValue);
      return initValue;
    }
  };
  var load = function load() {
    setLoading(true);
    ajax().then(function (res) {
      setLoading(false);
      setItems(res.data.content);
    })["catch"](function (err) {
      setLoading(false);
      setItems([]);
    });
  };
  var ajax = function ajax() {
    return axios__default["default"].get(props.baseEndpoint, {
      params: {
        page: 0,
        size: props.maxResults
      },
      headers: _objectSpread2({}, props.requestHeaders)
    });
  };
  React.useEffect(function () {
    load();
  }, [props.baseEndpoint]);

  // useEffect(() => {
  //     load();
  // }, []);

  React.useEffect(function () {
    if (props.withController) {
      applyValue(field.value);
    } else {
      applyValue(props.value);
    }
  }, [props.value, field.value]);
  var change = function change(e) {
    var newVal = applyValue(e.value);
    if (props.withController) {
      field.onChange(newVal);
    }
    props.onChange(newVal);
  };
  var itemTemplate = function itemTemplate(item) {
    if (props.itemTemplate) return props.itemTemplate(item, props);
    return /*#__PURE__*/React__default["default"].createElement("div", null, item[props.nameField]);
  };
  var valueTemplate = function valueTemplate(item) {
    if (props.valueTemplate) return props.valueTemplate(item, props);
    if (item) {
      return /*#__PURE__*/React__default["default"].createElement("span", null, item ? item[props.nameField] : '');
    }
    return /*#__PURE__*/React__default["default"].createElement("span", null, props.placeholder);
  };
  return /*#__PURE__*/React__default["default"].createElement("div", {
    className: "p-field"
  }, /*#__PURE__*/React__default["default"].createElement("label", {
    htmlFor: props.name,
    className: utils.classNames('block', {
      'p-error': errors[props.name]
    })
  }, props.label), /*#__PURE__*/React__default["default"].createElement(dropdown.Dropdown, _extends({}, props.dataKey && {
    dataKey: props.dataKey
  }, {
    disabled: loading || props.readOnly,
    value: value,
    options: items,
    optionLabel: props.nameField,
    filter: true,
    showClear: true,
    style: {
      width: '100%'
    },
    filterBy: props.nameField,
    placeholder: props.placeholder,
    valueTemplate: valueTemplate,
    className: utils.classNames({
      'p-invalid': hasError(errors, props.name)
    }),
    itemTemplate: itemTemplate,
    onChange: change,
    panelStyle: {
      maxWidth: '250px'
    },
    resetFilterOnHide: true
  }, props.customProps)), /*#__PURE__*/React__default["default"].createElement("small", {
    className: "p-error",
    style: {
      display: 'block'
    }
  }, (_hasError = hasError(errors, props.name)) === null || _hasError === void 0 ? void 0 : _hasError.message));
};
AjaxDropdown.propTypes = {
  baseEndpoint: PropTypes__default["default"].string.isRequired,
  itemTemplate: PropTypes__default["default"].func,
  valueTemplate: PropTypes__default["default"].func,
  maxResults: PropTypes__default["default"].number,
  onChange: PropTypes__default["default"].func,
  nameField: PropTypes__default["default"].string.isRequired,
  placeholder: PropTypes__default["default"].any,
  withController: PropTypes__default["default"].bool.isRequired,
  name: PropTypes__default["default"].string.isRequired,
  label: PropTypes__default["default"].string,
  cache: PropTypes__default["default"].bool,
  requestHeaders: PropTypes__default["default"].object,
  requestParams: PropTypes__default["default"].object,
  readOnly: PropTypes__default["default"].bool,
  innerRef: PropTypes__default["default"].object,
  dataKey: PropTypes__default["default"].string,
  customProps: PropTypes__default["default"].object
};
AjaxDropdown.defaultProps = {
  baseEndpoint: '/',
  readOnly: false,
  maxResults: 20,
  value: null,
  innerRef: null,
  withController: true,
  placeholder: /*#__PURE__*/React__default["default"].createElement(Translate, {
    value: "generic.selectplaceholder"
  }),
  cache: false,
  onChange: function onChange() {},
  dataKey: null
};

function useTranslations() {
  var intl = reactIntl.useIntl();
  var _t = function _t(key, data) {
    data = _objectSpread2(_objectSpread2({}, data), {}, {
      b: function b(chunks) {
        return /*#__PURE__*/React__default["default"].createElement("b", null, chunks);
      }
    });
    return intl.formatMessage({
      id: key,
      defaultMessage: key
    }, data);
  };
  var _tRequired = function _tRequired(key, data) {
    return _t(key, data) + ' *';
  };
  return {
    _t: _t,
    _tRequired: _tRequired
  };
}

var AjaxPickList = function AjaxPickList(props) {
  var _ref = React.useContext(FormContext) || {
      control: {}
    },
    control = _ref.control;
  return /*#__PURE__*/React__default["default"].createElement(CondionalControllerWrapper, {
    name: props.name,
    wrap: props.withController,
    control: control
  }, /*#__PURE__*/React__default["default"].createElement(FormItemContext.Consumer, null, function (field) {
    return /*#__PURE__*/React__default["default"].createElement(AjaxPickListInner, props);
  }));
};
var AjaxPickListInner = function AjaxPickListInner(props) {
  var _hasError;
  var initValue = [];
  var _ref2 = React.useContext(FormContext) || {
      register: function register() {},
      control: {},
      errors: {}
    },
    errors = _ref2.errors;
  var field = React.useContext(FormItemContext) || {
    field: {}
  };
  var _useState = React.useState(initValue),
    _useState2 = _slicedToArray(_useState, 2),
    value = _useState2[0],
    setValue = _useState2[1];
  var _useState3 = React.useState(''),
    _useState4 = _slicedToArray(_useState3, 2),
    searchValue = _useState4[0],
    setSearchValue = _useState4[1];
  var _useState5 = React.useState([]),
    _useState6 = _slicedToArray(_useState5, 2),
    serverValues = _useState6[0],
    setServerValues = _useState6[1];
  var _useTranslations = useTranslations(),
    _t = _useTranslations._t;
  var _useState7 = React.useState(false),
    _useState8 = _slicedToArray(_useState7, 2),
    loading = _useState8[0],
    setLoading = _useState8[1];
  var _useState9 = React.useState([]),
    _useState10 = _slicedToArray(_useState9, 2),
    source = _useState10[0],
    setSource = _useState10[1];
  var applyValue = function applyValue(newVal) {
    if (Array.isArray(newVal)) {
      setValue(newVal);
      return newVal;
    } else {
      setValue(initValue);
      return initValue;
    }
  };
  var itemTemplate = function itemTemplate(item) {
    if (props.itemTemplate) return props.itemTemplate(item, props);
    return /*#__PURE__*/React__default["default"].createElement("div", {
      key: item.id
    }, " ", item[props.nameField]);
  };
  var filterValues = function filterValues(query, items) {
    return items.filter(function (v) {
      return v.name.toLowerCase().includes(query.toLowerCase());
    });
  };
  var computeLeft = function computeLeft(left, right) {
    //return serverValues;
    return left.filter(function (v) {
      return !right.some(function (v2) {
        return v.id === v2.id;
      });
    });
  };
  var evaluateList = function evaluateList() {
    var left = [];
    if (searchValue.length > 0) {
      left = filterValues(searchValue, serverValues);
    } else {
      left = serverValues;
    }
    left = computeLeft(left, value);
    setSource(left);
  };
  var change = function change(e) {
    var newVal = applyValue(e.target);
    if (props.withController) {
      field.onChange(newVal);
    }
    props.onChange(newVal);
  };
  React.useEffect(function () {
    evaluateList();
  }, [serverValues, value, searchValue]);
  React.useEffect(function () {
    if (props.withController) {
      applyValue(field.value);
    } else {
      applyValue(props.value);
    }
  }, [props.value, field.value]);
  React.useEffect(function () {
    setLoading(true);
    axios__default["default"].get(props.baseEndpoint, {
      params: _objectSpread2({
        page: 0,
        size: props.maxResults
      }, props.requestParams),
      headers: _objectSpread2({}, props.requestHeaders)
    }).then(function (res) {
      setLoading(false);
      props.onLoadedData(res.data.content);
      setServerValues(res.data.content);
      if (props.value === null) {
        setValue(initValue);
      }
    })["catch"](function (err) {
      setLoading(false);
      setSource([]);
      setValue([]);
    });
  }, [props.baseEndpoint]);
  return /*#__PURE__*/React__default["default"].createElement("div", {
    className: "p-field"
  }, /*#__PURE__*/React__default["default"].createElement("label", {
    htmlFor: props.name,
    className: utils.classNames('p-d-block', {
      'p-error': hasError(errors, props.name)
    }),
    style: {
      width: '90%'
    }
  }, props.label), /*#__PURE__*/React__default["default"].createElement("div", {
    style: {
      border: hasError(errors, props.name) ? 'solid 1px #f44336' : props.border ? 'solid 1px #ccc' : 'none'
    }
  }, /*#__PURE__*/React__default["default"].createElement(blockui.BlockUI, {
    blocked: loading,
    template: /*#__PURE__*/React__default["default"].createElement("i", {
      className: "pi pi-spin pi-spinner",
      style: {
        fontSize: '2rem'
      }
    })
  }, props.searchable && /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, /*#__PURE__*/React__default["default"].createElement("div", {
    className: "p-picklist p-picklist-search",
    style: {
      marginTop: '2rem'
    }
  }, /*#__PURE__*/React__default["default"].createElement("div", {
    className: "p-picklist-buttons",
    style: {
      paddingTop: '0px',
      paddingBottom: '0px'
    }
  }, /*#__PURE__*/React__default["default"].createElement("button", {
    type: "button",
    className: "p-button p-button-icon-only",
    disabled: true
  })), /*#__PURE__*/React__default["default"].createElement("div", {
    className: "p-picklist-list-wrapper p-picklist-source-wrapper"
  }, /*#__PURE__*/React__default["default"].createElement("div", {
    className: "p-inputgroup"
  }, /*#__PURE__*/React__default["default"].createElement(inputtext.InputText, {
    style: {
      margin: '0',
      width: '100%'
    },
    value: searchValue,
    onChange: function onChange(e) {
      return setSearchValue(e.target.value);
    },
    placeholder: props.searchplaceholder
  }), /*#__PURE__*/React__default["default"].createElement("span", {
    className: "p-inputgroup-addon"
  }, /*#__PURE__*/React__default["default"].createElement("i", {
    className: "pi pi-search"
  })))), /*#__PURE__*/React__default["default"].createElement("div", {
    className: "p-picklist-buttons",
    style: {
      paddingTop: '0px',
      paddingBottom: '0px'
    }
  }, /*#__PURE__*/React__default["default"].createElement("button", {
    type: "button",
    className: "p-button p-button-icon-only",
    disabled: true
  })), /*#__PURE__*/React__default["default"].createElement("div", {
    className: "p-picklist-list-wrapper p-picklist-target-wrapper"
  }), /*#__PURE__*/React__default["default"].createElement("div", {
    className: "p-picklist-buttons",
    style: {
      paddingTop: '0px',
      paddingBottom: '0px'
    }
  }, /*#__PURE__*/React__default["default"].createElement("button", {
    type: "button",
    className: "p-button p-button-icon-only",
    disabled: true
  })))), /*#__PURE__*/React__default["default"].createElement(picklist.PickList, {
    source: source,
    target: value,
    dataKey: props.dataKey,
    sourceHeader: _t('generic.picklist.available-obj') + '  ' + props.available + ' (' + source.length + ')',
    targetHeader: _t('generic.picklist.selected-obj') + '  ' + props.selected + ' (' + value.length + ')',
    itemTemplate: itemTemplate,
    sourceStyle: {
      height: '342px'
    },
    targetStyle: {
      height: '342px'
    },
    className: utils.classNames({
      'p-invalid': hasError(errors, props.name)
    }),
    onChange: change,
    onLoadedData: props.onLoadedData
  }))), /*#__PURE__*/React__default["default"].createElement("small", {
    className: "p-error",
    style: {
      display: 'block'
    }
  }, (_hasError = hasError(errors, props.name)) === null || _hasError === void 0 ? void 0 : _hasError.message));
};
AjaxPickList.propTypes = {
  baseEndpoint: PropTypes__default["default"].string.isRequired,
  itemTemplate: PropTypes__default["default"].func,
  valueTemplate: PropTypes__default["default"].func,
  maxResults: PropTypes__default["default"].number,
  onChange: PropTypes__default["default"].func,
  nameField: PropTypes__default["default"].string.isRequired,
  placeholder: PropTypes__default["default"].string,
  withController: PropTypes__default["default"].bool.isRequired,
  name: PropTypes__default["default"].string.isRequired,
  label: PropTypes__default["default"].string,
  requestHeaders: PropTypes__default["default"].object,
  requestParams: PropTypes__default["default"].object,
  value: PropTypes__default["default"].array,
  searchable: PropTypes__default["default"].bool,
  available: PropTypes__default["default"].string,
  selected: PropTypes__default["default"].string,
  border: PropTypes__default["default"].bool,
  onLoadedData: PropTypes__default["default"].func,
  dataKey: PropTypes__default["default"].string.isRequired
};
AjaxPickList.defaultProps = {
  baseEndpoint: '/',
  maxResults: 20,
  value: null,
  withController: true,
  searchplaceholder: 'Search...',
  onChange: function onChange() {},
  onLoadedData: function onLoadedData() {},
  available: '',
  selected: '',
  requestParams: {},
  border: true,
  dataKey: 'name'
};

var AjaxFullPickList = function AjaxFullPickList(props) {
  var _ref = React.useContext(FormContext) || {
      control: {}
    },
    control = _ref.control;
  return /*#__PURE__*/React__default["default"].createElement(CondionalControllerWrapper, {
    name: props.name,
    wrap: props.withController,
    control: control
  }, /*#__PURE__*/React__default["default"].createElement(FormItemContext.Consumer, null, function (field) {
    return /*#__PURE__*/React__default["default"].createElement(AjaxFullPickListInner, props);
  }));
};
var AjaxFullPickListInner = function AjaxFullPickListInner(props) {
  var _hasError;
  var initValue = [];
  var _ref2 = React.useContext(FormContext) || {
      register: function register() {},
      control: {},
      errors: {}
    },
    errors = _ref2.errors;
  var field = React.useContext(FormItemContext) || {
    field: {}
  };
  var _useState = React.useState(initValue),
    _useState2 = _slicedToArray(_useState, 2),
    value = _useState2[0],
    setValue = _useState2[1];
  var _useState3 = React.useState(''),
    _useState4 = _slicedToArray(_useState3, 2),
    searchValue = _useState4[0];
    _useState4[1];
  var _useState5 = React.useState([]),
    _useState6 = _slicedToArray(_useState5, 2),
    serverValues = _useState6[0],
    setServerValues = _useState6[1];
  var _useTranslations = useTranslations();
    _useTranslations._t;
  var _useState7 = React.useState(false),
    _useState8 = _slicedToArray(_useState7, 2);
    _useState8[0];
    var setLoading = _useState8[1];
  var _useState9 = React.useState([]),
    _useState10 = _slicedToArray(_useState9, 2),
    source = _useState10[0],
    setSource = _useState10[1];
  var applyValue = function applyValue(newVal) {
    if (Array.isArray(newVal)) {
      setValue(newVal);
      return newVal;
    } else {
      setValue(initValue);
      return initValue;
    }
  };
  var itemTemplate = function itemTemplate(item) {
    if (props.itemTemplate) return props.itemTemplate(item, props);
    return /*#__PURE__*/React__default["default"].createElement("div", {
      key: item.id
    }, " ", item[props.nameField]);
  };
  var filterValues = function filterValues(query, items) {
    return items.filter(function (v) {
      return v.name.toLowerCase().includes(query.toLowerCase());
    });
  };
  var computeLeft = function computeLeft(left, right) {
    //return serverValues;
    return left.filter(function (v) {
      return !right.some(function (v2) {
        return v[props.dataKey] === v2[props.dataKey];
      });
    });
  };
  var evaluateList = function evaluateList() {
    var left = [];
    if (searchValue.length > 0) {
      left = filterValues(searchValue, serverValues);
    } else {
      left = serverValues;
    }
    left = computeLeft(left, value);
    setSource(left);
  };
  var change = function change(e) {
    var newVal = applyValue(e.target);
    setSource(e.source);
    if (props.withController) {
      field.onChange(newVal);
    }
    props.onChange(newVal);
  };
  React.useEffect(function () {
    evaluateList();
  }, [serverValues, value, searchValue]);
  React.useEffect(function () {
    if (props.withController) {
      applyValue(field.value);
    } else {
      applyValue(props.value);
    }
  }, [props.value, field.value]);
  React.useEffect(function () {
    setLoading(true);
    axios__default["default"].get(props.sourceEndpoint, {
      params: _objectSpread2({
        page: 0,
        size: props.maxResults
      }, props.requestParams),
      headers: _objectSpread2({}, props.requestHeaders)
    }).then(function (res) {
      setLoading(false);
      props.onLoadedData(res.data.content);
      setServerValues(res.data.content);
    })["catch"](function (err) {
      setLoading(false);
      setSource([]);
      setValue([]);
      props.onErrorLoading(err);
    });
  }, [props.sourceEndpoint]);
  return /*#__PURE__*/React__default["default"].createElement("div", {
    className: "p-field"
  }, /*#__PURE__*/React__default["default"].createElement("label", {
    htmlFor: props.name,
    className: utils.classNames('p-d-block', {
      'p-error': hasError(errors, props.name)
    }),
    style: {
      width: '90%'
    }
  }, props.label), /*#__PURE__*/React__default["default"].createElement("div", {
    style: {
      border: hasError(errors, props.name) ? 'solid 1px #f44336' : props.border ? 'solid 1px #ccc' : 'none'
    }
  }, /*#__PURE__*/React__default["default"].createElement("div", null, /*#__PURE__*/React__default["default"].createElement(picklist.PickList, _extends({
    source: source,
    target: value,
    onChange: change,
    itemTemplate: itemTemplate
  }, props.filter && {
    filter: true,
    filterBy: props.nameField
  }, {
    sourceHeader: props.sourceHeader,
    targetHeader: props.targetHeader,
    sourceFilterPlaceholder: props.searchplaceholder,
    targetFilterPlaceholder: props.searchplaceholder,
    metaKeySelection: true
  }, props.customProps)))), /*#__PURE__*/React__default["default"].createElement("small", {
    className: "p-error",
    style: {
      display: 'block'
    }
  }, (_hasError = hasError(errors, props.name)) === null || _hasError === void 0 ? void 0 : _hasError.message));
};
AjaxFullPickList.propTypes = {
  sourceEndpoint: PropTypes__default["default"].string.isRequired,
  itemTemplate: PropTypes__default["default"].func,
  maxResults: PropTypes__default["default"].number,
  onChange: PropTypes__default["default"].func,
  nameField: PropTypes__default["default"].string.isRequired,
  withController: PropTypes__default["default"].bool.isRequired,
  filter: PropTypes__default["default"].bool,
  name: PropTypes__default["default"].string.isRequired,
  label: PropTypes__default["default"].string,
  sourceHeader: PropTypes__default["default"].string,
  targetHeader: PropTypes__default["default"].string,
  requestHeaders: PropTypes__default["default"].object,
  requestParams: PropTypes__default["default"].object,
  value: PropTypes__default["default"].array,
  border: PropTypes__default["default"].bool,
  onLoadedData: PropTypes__default["default"].func,
  onErrorLoading: PropTypes__default["default"].func,
  dataKey: PropTypes__default["default"].string.isRequired,
  customProps: PropTypes__default["default"].object
};
AjaxFullPickList.defaultProps = {
  sourceEndpoint: '/',
  maxResults: 20,
  value: null,
  withController: true,
  filter: false,
  sourceHeader: 'Available',
  targetHeader: 'Selected',
  searchplaceholder: 'Search...',
  onChange: function onChange() {},
  onLoadedData: function onLoadedData() {},
  onErrorLoading: function onErrorLoading() {},
  available: '',
  requestParams: {},
  border: true,
  dataKey: 'id'
};

var AjaxDropdownMultipleSelect = function AjaxDropdownMultipleSelect(props) {
  var _ref = React.useContext(FormContext) || {
      control: {}
    },
    control = _ref.control;
  return /*#__PURE__*/React__default["default"].createElement(CondionalControllerWrapper, {
    name: props.name,
    wrap: props.withController,
    control: control
  }, /*#__PURE__*/React__default["default"].createElement(FormItemContext.Consumer, null, function (field) {
    return /*#__PURE__*/React__default["default"].createElement(AjaxDropdownMultipleSelectInner, props);