starh-comp-common/dist/index.es.js

Libreria di componenti React specifica per la piattaforma StarH.

import React, { useContext, useState, useEffect, useImperativeHandle, useRef, useReducer } from 'react';
import { InputText } from 'primereact/inputtext';
import { classNames } from 'primereact/utils';
import * as PropTypes from 'prop-types';
import PropTypes__default from 'prop-types';
import { Controller, useForm, useFieldArray } from 'react-hook-form';
import moment from 'moment';
import { yupResolver } from '@hookform/resolvers/yup';
import { Dropdown } from 'primereact/dropdown';
import axios from 'axios';
import { FormattedMessage, useIntl } from 'react-intl';
import { BlockUI } from 'primereact/blockui';
import { PickList } from 'primereact/picklist';
import { MultiSelect } from 'primereact/multiselect';
import { Chips as Chips$1 } from 'primereact/chips';
import { Calendar } from 'primereact/calendar';
import { Button } from 'primereact/button';
import { Checkbox } from 'primereact/checkbox';
import { InputNumber } from 'primereact/inputnumber';
import { Password as Password$1 } from 'primereact/password';
import { InputSwitch } from 'primereact/inputswitch';
import { InputTextarea } from 'primereact/inputtextarea';
import { TriStateCheckbox } from 'primereact/tristatecheckbox';
import { AutoComplete } from 'primereact/autocomplete';
import _ from 'lodash';
import { FileUpload } from 'primereact/fileupload';
import { DataTable } from 'primereact/datatable';
import { Column } from 'primereact/column';
import { Sidebar } from 'primereact/sidebar';
import { OverlayPanel } from 'primereact/overlaypanel';
import { TabView, TabPanel } from 'primereact/tabview';
import { Dialog } from 'primereact/dialog';
import { MultiStateCheckbox } from 'primereact/multistatecheckbox';
import { SplitButton } from 'primereact/splitbutton';
import { ScrollPanel } from 'primereact/scrollpanel';
import * as yup from 'yup';
import { Panel } from 'primereact/panel';
import { useHistory } from 'react-router-dom';
import { SelectButton } from 'primereact/selectbutton';
export * from './bundle.css';

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.createContext(null);
var FormItemContext = /*#__PURE__*/React.createContext(null);

