contentoh-components-library 21.4.102 → 21.4.104

package/dist/components/molecules/Phase/index.js

@@ -1,58 +1,109 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
 var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Phase = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/asyncToGenerator"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+
 var _react = _interopRequireWildcard(require("react"));
+
 var _styles = require("./styles");
+
 var _material = require("@mui/material");
+
 var _Select = _interopRequireDefault(require("@mui/material/Select"));
+
 var _axios = _interopRequireDefault(require("axios"));
+
 var _Modal = require("../../organisms/Modal");
+
 var _TextField = require("@mui/material/TextField");
+
 var _GroupSelect = require("../../molecules/GroupSelect");
+
 var _CustomChip = require("../../atoms/CustomChip");
+
 var _CustomSelect = require("../../molecules/CustomSelect");
+
 var _ButtonV = require("../../atoms/ButtonV2");
+
 var _options = _interopRequireDefault(require("../../../assets/images/Icons/options.svg"));
+
 var _addv = _interopRequireDefault(require("../../../assets/images/Icons/addv2.svg"));
+
 var _jsxRuntime = require("react/jsx-runtime");
-//Componentes
 
+//Componentes
 //svg
+var Phase = function Phase(_ref) {
+  var key = _ref.key,
+      id = _ref.id,
+      phaseId = _ref.phaseId,
+      phases = _ref.phases,
+      phaseName = _ref.phaseName,
+      nextPhase = _ref.nextPhase,
+      groups = _ref.groups,
+      onDeletePhase = _ref.onDeletePhase,
+      token = _ref.token,
+      _ref$showMenu = _ref.showMenu,
+      showMenu = _ref$showMenu === void 0 ? true : _ref$showMenu,
+      _ref$showButtonChip = _ref.showButtonChip,
+      showButtonChip = _ref$showButtonChip === void 0 ? true : _ref$showButtonChip;
+
+  var _useState = (0, _react.useState)([]),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      selectedValue = _useState2[0],
+      setSelectedValue = _useState2[1];
+
+  var _useState3 = (0, _react.useState)([]),
+      _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+      chips = _useState4[0],
+      setChips = _useState4[1];
+
+  var _useState5 = (0, _react.useState)([]),
+      _useState6 = (0, _slicedToArray2.default)(_useState5, 2),
+      groupsSelected = _useState6[0],
+      setGroupsSelected = _useState6[1];
+
+  var _React$useState = _react.default.useState(null),
+      _React$useState2 = (0, _slicedToArray2.default)(_React$useState, 2),
+      anchorEl = _React$useState2[0],
+      setAnchorEl = _React$useState2[1];
+
+  var _useState7 = (0, _react.useState)(""),
+      _useState8 = (0, _slicedToArray2.default)(_useState7, 2),
+      nextPhaseState = _useState8[0],
+      setNextPhaseState = _useState8[1];
+
+  var open = Boolean(anchorEl);
 
-const Phase = _ref => {
-  let {
-    key,
-    id,
-    phaseId,
-    phases,
-    phaseName,
-    nextPhase,
-    groups,
-    onDeletePhase,
-    token,
-    showMenu = true,
-    showButtonChip = true
-  } = _ref;
-  const [selectedValue, setSelectedValue] = (0, _react.useState)([]);
-  const [chips, setChips] = (0, _react.useState)([]);
-  const [groupsSelected, setGroupsSelected] = (0, _react.useState)([]);
-  const [anchorEl, setAnchorEl] = _react.default.useState(null);
-  const [nextPhaseState, setNextPhaseState] = (0, _react.useState)("");
-  const open = Boolean(anchorEl);
-  const [modalData, setModalData] = (0, _react.useState)({
+  var _useState9 = (0, _react.useState)({
     show: false,
     title: "Actualización completa",
     message: "",
     icon: "success"
-  });
-  const ITEM_HEIGHT = 48;
-  const ITEM_PADDING_TOP = 8;
-  const MenuProps = {
+  }),
+      _useState10 = (0, _slicedToArray2.default)(_useState9, 2),
+      modalData = _useState10[0],
+      setModalData = _useState10[1];
+
+  var ITEM_HEIGHT = 48;
+  var ITEM_PADDING_TOP = 8;
+  var MenuProps = {
     PaperProps: {
       style: {
         maxHeight: ITEM_HEIGHT * 4.5 + ITEM_PADDING_TOP,
@@ -60,120 +111,236 @@ const Phase = _ref => {
       }
     }
   };
-  const loadData = async () => {
-    const activeGroups = groups.filter(group => group.groupActive === 1);
-    const initialChips = activeGroups.map(group => ({
-      id: group.groupId,
-      label: group.groupName
+
+  var loadData = /*#__PURE__*/function () {
+    var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+      var activeGroups, initialChips, nextPhaseObject;
+      return _regenerator.default.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              activeGroups = groups.filter(function (group) {
+                return group.groupActive === 1;
+              });
+              initialChips = activeGroups.map(function (group) {
+                return {
+                  id: group.groupId,
+                  label: group.groupName
+                };
+              });
+              setChips(initialChips);
+              nextPhaseObject = phases.find(function (phase) {
+                return phase.phaseId === nextPhase;
+              });
+
+              if (nextPhaseObject) {
+                setNextPhaseState(nextPhaseObject.phaseName);
+              }
+
+            case 5:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
     }));
-    setChips(initialChips);
-    const nextPhaseObject = phases.find(phase => phase.phaseId === nextPhase);
-    if (nextPhaseObject) {
-      setNextPhaseState(nextPhaseObject.phaseName);
-    }
-  };
-  (0, _react.useEffect)(() => {
+
+    return function loadData() {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+
+  (0, _react.useEffect)(function () {
     loadData();
   }, [groups]);
-  (0, _react.useEffect)(() => {
+  (0, _react.useEffect)(function () {
     loadData();
   }, [nextPhase, phases]);
-  (0, _react.useEffect)(() => {
+  (0, _react.useEffect)(function () {
     handleGroupSelect();
   }, [groupsSelected]);
-  (0, _react.useEffect)(() => {
+  (0, _react.useEffect)(function () {
     handleNextPhaseSelect();
-  }, [selectedValue]);
-
-  //agregar fase
-  const onAdd = async phaseId => {
-    if (selectedValue && !groupsSelected.includes(selectedValue)) {
-      const updatedGroups = groups.map(group => group.groupName === selectedValue ? {
-        ...group,
-        groupActive: 1
-      } : group);
-
-      // Actualizar el estado de chips y groupsSelected
-      setChips(prevChips => [...prevChips, {
-        id: phaseId,
-        label: selectedValue
-      }]);
-      setGroupsSelected(prevGroups => [...prevGroups, selectedValue]);
-      setSelectedValue("");
-      console.log("update", updatedGroups);
-      loadData();
-    }
-  };
+  }, [selectedValue]); //agregar fase
 
-  //agregar grupo a fase
-  const addGroup = async (phaseId, groups) => {
-    try {
-      const response = await _axios.default.post("".concat(process.env.REACT_APP_PHASES_ENDPOINT, "/update"), {
-        retailerGroupsIds: groups,
-        phaseId
-      }, {
-        headers: {
-          Authorization: token
+  var onAdd = /*#__PURE__*/function () {
+    var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(phaseId) {
+      var updatedGroups;
+      return _regenerator.default.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              if (selectedValue && !groupsSelected.includes(selectedValue)) {
+                updatedGroups = groups.map(function (group) {
+                  return group.groupName === selectedValue ? (0, _objectSpread2.default)((0, _objectSpread2.default)({}, group), {}, {
+                    groupActive: 1
+                  }) : group;
+                }); // Actualizar el estado de chips y groupsSelected
+
+                setChips(function (prevChips) {
+                  return [].concat((0, _toConsumableArray2.default)(prevChips), [{
+                    id: phaseId,
+                    label: selectedValue
+                  }]);
+                });
+                setGroupsSelected(function (prevGroups) {
+                  return [].concat((0, _toConsumableArray2.default)(prevGroups), [selectedValue]);
+                });
+                setSelectedValue("");
+                console.log("update", updatedGroups);
+                loadData();
+              }
+
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
         }
-      });
-      console.log("response", response.data.body);
-      console.log("grupo agregado correctamente");
-      loadData();
-    } catch (error) {
-      console.error("Error al agregar grupo a fase:", error);
-    }
-  };
+      }, _callee2);
+    }));
 
-  //actualiza siguiente fase
-  const updateNextPhase = async (phaseId, newNextPhase) => {
-    try {
-      console.log("fase y grupos", {
-        phaseId,
-        newNextPhase
-      });
-      const response = await _axios.default.post("".concat(process.env.REACT_APP_PHASES_ENDPOINT, "/update"), {
-        nextPhaseId: newNextPhase,
-        phaseId
-      }, {
-        headers: {
-          Authorization: token
+    return function onAdd(_x) {
+      return _ref3.apply(this, arguments);
+    };
+  }(); //agregar grupo a fase
+
+
+  var addGroup = /*#__PURE__*/function () {
+    var _ref4 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(phaseId, groups) {
+      var response;
+      return _regenerator.default.wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.prev = 0;
+              _context3.next = 3;
+              return _axios.default.post("".concat(process.env.REACT_APP_PHASES_ENDPOINT, "/update"), {
+                retailerGroupsIds: groups,
+                phaseId: phaseId
+              }, {
+                headers: {
+                  Authorization: token
+                }
+              });
+
+            case 3:
+              response = _context3.sent;
+              console.log("response", response.data.body);
+              console.log("grupo agregado correctamente");
+              loadData();
+              _context3.next = 12;
+              break;
+
+            case 9:
+              _context3.prev = 9;
+              _context3.t0 = _context3["catch"](0);
+              console.error("Error al agregar grupo a fase:", _context3.t0);
+
+            case 12:
+            case "end":
+              return _context3.stop();
+          }
         }
+      }, _callee3, null, [[0, 9]]);
+    }));
+
+    return function addGroup(_x2, _x3) {
+      return _ref4.apply(this, arguments);
+    };
+  }(); //actualiza siguiente fase
+
+
+  var updateNextPhase = /*#__PURE__*/function () {
+    var _ref5 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(phaseId, newNextPhase) {
+      var response;
+      return _regenerator.default.wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.prev = 0;
+              console.log("fase y grupos", {
+                phaseId: phaseId,
+                newNextPhase: newNextPhase
+              });
+              _context4.next = 4;
+              return _axios.default.post("".concat(process.env.REACT_APP_PHASES_ENDPOINT, "/update"), {
+                nextPhaseId: newNextPhase,
+                phaseId: phaseId
+              }, {
+                headers: {
+                  Authorization: token
+                }
+              });
+
+            case 4:
+              response = _context4.sent;
+              console.log("response", response.data.body);
+              console.log("grupo agregado correctamente");
+              _context4.next = 12;
+              break;
+
+            case 9:
+              _context4.prev = 9;
+              _context4.t0 = _context4["catch"](0);
+              console.error("Error al actualizar grupo de fase:", _context4.t0);
+
+            case 12:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4, null, [[0, 9]]);
+    }));
+
+    return function updateNextPhase(_x4, _x5) {
+      return _ref5.apply(this, arguments);
+    };
+  }();
+
+  var handleGroupSelect = function handleGroupSelect() {
+    groupsSelected.forEach(function (groupId) {
+      var matchingGroup = groups.find(function (group) {
+        return group.groupId === groupId;
       });
-      console.log("response", response.data.body);
-      console.log("grupo agregado correctamente");
-    } catch (error) {
-      console.error("Error al actualizar grupo de fase:", error);
-    }
-  };
-  const handleGroupSelect = () => {
-    groupsSelected.forEach(groupId => {
-      const matchingGroup = groups.find(group => group.groupId === groupId);
+
       if (matchingGroup) {
-        if (!chips.find(chip => chip.key === matchingGroup.groupId)) {
-          setChips(prevChips => [...prevChips, {
-            id: matchingGroup.groupId,
-            label: matchingGroup.groupName
-          }]);
+        if (!chips.find(function (chip) {
+          return chip.key === matchingGroup.groupId;
+        })) {
+          setChips(function (prevChips) {
+            return [].concat((0, _toConsumableArray2.default)(prevChips), [{
+              id: matchingGroup.groupId,
+              label: matchingGroup.groupName
+            }]);
+          });
         }
+
         addGroup(phaseId, groupsSelected);
       }
     });
   };
-  const handleNextPhaseSelect = () => {
+
+  var handleNextPhaseSelect = function handleNextPhaseSelect() {
     if (selectedValue.length > 0) {
-      const Id = selectedValue[0];
+      var Id = selectedValue[0];
       console.log("phaseId", Id);
-      const matchingPhase = phases.find(phase => phase.phaseId === Id);
+      var matchingPhase = phases.find(function (phase) {
+        return phase.phaseId === Id;
+      });
       console.log("matchingPhase", matchingPhase);
+
       if (matchingPhase) {
         checkAvailablePhase(phaseId, matchingPhase.phaseId);
       }
     }
-  };
+  }; //checa si llega una fase que se tiene en otro lado 
+
+
+  var checkAvailablePhase = function checkAvailablePhase(phaseId, newNextPhase) {
+    var isNextPhaseUsed = phases.some(function (phase) {
+      return phase.nextPhaseIfApproved === newNextPhase;
+    });
 
-  //checa si llega una fase que se tiene en otro lado 
-  const checkAvailablePhase = (phaseId, newNextPhase) => {
-    const isNextPhaseUsed = phases.some(phase => phase.nextPhaseIfApproved === newNextPhase);
     if (isNextPhaseUsed) {
       setModalData({
         show: true,
@@ -192,21 +359,23 @@ const Phase = _ref => {
           type: "white",
           label: "Cancelar",
           size: 12,
-          onClick: () => {
-            setModalData(prev => ({
-              ...prev,
-              show: false
-            }));
+          onClick: function onClick() {
+            setModalData(function (prev) {
+              return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, prev), {}, {
+                show: false
+              });
+            });
           }
         }, "btn-Cancelar"), /*#__PURE__*/(0, _jsxRuntime.jsx)(_ButtonV.ButtonV2, {
           type: "pink",
           label: "Aceptar",
           size: 12,
-          onClick: () => {
-            setModalData(prev => ({
-              ...prev,
-              show: false
-            }));
+          onClick: function onClick() {
+            setModalData(function (prev) {
+              return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, prev), {}, {
+                show: false
+              });
+            });
           }
         }, "btn-Aceptar")]
       });
@@ -214,45 +383,82 @@ const Phase = _ref => {
       // Si la fase no está siendo utilizada, se actualizar la siguiente fase
       updateNextPhase(phaseId, newNextPhase);
     }
-  };
+  }; //eliminar chip
 
-  //eliminar chip
-  const handleChipDelete = (phaseId, chipToRemove) => {
-    setGroupsSelected(prevGroups => prevGroups.filter(chip => chip.id !== chipToRemove.id));
+
+  var handleChipDelete = function handleChipDelete(phaseId, chipToRemove) {
+    setGroupsSelected(function (prevGroups) {
+      return prevGroups.filter(function (chip) {
+        return chip.id !== chipToRemove.id;
+      });
+    });
     console.log("Se elimino el grupo", chipToRemove.id);
-    setChips(prevChips => prevChips.filter(chip => chip.id !== chipToRemove.id));
+    setChips(function (prevChips) {
+      return prevChips.filter(function (chip) {
+        return chip.id !== chipToRemove.id;
+      });
+    });
     deleteGroup(phaseId, chipToRemove.id);
-  };
+  }; //eliminar grupo de fase
 
-  //eliminar grupo de fase
-  const deleteGroup = async (phaseId, groupId) => {
-    try {
-      console.log("grupo de fase", {
-        phaseId,
-        groupId
-      });
-      const response = await _axios.default.post("".concat(process.env.REACT_APP_PHASES_ENDPOINT, "/delete"), {
-        deleteGroupOfPhase: {
-          phaseId,
-          groupId
-        }
-      }, {
-        headers: {
-          Authorization: token
-          // Authorization: sessionStorage.getItem("jwt"),
+
+  var deleteGroup = /*#__PURE__*/function () {
+    var _ref6 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(phaseId, groupId) {
+      var response;
+      return _regenerator.default.wrap(function _callee5$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.prev = 0;
+              console.log("grupo de fase", {
+                phaseId: phaseId,
+                groupId: groupId
+              });
+              _context5.next = 4;
+              return _axios.default.post("".concat(process.env.REACT_APP_PHASES_ENDPOINT, "/delete"), {
+                deleteGroupOfPhase: {
+                  phaseId: phaseId,
+                  groupId: groupId
+                }
+              }, {
+                headers: {
+                  Authorization: token // Authorization: sessionStorage.getItem("jwt"),
+
+                }
+              });
+
+            case 4:
+              response = _context5.sent;
+              console.log("grupo eliminado correctamente");
+              _context5.next = 11;
+              break;
+
+            case 8:
+              _context5.prev = 8;
+              _context5.t0 = _context5["catch"](0);
+              console.error("Error al eliminar grupo de fase:", _context5.t0);
+
+            case 11:
+            case "end":
+              return _context5.stop();
+          }
         }
-      });
-      console.log("grupo eliminado correctamente");
-    } catch (error) {
-      console.error("Error al eliminar grupo de fase:", error);
-    }
-  };
-  const handleClick = event => {
+      }, _callee5, null, [[0, 8]]);
+    }));
+
+    return function deleteGroup(_x6, _x7) {
+      return _ref6.apply(this, arguments);
+    };
+  }();
+
+  var handleClick = function handleClick(event) {
     setAnchorEl(event.currentTarget);
   };
