'use strict';

var React = require('react');
var Button = require('@mui/material/Button');
var Dialog = require('@mui/material/Dialog');
var DialogActions = require('@mui/material/DialogActions');
var DialogContent = require('@mui/material/DialogContent');
var DialogContentText = require('@mui/material/DialogContentText');
var DialogTitle = require('@mui/material/DialogTitle');
var TextField = require('@mui/material/TextField');
var Checkbox = require('@mui/material/Checkbox');
var FormControlLabel = require('@mui/material/FormControlLabel');

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

var React__default = /*#__PURE__*/_interopDefaultCompat(React);
var Button__default = /*#__PURE__*/_interopDefaultCompat(Button);
var Dialog__default = /*#__PURE__*/_interopDefaultCompat(Dialog);
var DialogActions__default = /*#__PURE__*/_interopDefaultCompat(DialogActions);
var DialogContent__default = /*#__PURE__*/_interopDefaultCompat(DialogContent);
var DialogContentText__default = /*#__PURE__*/_interopDefaultCompat(DialogContentText);
var DialogTitle__default = /*#__PURE__*/_interopDefaultCompat(DialogTitle);
var TextField__default = /*#__PURE__*/_interopDefaultCompat(TextField);
var Checkbox__default = /*#__PURE__*/_interopDefaultCompat(Checkbox);
var FormControlLabel__default = /*#__PURE__*/_interopDefaultCompat(FormControlLabel);

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 _defineProperty(e, r, t) {
  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
    value: t,
    enumerable: true,
    configurable: true,
    writable: true
  }) : 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 _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 = true,
      o = false;
    try {
      if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
    } catch (r) {
      o = true, 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 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), true).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 _toPrimitive(t, r) {
  if ("object" != typeof t || !t) return t;
  var e = t[Symbol.toPrimitive];
  if (undefined !== 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) : undefined;
  }
}

var ConfirmContext = /*#__PURE__*/React.createContext({
  confirmBase: function confirmBase() {
    throw new Error("Missing ConfirmProvider");
  },
  closeOnParentUnmount: function closeOnParentUnmount() {}
});

var ConfirmationDialog = function ConfirmationDialog(_ref) {
  var open = _ref.open,
    options = _ref.options,
    onCancel = _ref.onCancel,
    onConfirm = _ref.onConfirm,
    onClose = _ref.onClose;
  var title = options.title,
    description = options.description,
    content = options.content,
    confirmationText = options.confirmationText,
    cancellationText = options.cancellationText,
    dialogProps = options.dialogProps,
    dialogActionsProps = options.dialogActionsProps,
    confirmationButtonProps = options.confirmationButtonProps,
    cancellationButtonProps = options.cancellationButtonProps,
    titleProps = options.titleProps,
    contentProps = options.contentProps,
    allowClose = options.allowClose,
    confirmationKeyword = options.confirmationKeyword,
    confirmationKeywordTextFieldProps = options.confirmationKeywordTextFieldProps,
    hideCancelButton = options.hideCancelButton,
    buttonOrder = options.buttonOrder,
    acknowledgement = options.acknowledgement,
    acknowledgementFormControlLabelProps = options.acknowledgementFormControlLabelProps,
    acknowledgementCheckboxProps = options.acknowledgementCheckboxProps;
  var _React$useState = React__default.default.useState(""),
    _React$useState2 = _slicedToArray(_React$useState, 2),
    confirmationKeywordValue = _React$useState2[0],
    setConfirmationKeywordValue = _React$useState2[1];
  var _React$useState3 = React__default.default.useState(false),
    _React$useState4 = _slicedToArray(_React$useState3, 2),
    isAcknowledged = _React$useState4[0],
    setIsAcknowledged = _React$useState4[1];
  var confirmationButtonDisabled = Boolean(confirmationKeyword && confirmationKeywordValue !== confirmationKeyword || acknowledgement && !isAcknowledged);
  var acknowledgeCheckbox = /*#__PURE__*/React__default.default.createElement(React__default.default.Fragment, null, acknowledgement && /*#__PURE__*/React__default.default.createElement(FormControlLabel__default.default, _extends({}, acknowledgementFormControlLabelProps, {
    control: /*#__PURE__*/React__default.default.createElement(Checkbox__default.default, _extends({}, acknowledgementCheckboxProps, {
      value: isAcknowledged,
      onChange: function onChange(_, value) {
        return setIsAcknowledged(value);
      }
    })),
    label: acknowledgement
  })));
  var confirmationContent = /*#__PURE__*/React__default.default.createElement(React__default.default.Fragment, null, confirmationKeyword && /*#__PURE__*/React__default.default.createElement(TextField__default.default, _extends({
    onChange: function onChange(e) {
      return setConfirmationKeywordValue(e.target.value);
    },
    value: confirmationKeywordValue,
    fullWidth: true
  }, confirmationKeywordTextFieldProps)));
  var dialogActions = buttonOrder.map(function (buttonType) {
    if (buttonType === "cancel") {
      return !hideCancelButton && /*#__PURE__*/React__default.default.createElement(Button__default.default, _extends({
        key: "cancel"
      }, cancellationButtonProps, {
        onClick: onCancel
      }), cancellationText);
    }
    if (buttonType === "confirm") {
      return /*#__PURE__*/React__default.default.createElement(Button__default.default, _extends({
        key: "confirm",
        color: "primary",
        disabled: confirmationButtonDisabled
      }, confirmationButtonProps, {
        onClick: onConfirm
      }), confirmationText);
    }
    throw new Error("Supported button types are only \"confirm\" and \"cancel\", got: ".concat(buttonType));
  });
  return /*#__PURE__*/React__default.default.createElement(Dialog__default.default, _extends({
    fullWidth: true
  }, dialogProps, {
    open: open,
    onClose: allowClose ? onClose : null
  }), title && /*#__PURE__*/React__default.default.createElement(DialogTitle__default.default, titleProps, title), content ? /*#__PURE__*/React__default.default.createElement(DialogContent__default.default, contentProps, content, confirmationContent, acknowledgeCheckbox) : description ? /*#__PURE__*/React__default.default.createElement(DialogContent__default.default, contentProps, /*#__PURE__*/React__default.default.createElement(DialogContentText__default.default, null, description), confirmationContent, acknowledgeCheckbox) : (confirmationKeyword || acknowledgeCheckbox) && /*#__PURE__*/React__default.default.createElement(DialogContent__default.default, contentProps, confirmationContent, acknowledgeCheckbox), /*#__PURE__*/React__default.default.createElement(DialogActions__default.default, dialogActionsProps, dialogActions));
};