var CondionalControllerWrapper = function CondionalControllerWrapper(props) {
  if (props.wrap) {
    return /*#__PURE__*/React.createElement(Controller, {
      control: props.control,
      name: props.name,
      defaultValue: props.defaultValue,
      render: function render(_ref) {
        var field = _ref.field;
        return /*#__PURE__*/React.createElement(FormItemContext.Provider, {
          value: field
        }, props.children);
      }
    });
  } else {
    return /*#__PURE__*/React.createElement(React.Fragment, null, props.children);
  }
};
CondionalControllerWrapper.propTypes = {
  wrap: PropTypes__default.bool.isRequired,
  control: PropTypes__default.object,
  name: PropTypes__default.string.isRequired,
  defaultValue: PropTypes__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(value, 'YYYY-MM-DD').utc().toDate();
};
var formatStringToDateTime = function formatStringToDateTime(value) {
  return moment(value, 'YYYY-MM-DD HH:mm').utc().toDate();
};
var formatDateToString = function formatDateToString(value) {
  return moment(value).utc().format('YYYY-MM-DD');
};
var formatDateTimeToString = function formatDateTimeToString(value) {
  return moment(value).utc().format('YYYY-MM-DD HH:mm');
};
var formatDateTimeToStringWithoutUTC = function formatDateTimeToStringWithoutUTC(value) {
  return moment(value).format('YYYY-MM-DD HH:mm');
};
var dateTimeWithFormatToString = function dateTimeWithFormatToString(value, format) {
  return moment(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 = useContext(FormContext) || {
      control: {}
    },
    control = _ref.control;
  return /*#__PURE__*/React.createElement(CondionalControllerWrapper, {
    name: props.name,
    wrap: props.withController,
    control: control,
    defaultValue: props.defaultValue
  }, /*#__PURE__*/React.createElement(FormItemContext.Consumer, null, function (field) {
    return /*#__PURE__*/React.createElement(InnerInput, props);
  }));
};
function InnerInput(props) {
  var _hasError;
  var initValue = '';
  var _ref2 = useContext(FormContext) || {
      register: function register() {},
      control: {},
      errors: {}
    },
    errors = _ref2.errors;
  var field = useContext(FormItemContext) || {
    field: {}
  };
  var _useState = 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;
    }
  };
  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.createElement("div", {
    className: "p-field"
  }, props.type !== 'hidden' && /*#__PURE__*/React.createElement("label", {
    htmlFor: props.name,
    className: classNames('block', {
      'p-error': hasError(errors, props.name)
    })
  }, props.label), /*#__PURE__*/React.createElement("div", {
    className: "p-inputgroup"
  }, props.inputGroupAddonBefore && /*#__PURE__*/React.createElement("span", {
    className: "p-inputgroup-addon"
  }, props.inputGroupAddonBefore), /*#__PURE__*/React.createElement(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: classNames({
      'p-invalid': hasError(errors, props.name)
    })
  }, props.customProps)), props.inputGroupAddonAfter && /*#__PURE__*/React.createElement("span", {
    className: "p-inputgroup-addon"
  }, props.inputGroupAddonAfter)), props.type !== 'hidden' && /*#__PURE__*/React.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.string,
  label: PropTypes__default.string,
  name: PropTypes__default.string.isRequired,
  withController: PropTypes__default.bool.isRequired,
  onChange: PropTypes__default.func,
  inputGroupAddonBefore: PropTypes__default.string,
  inputGroupAddonAfter: PropTypes__default.string,
  readonly: PropTypes__default.bool,
  value: PropTypes__default.string,
  type: PropTypes__default.string,
  step: PropTypes__default.string,
  defaultValue: PropTypes__default.any,
  customProps: PropTypes__default.object
};
Input.defaultProps = {
  readonly: false,
  type: 'text',
  step: 'any',
  onChange: function onChange() {},
  defaultValue: ''
};

var Form = function Form(props) {
  var _useForm = useForm({
      resolver: 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;
  useEffect(function () {
    reset(props.defaultValues);
  }, [props.defaultValues]);
  useEffect(function () {
    reset();
  }, [props.reset]);
  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]);

  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.createElement("form", {
    id: props.id,
    className: props.className,
    onSubmit: handleSubmit(props.onSubmit),
    onKeyDown: function onKeyDown(e) {
      return checkKeyDown(e);
    }
  }, /*#__PURE__*/React.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.node.isRequired,
  onSubmit: PropTypes__default.func.isRequired,
  schema: PropTypes__default.object.isRequired,
  defaultValues: PropTypes__default.object,
  values: PropTypes__default.object,
  reset: PropTypes__default.bool,
  id: PropTypes__default.string,
  className: PropTypes__default.string,
  onChange: PropTypes__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.createElement("b", null, chunks);
    }
  });
  return /*#__PURE__*/React.createElement(FormattedMessage, {
    id: key,
    defaultMessage: key,
    values: data,
    description: ''
  });
};
Translate.propTypes = {
  value: PropTypes.string,
  data: PropTypes.object
};
Translate.defaultProps = {
  value: null,
  data: {}
};