-  const handleClose = () => {
+
+  var handleClose = function handleClose() {
     setAnchorEl(null);
   };
+
   return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_styles.Container, {
     children: [/*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
       className: "header-phase",
@@ -268,8 +474,10 @@ const Phase = _ref => {
           }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_Select.default, {
             value: selectedValue.length > 0 ? selectedValue[0] : nextPhaseState ? nextPhaseState : "",
             placeholder: "Fase",
-            onChange: e => {
-              const selectedPhase = phases.find(phase => phase.phaseName === e.target.value);
+            onChange: function onChange(e) {
+              var selectedPhase = phases.find(function (phase) {
+                return phase.phaseName === e.target.value;
+              });
               setSelectedValue(selectedPhase ? [selectedPhase.phaseId] : []);
             },
             sx: {
@@ -286,22 +494,26 @@ const Phase = _ref => {
                 }
               }
             },
-            children: phases.map(phase => /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.MenuItem, {
-              value: phase.phaseName,
-              sx: {
-                fontSize: "12px",
-                color: "#262626",
-                minHeight: "auto"
-              },
-              children: phase.phaseName
-            }, phase.phaseId))
+            children: phases.map(function (phase) {
+              return /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.MenuItem, {
+                value: phase.phaseName,
+                sx: {
+                  fontSize: "12px",
+                  color: "#262626",
+                  minHeight: "auto"
+                },
+                children: phase.phaseName
+              }, phase.phaseId);
+            })
           }), showMenu && /*#__PURE__*/(0, _jsxRuntime.jsxs)(_jsxRuntime.Fragment, {
             children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
               id: "basic-button",
               "aria-controls": open ? "basic-menu" : undefined,
               "aria-haspopup": "true",
               "aria-expanded": open ? "true" : undefined,
-              onClick: e => handleClick(e),
+              onClick: function onClick(e) {
+                return handleClick(e);
+              },
               children: /*#__PURE__*/(0, _jsxRuntime.jsx)("img", {
                 src: _options.default,
                 alt: ""
@@ -321,7 +533,9 @@ const Phase = _ref => {
                 }
               },
               children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.MenuItem, {
-                onClick: () => onDeletePhase(id),
+                onClick: function onClick() {
+                  return onDeletePhase(id);
+                },
                 sx: {
                   fontSize: "12px",
                   color: "#262626",
@@ -335,14 +549,22 @@ const Phase = _ref => {
       })]
     }, key), /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
       className: "attributes-container",
-      children: [chips.map(chip => /*#__PURE__*/(0, _jsxRuntime.jsx)(_CustomChip.CustomChip, {
-        label: chip.label,
-        onDelete: () => handleChipDelete(phaseId, chip)
-      }, chip.id)), showButtonChip && /*#__PURE__*/(0, _jsxRuntime.jsx)(_GroupSelect.GroupSelect, {
-        options: groups.filter(group => group.groupActive === 0).map(group => ({
-          id: group.groupId,
-          name: group.groupName
-        })),
+      children: [chips.map(function (chip) {
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(_CustomChip.CustomChip, {
+          label: chip.label,
+          onDelete: function onDelete() {
+            return handleChipDelete(phaseId, chip);
+          }
+        }, chip.id);
+      }), showButtonChip && /*#__PURE__*/(0, _jsxRuntime.jsx)(_GroupSelect.GroupSelect, {
+        options: groups.filter(function (group) {
+          return group.groupActive === 0;
+        }).map(function (group) {
+          return {
+            id: group.groupId,
+            name: group.groupName
+          };
+        }),
         showSearchBar: true,
         isSingleSelect: false,
         icon: _addv.default,
@@ -351,17 +573,20 @@ const Phase = _ref => {
         defaultOption: "Todos los grupos",
         parameterArray: groupsSelected,
         setParameterArray: setGroupsSelected,
-        onClickItem: () => {
+        onClickItem: function onClickItem() {
           handleGroupSelect();
         }
       })]
-    }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_Modal.Modal, {
-      ...modalData,
-      onClickBtnDefault: () => setModalData(prev => ({
-        ...prev,
-        show: false
-      }))
-    })]
+    }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_Modal.Modal, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, modalData), {}, {
+      onClickBtnDefault: function onClickBtnDefault() {
+        return setModalData(function (prev) {
+          return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, prev), {}, {
+            show: false
+          });
+        });
+      }
+    }))]
   });
 };
+
 exports.Phase = Phase;