var DEFAULT_OPTIONS = {
  title: "Are you sure?",
  description: "",
  content: null,
  confirmationText: "Ok",
  cancellationText: "Cancel",
  dialogProps: {},
  dialogActionsProps: {},
  confirmationButtonProps: {},
  cancellationButtonProps: {},
  titleProps: {},
  contentProps: {},
  allowClose: true,
  confirmationKeywordTextFieldProps: {},
  hideCancelButton: false,
  buttonOrder: ["cancel", "confirm"],
  acknowledgement: false,
  acknowledgementFormControlLabelProps: {},
  acknowledgementCheckboxProps: {}
};
var buildOptions = function buildOptions(defaultOptions, options) {
  var dialogProps = _objectSpread2(_objectSpread2({}, defaultOptions.dialogProps || DEFAULT_OPTIONS.dialogProps), options.dialogProps || {});
  var dialogActionsProps = _objectSpread2(_objectSpread2({}, defaultOptions.dialogActionsProps || DEFAULT_OPTIONS.dialogActionsProps), options.dialogActionsProps || {});
  var confirmationButtonProps = _objectSpread2(_objectSpread2({}, defaultOptions.confirmationButtonProps || DEFAULT_OPTIONS.confirmationButtonProps), options.confirmationButtonProps || {});
  var cancellationButtonProps = _objectSpread2(_objectSpread2({}, defaultOptions.cancellationButtonProps || DEFAULT_OPTIONS.cancellationButtonProps), options.cancellationButtonProps || {});
  var titleProps = _objectSpread2(_objectSpread2({}, defaultOptions.titleProps || DEFAULT_OPTIONS.titleProps), options.titleProps || {});
  var contentProps = _objectSpread2(_objectSpread2({}, defaultOptions.contentProps || DEFAULT_OPTIONS.contentProps), options.contentProps || {});
  var confirmationKeywordTextFieldProps = _objectSpread2(_objectSpread2({}, defaultOptions.confirmationKeywordTextFieldProps || DEFAULT_OPTIONS.confirmationKeywordTextFieldProps), options.confirmationKeywordTextFieldProps || {});
  var acknowledgementFormControlLabelProps = _objectSpread2(_objectSpread2({}, defaultOptions.acknowledgementFormControlLabelProps || DEFAULT_OPTIONS.acknowledgementFormControlLabelProps), options.acknowledgementFormControlLabelProps || {});
  var acknowledgementCheckboxProps = _objectSpread2(_objectSpread2({}, defaultOptions.acknowledgementCheckboxProps || DEFAULT_OPTIONS.acknowledgementCheckboxProps), options.acknowledgementCheckboxProps || {});
  return _objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2({}, DEFAULT_OPTIONS), defaultOptions), options), {}, {
    dialogProps: dialogProps,
    dialogActionsProps: dialogActionsProps,
    confirmationButtonProps: confirmationButtonProps,
    cancellationButtonProps: cancellationButtonProps,
    titleProps: titleProps,
    contentProps: contentProps,
    confirmationKeywordTextFieldProps: confirmationKeywordTextFieldProps,
    acknowledgementFormControlLabelProps: acknowledgementFormControlLabelProps,
    acknowledgementCheckboxProps: acknowledgementCheckboxProps
  });
};
exports.confirm = void 0;
var ConfirmProvider = function ConfirmProvider(_ref) {
  var children = _ref.children,
    _ref$defaultOptions = _ref.defaultOptions,
    defaultOptions = _ref$defaultOptions === undefined ? {} : _ref$defaultOptions;
  // State that we clear on close (to avoid dangling references to resolve and
  // reject). If this is null, the dialog is closed.
  var _useState = React.useState(null),
    _useState2 = _slicedToArray(_useState, 2),
    state = _useState2[0],
    setState = _useState2[1];
  // Options for rendering the dialog, which aren't reset on close so that we
  // keep rendering the same modal during close animation
  var _useState3 = React.useState({}),
    _useState4 = _slicedToArray(_useState3, 2),
    options = _useState4[0],
    setOptions = _useState4[1];
  var _useState5 = React.useState(0),
    _useState6 = _slicedToArray(_useState5, 2),
    key = _useState6[0],
    setKey = _useState6[1];
  var confirmBase = React.useCallback(function (parentId) {
    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    return new Promise(function (resolve, reject) {
      setKey(function (key) {
        return key + 1;
      });
      setOptions(options);
      setState({
        resolve: resolve,
        reject: reject,
        parentId: parentId
      });
    });
  }, []);
  var closeOnParentUnmount = React.useCallback(function (parentId) {
    setState(function (state) {
      if (state && state.parentId === parentId) {
        return null;
      } else {
        return state;
      }
    });
  }, []);
  var handleClose = React.useCallback(function () {
    setState(null);
  }, []);
  var handleCancel = React.useCallback(function () {
    setState(function (state) {
      state && state.reject();
      return null;
    });
  }, []);
  var handleConfirm = React.useCallback(function () {
    setState(function (state) {
      state && state.resolve();
      return null;
    });
  }, []);
  exports.confirm = React.useCallback(function (options) {
    return confirmBase("global", options);
  });
  return /*#__PURE__*/React__default.default.createElement(React.Fragment, null, /*#__PURE__*/React__default.default.createElement(ConfirmContext.Provider, {
    value: {
      confirmBase: confirmBase,
      closeOnParentUnmount: closeOnParentUnmount
    }
  }, children), /*#__PURE__*/React__default.default.createElement(ConfirmationDialog, {
    key: key,
    open: state !== null,
    options: buildOptions(defaultOptions, options !== null && options !== undefined ? options : {}),
    onClose: handleClose,
    onCancel: handleCancel,
    onConfirm: handleConfirm
  }));
};

var idCounter = 0;
var useConfirmId = function useConfirmId() {
  var id = React.useMemo(function () {
    return idCounter++;
  }, []);
  return "confirm-".concat(id);
};
var useConfirm = function useConfirm() {
  var parentId = useConfirmId();
  var _useContext = React.useContext(ConfirmContext),
    confirmBase = _useContext.confirmBase,
    closeOnParentUnmount = _useContext.closeOnParentUnmount;
  var confirm = React.useCallback(function (options) {
    return confirmBase(parentId, options);
  }, [parentId]);

  // When the component calling useConfirm is unmounted, we automatically
  // close the associated confirmation dialog. Note that we use a
  // unique id per each useConfirm usage, so that we don't close the
  // dialog when an unrelated component unmounts
  React.useEffect(function () {
    return function () {
      closeOnParentUnmount(parentId);
    };
  }, [parentId]);
  return confirm;
};

exports.ConfirmProvider = ConfirmProvider;
exports.useConfirm = useConfirm;