var AjaxDropdown = function AjaxDropdown(props) {
  var _ref = useContext(FormContext) || {
      control: {}
    },
    control = _ref.control;
  return /*#__PURE__*/React.createElement(CondionalControllerWrapper, {
    name: props.name,
    wrap: props.withController,
    control: control
  }, /*#__PURE__*/React.createElement(FormItemContext.Consumer, null, function (field) {
    return /*#__PURE__*/React.createElement(AjaxDropdownInner, props);
  }));
};
var AjaxDropdownInner = function AjaxDropdownInner(props) {
  var _hasError;
  var initValue = undefined;
  var _ref2 = useContext(FormContext) || {
      register: function register() {},
      control: {},
      errors: {}
    },
    errors = _ref2.errors;
  var field = useContext(FormItemContext) || {
    field: {}
  };
  var _useState = useState(initValue),
    _useState2 = _slicedToArray(_useState, 2),
    value = _useState2[0],
    setValue = _useState2[1];
  var _useState3 = useState([]),
    _useState4 = _slicedToArray(_useState3, 2),
    items = _useState4[0],
    setItems = _useState4[1];
  var _useState5 = useState(false),
    _useState6 = _slicedToArray(_useState5, 2),
    loading = _useState6[0],
    setLoading = _useState6[1];
  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.get(props.baseEndpoint, {
      params: {
        page: 0,
        size: props.maxResults
      },
      headers: _objectSpread2({}, props.requestHeaders)
    });
  };
  useEffect(function () {
    load();
  }, [props.baseEndpoint]);

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

  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.createElement("div", null, item[props.nameField]);
  };
  var valueTemplate = function valueTemplate(item) {
    if (props.valueTemplate) return props.valueTemplate(item, props);
    if (item) {
      return /*#__PURE__*/React.createElement("span", null, item ? item[props.nameField] : '');
    }
    return /*#__PURE__*/React.createElement("span", null, props.placeholder);
  };
  return /*#__PURE__*/React.createElement("div", {
    className: "p-field"
  }, /*#__PURE__*/React.createElement("label", {
    htmlFor: props.name,
    className: classNames('block', {
      'p-error': errors[props.name]
    })
  }, props.label), /*#__PURE__*/React.createElement(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: classNames({
      'p-invalid': hasError(errors, props.name)
    }),
    itemTemplate: itemTemplate,
    onChange: change,
    panelStyle: {
      maxWidth: '250px'
    },
    resetFilterOnHide: true
  }, props.customProps)), /*#__PURE__*/React.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.string.isRequired,
  itemTemplate: PropTypes__default.func,
  valueTemplate: PropTypes__default.func,
  maxResults: PropTypes__default.number,
  onChange: PropTypes__default.func,
  nameField: PropTypes__default.string.isRequired,
  placeholder: PropTypes__default.any,
  withController: PropTypes__default.bool.isRequired,
  name: PropTypes__default.string.isRequired,
  label: PropTypes__default.string,
  cache: PropTypes__default.bool,
  requestHeaders: PropTypes__default.object,
  requestParams: PropTypes__default.object,
  readOnly: PropTypes__default.bool,
  innerRef: PropTypes__default.object,
  dataKey: PropTypes__default.string,
  customProps: PropTypes__default.object
};
AjaxDropdown.defaultProps = {
  baseEndpoint: '/',
  readOnly: false,
  maxResults: 20,
  value: null,
  innerRef: null,
  withController: true,
  placeholder: /*#__PURE__*/React.createElement(Translate, {
    value: "generic.selectplaceholder"
  }),
  cache: false,
  onChange: function onChange() {},
  dataKey: null
};

function useTranslations() {
  var intl = useIntl();
  var _t = function _t(key, data) {
    data = _objectSpread2(_objectSpread2({}, data), {}, {
      b: function b(chunks) {
        return /*#__PURE__*/React.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 = useContext(FormContext) || {
      control: {}
    },
    control = _ref.control;
  return /*#__PURE__*/React.createElement(CondionalControllerWrapper, {
    name: props.name,
    wrap: props.withController,
    control: control
  }, /*#__PURE__*/React.createElement(FormItemContext.Consumer, null, function (field) {
    return /*#__PURE__*/React.createElement(AjaxPickListInner, props);
  }));
};
var AjaxPickListInner = function AjaxPickListInner(props) {
  var _hasError;
  var initValue = [];
  var _ref2 = useContext(FormContext) || {
      register: function register() {},
      control: {},
      errors: {}
    },
    errors = _ref2.errors;
  var field = useContext(FormItemContext) || {
    field: {}
  };
  var _useState = useState(initValue),
    _useState2 = _slicedToArray(_useState, 2),
    value = _useState2[0],
    setValue = _useState2[1];
  var _useState3 = useState(''),
    _useState4 = _slicedToArray(_useState3, 2),
    searchValue = _useState4[0],
    setSearchValue = _useState4[1];
  var _useState5 = useState([]),
    _useState6 = _slicedToArray(_useState5, 2),
    serverValues = _useState6[0],
    setServerValues = _useState6[1];
  var _useTranslations = useTranslations(),
    _t = _useTranslations._t;
  var _useState7 = useState(false),
    _useState8 = _slicedToArray(_useState7, 2),
    loading = _useState8[0],
    setLoading = _useState8[1];
  var _useState9 = 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.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);
  };
  useEffect(function () {
    evaluateList();
  }, [serverValues, value, searchValue]);
  useEffect(function () {
    if (props.withController) {
      applyValue(field.value);
    } else {
      applyValue(props.value);
    }
  }, [props.value, field.value]);
  useEffect(function () {
    setLoading(true);
    axios.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.createElement("div", {
    className: "p-field"
  }, /*#__PURE__*/React.createElement("label", {
    htmlFor: props.name,
    className: classNames('p-d-block', {
      'p-error': hasError(errors, props.name)
    }),
    style: {
      width: '90%'
    }
  }, props.label), /*#__PURE__*/React.createElement("div", {
    style: {
      border: hasError(errors, props.name) ? 'solid 1px #f44336' : props.border ? 'solid 1px #ccc' : 'none'
    }
  }, /*#__PURE__*/React.createElement(BlockUI, {
    blocked: loading,
    template: /*#__PURE__*/React.createElement("i", {
      className: "pi pi-spin pi-spinner",
      style: {
        fontSize: '2rem'
      }
    })
  }, props.searchable && /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
    className: "p-picklist p-picklist-search",
    style: {
      marginTop: '2rem'
    }
  }, /*#__PURE__*/React.createElement("div", {
    className: "p-picklist-buttons",
    style: {
      paddingTop: '0px',
      paddingBottom: '0px'
    }
  }, /*#__PURE__*/React.createElement("button", {
    type: "button",
    className: "p-button p-button-icon-only",
    disabled: true
  })), /*#__PURE__*/React.createElement("div", {
    className: "p-picklist-list-wrapper p-picklist-source-wrapper"
  }, /*#__PURE__*/React.createElement("div", {
    className: "p-inputgroup"
  }, /*#__PURE__*/React.createElement(InputText, {
    style: {
      margin: '0',
      width: '100%'
    },
    value: searchValue,
    onChange: function onChange(e) {
      return setSearchValue(e.target.value);
    },
    placeholder: props.searchplaceholder
  }), /*#__PURE__*/React.createElement("span", {
    className: "p-inputgroup-addon"
  }, /*#__PURE__*/React.createElement("i", {
    className: "pi pi-search"
  })))), /*#__PURE__*/React.createElement("div", {
    className: "p-picklist-buttons",
    style: {
      paddingTop: '0px',
      paddingBottom: '0px'
    }
  }, /*#__PURE__*/React.createElement("button", {
    type: "button",
    className: "p-button p-button-icon-only",
    disabled: true
  })), /*#__PURE__*/React.createElement("div", {
    className: "p-picklist-list-wrapper p-picklist-target-wrapper"
  }), /*#__PURE__*/React.createElement("div", {
    className: "p-picklist-buttons",
    style: {
      paddingTop: '0px',
      paddingBottom: '0px'
    }
  }, /*#__PURE__*/React.createElement("button", {
    type: "button",
    className: "p-button p-button-icon-only",
    disabled: true
  })))), /*#__PURE__*/React.createElement(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: classNames({
      'p-invalid': hasError(errors, props.name)
    }),
    onChange: change,
    onLoadedData: props.onLoadedData
  }))), /*#__PURE__*/React.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.string.isRequired,
  itemTemplate: PropTypes__default.func,
  valueTemplate: PropTypes__default.func,
  maxResults: PropTypes__default.number,
  onChange: PropTypes__default.func,
  nameField: PropTypes__default.string.isRequired,
  placeholder: PropTypes__default.string,
  withController: PropTypes__default.bool.isRequired,
  name: PropTypes__default.string.isRequired,
  label: PropTypes__default.string,
  requestHeaders: PropTypes__default.object,
  requestParams: PropTypes__default.object,
  value: PropTypes__default.array,
  searchable: PropTypes__default.bool,
  available: PropTypes__default.string,
  selected: PropTypes__default.string,
  border: PropTypes__default.bool,
  onLoadedData: PropTypes__default.func,
  dataKey: PropTypes__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 = useContext(FormContext) || {
      control: {}
    },
    control = _ref.control;
  return /*#__PURE__*/React.createElement(CondionalControllerWrapper, {
    name: props.name,
    wrap: props.withController,
    control: control
  }, /*#__PURE__*/React.createElement(FormItemContext.Consumer, null, function (field) {
    return /*#__PURE__*/React.createElement(AjaxFullPickListInner, props);
  }));
};
var AjaxFullPickListInner = function AjaxFullPickListInner(props) {
  var _hasError;
  var initValue = [];
  var _ref2 = useContext(FormContext) || {
      register: function register() {},
      control: {},
      errors: {}
    },
    errors = _ref2.errors;
  var field = useContext(FormItemContext) || {
    field: {}
  };
  var _useState = useState(initValue),
    _useState2 = _slicedToArray(_useState, 2),
    value = _useState2[0],
    setValue = _useState2[1];
  var _useState3 = useState(''),
    _useState4 = _slicedToArray(_useState3, 2),
    searchValue = _useState4[0];
    _useState4[1];
  var _useState5 = useState([]),
    _useState6 = _slicedToArray(_useState5, 2),
    serverValues = _useState6[0],
    setServerValues = _useState6[1];
  var _useTranslations = useTranslations();
    _useTranslations._t;
  var _useState7 = useState(false),
    _useState8 = _slicedToArray(_useState7, 2);
    _useState8[0];
    var setLoading = _useState8[1];
  var _useState9 = 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.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);
  };
  useEffect(function () {
    evaluateList();
  }, [serverValues, value, searchValue]);
  useEffect(function () {
    if (props.withController) {
      applyValue(field.value);
    } else {
      applyValue(props.value);
    }
  }, [props.value, field.value]);
  useEffect(function () {
    setLoading(true);
    axios.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.createElement("div", {
    className: "p-field"
  }, /*#__PURE__*/React.createElement("label", {
    htmlFor: props.name,
    className: classNames('p-d-block', {
      'p-error': hasError(errors, props.name)
    }),
    style: {
      width: '90%'
    }
  }, props.label), /*#__PURE__*/React.createElement("div", {
    style: {
      border: hasError(errors, props.name) ? 'solid 1px #f44336' : props.border ? 'solid 1px #ccc' : 'none'
    }
  }, /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(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.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.string.isRequired,
  itemTemplate: PropTypes__default.func,
  maxResults: PropTypes__default.number,
  onChange: PropTypes__default.func,
  nameField: PropTypes__default.string.isRequired,
  withController: PropTypes__default.bool.isRequired,
  filter: PropTypes__default.bool,
  name: PropTypes__default.string.isRequired,
  label: PropTypes__default.string,
  sourceHeader: PropTypes__default.string,
  targetHeader: PropTypes__default.string,
  requestHeaders: PropTypes__default.object,
  requestParams: PropTypes__default.object,
  value: PropTypes__default.array,
  border: PropTypes__default.bool,
  onLoadedData: PropTypes__default.func,
  onErrorLoading: PropTypes__default.func,
  dataKey: PropTypes__default.string.isRequired,
  customProps: PropTypes__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 = useContext(FormContext) || {
      control: {}
    },
    control = _ref.control;
  return /*#__PURE__*/React.createElement(CondionalControllerWrapper, {
    name: props.name,
    wrap: props.withController,
    control: control
  }, /*#__PURE__*/React.createElement(FormItemContext.Consumer, null, function (field) {
    return /*#__PURE__*/React.createElement(AjaxDropdownMultipleSelectInner, props);
  }));
};
var AjaxDropdownMultipleSelectInner = function AjaxDropdownMultipleSelectInner(props) {
  var _hasError;
  var initValue = [];
  var _ref2 = useContext(FormContext) || {
      register: function register() {},
      control: {},
      errors: {}
    },
    errors = _ref2.errors;
  var field = useContext(FormItemContext) || {
    field: {}
  };
  var _useState = useState(initValue),
    _useState2 = _slicedToArray(_useState, 2),
    value = _useState2[0],
    setValue = _useState2[1];
  var _useState3 = useState(false),
    _useState4 = _slicedToArray(_useState3, 2),
    loading = _useState4[0],
    setLoading = _useState4[1];
  var _useState5 = useState([]),
    _useState6 = _slicedToArray(_useState5, 2),
    items = _useState6[0],
    setItems = _useState6[1];
  var _useState7 = useState(false),
    _useState8 = _slicedToArray(_useState7, 2),
    selectAll = _useState8[0],
    setSelectAll = _useState8[1];
  var applyValue = function applyValue(newVal) {
    if (Array.isArray(newVal)) {
      setSelectAll(newVal.length === items.length);
      setValue(newVal);
      return newVal;
    } else {
      setSelectAll(false);
      setValue(initValue);
      return initValue;
    }
  };
  useEffect(function () {
    setLoading(true);
    axios.get(props.baseEndpoint, {
      params: {
        page: 0,
        size: props.maxResults
      },
      headers: _objectSpread2({}, props.requestHeaders)
    }).then(function (res) {
      setLoading(false);
      setItems(res.data.content);
    })["catch"](function (err) {
      setLoading(false);
      setItems([]);
    });
  }, []);
  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);
  };

  /*
  const itemTemplate = (item) => {
    if (props.itemTemplate) return props.itemTemplate(item, props);
    return <div>{item[props.nameField]}</div>;
  };
   const selectedItemTemplate = (item) => {
    if (props.valueTemplate) return props.valueTemplate(item, props);
    if (item) {
      return <span>{item ? item[props.nameField] : ''}</span>;
    }
    return <span>{props.placeholder}</span>;
  };
  */

  var callbackSelectAll = function callbackSelectAll(e) {
    var newVal = applyValue(e.checked ? [] : items);
    if (props.withController) {
      field.onChange(newVal);
    }
    props.onChange(newVal);
  };
  return /*#__PURE__*/React.createElement("div", {
    className: "p-field"
  }, /*#__PURE__*/React.createElement("label", {
    htmlFor: props.name,
    className: classNames('block', {
      'p-error': errors[props.name]
    })
  }, props.label), /*#__PURE__*/React.createElement(MultiSelect, _extends({
    disabled: loading || props.readOnly,
    value: value,
    showClear: props.showClear,
    options: items,
    onChange: change,
    optionLabel: props.nameField,
    filter: true,
    style: {
      width: '100%'
    },
    filterBy: props.nameField,
    onSelectAll: callbackSelectAll,
    selectAll: selectAll,
    panelStyle: {
      maxWidth: '250px'
    }
  }, props.itemTemplate && {
    itemTemplate: props.itemTemplate
  }, props.valueTemplate && {
    selectedItemTemplate: props.valueTemplate
  }, {
    placeholder: props.placeholder,
    className: classNames({
      'p-invalid': hasError(errors, props.name)
    })
  }, props.customProps)), /*#__PURE__*/React.createElement("small", {
    className: "p-error",
    style: {
      display: 'block'
    }
  }, (_hasError = hasError(errors, props.name)) === null || _hasError === void 0 ? void 0 : _hasError.message));
};
A