@elice/material-runbox 1.240718.0-trasncript.0 → 1.240718.0-trasncript.2

package/es/components/material-runbox/actions/MaterialRunboxActionMenu.js

@@ -1,3 +1,4 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
 import React from 'react';
 import { useEliceRunboxRunning } from '@elice/runbox-client';
 import { Menu } from '@mui/material';
@@ -8,22 +9,20 @@ import MaterialRunboxActionShare from './MaterialRunboxActionShare.js';
 //
 //
 //
-const MaterialRunboxActionMenu = ({
-  runbox,
-  runtime,
-  courseId,
-  menuAnchorEl,
-  refetch,
-  handleMenuClose
-}) => {
-  const {
-    status
-  } = useEliceRunboxRunning();
-  const isRunboxRunning = status === 'running';
+var MaterialRunboxActionMenu = function MaterialRunboxActionMenu(_ref) {
+  var runbox = _ref.runbox,
+    runtime = _ref.runtime,
+    courseId = _ref.courseId,
+    menuAnchorEl = _ref.menuAnchorEl,
+    refetch = _ref.refetch,
+    handleMenuClose = _ref.handleMenuClose;
+  var _useEliceRunboxRunnin = useEliceRunboxRunning(),
+    status = _useEliceRunboxRunnin.status;
+  var isRunboxRunning = status === 'running';
   //
   //
   //
-  React.useEffect(() => {
+  React.useEffect(function () {
     if (!isRunboxRunning) {
       handleMenuClose();
     }
@@ -31,7 +30,7 @@ const MaterialRunboxActionMenu = ({
   //
   //
   //
-  return React.createElement(Menu, {
+  return jsxs(Menu, {
     open: Boolean(menuAnchorEl),
     anchorEl: menuAnchorEl,
     anchorOrigin: {
@@ -42,20 +41,21 @@ const MaterialRunboxActionMenu = ({
       vertical: 'top',
       horizontal: 'right'
     },
-    onClose: handleMenuClose
-  }, React.createElement(MaterialRunboxActionShare, {
-    handleMenuClose: handleMenuClose
-  }), React.createElement(MaterialRunboxActionRestart, {
-    runbox: runbox,
-    runtime: runtime,
-    courseId: courseId,
-    refetch: refetch,
-    handleMenuClose: handleMenuClose
-  }), React.createElement(MaterialRunboxActionReset, {
-    runtime: runtime,
-    courseId: courseId,
-    handleMenuClose: handleMenuClose
-  }));
+    onClose: handleMenuClose,
+    children: [jsx(MaterialRunboxActionShare, {
+      handleMenuClose: handleMenuClose
+    }), jsx(MaterialRunboxActionRestart, {
+      runbox: runbox,
+      runtime: runtime,
+      courseId: courseId,
+      refetch: refetch,
+      handleMenuClose: handleMenuClose
+    }), jsx(MaterialRunboxActionReset, {
+      runtime: runtime,
+      courseId: courseId,
+      handleMenuClose: handleMenuClose
+    })]
+  });
 };
 
 export { MaterialRunboxActionMenu as default };

package/es/components/material-runbox/actions/MaterialRunboxActionReset.js

@@ -1,3 +1,5 @@
+import { slicedToArray as _slicedToArray, asyncToGenerator as _asyncToGenerator, regeneratorRuntime as _regeneratorRuntime } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
 import React from 'react';
 import { useRawEliceIntl } from '@elice/intl';
 import { EliceIcon } from '@elice/mui-elements';
@@ -13,108 +15,151 @@ import '../contexts/MaterialRunboxContext.js';
 //
 //
 //
-const MaterialRunboxActionReset = ({
-  runtime,
-  courseId,
-  handleMenuClose
-}) => {
-  const intl = useRawEliceIntl();
-  const {
-    enqueueSnackbar
-  } = useSnackbar();
-  const materialRunboxApi = useMaterialRunboxApiContext();
-  const [isLoading, setLoading] = React.useState(false);
-  const [isDialogOpened, setDialogOpened] = React.useState(false);
-  const {
-    isLastCommandRunning,
-    setCommandIdToPing
-  } = useMaterialRunboxCommandContext();
+var MaterialRunboxActionReset = function MaterialRunboxActionReset(_ref) {
+  var runtime = _ref.runtime,
+    courseId = _ref.courseId;
+    _ref.handleMenuClose;
+  var intl = useRawEliceIntl();
+  var _useSnackbar = useSnackbar(),
+    enqueueSnackbar = _useSnackbar.enqueueSnackbar;
+  var materialRunboxApi = useMaterialRunboxApiContext();
+  var _React$useState = React.useState(false),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    isLoading = _React$useState2[0],
+    setLoading = _React$useState2[1];
+  var _React$useState3 = React.useState(false),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    isDialogOpened = _React$useState4[0],
+    setDialogOpened = _React$useState4[1];
+  var _useMaterialRunboxCom = useMaterialRunboxCommandContext(),
+    isLastCommandRunning = _useMaterialRunboxCom.isLastCommandRunning,
+    setCommandIdToPing = _useMaterialRunboxCom.setCommandIdToPing;
   /**
    *
    */
-  const handleDialogClose = () => {
+  var handleDialogClose = function handleDialogClose() {
     setDialogOpened(false);
   };
   /**
    *
    */
-  const handleReset = async () => {
-    setLoading(true);
-    try {
-      const runtimeId = runtime === null || runtime === void 0 ? void 0 : runtime.id;
-      const {
-        id: commentId
-      } = await materialRunboxApi.runtime.runtimeRuntimeIdCommandPost({
-        runtimeId,
-        eliceCourseId: courseId,
-        runboxCommandPostRequest: {
-          commandType: CommandType.ProjectFileReset
+  var handleReset = /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+      var runtimeId, _yield$materialRunbox, commentId;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            setLoading(true);
+            _context.prev = 1;
+            runtimeId = runtime === null || runtime === void 0 ? void 0 : runtime.id;
+            _context.next = 5;
+            return materialRunboxApi.runtime.runtimeRuntimeIdCommandPost({
+              runtimeId: runtimeId,
+              eliceCourseId: courseId,
+              runboxCommandPostRequest: {
+                commandType: CommandType.ProjectFileReset
+              }
+            });
+          case 5:
+            _yield$materialRunbox = _context.sent;
+            commentId = _yield$materialRunbox.id;
+            setCommandIdToPing(commentId);
+            handleDialogClose();
+            _context.next = 14;
+            break;
+          case 11:
+            _context.prev = 11;
+            _context.t0 = _context["catch"](1);
+            enqueueSnackbar(intl.formatMessage({
+              id: 'runbox.action.reset.noti.error'
+            }), {
+              variant: 'error'
+            });
+          case 14:
+            _context.prev = 14;
+            setLoading(false);
+            return _context.finish(14);
+          case 17:
+          case "end":
+            return _context.stop();
         }
-      });
-      setCommandIdToPing(commentId);
-      handleDialogClose();
-    } catch (err) {
-      enqueueSnackbar(intl.formatMessage({
-        id: 'runbox.action.reset.noti.error'
-      }), {
-        variant: 'error'
-      });
-    } finally {
-      setLoading(false);
-    }
-  };
+      }, _callee, null, [[1, 11, 14, 17]]);
+    }));
+    return function handleReset() {
+      return _ref2.apply(this, arguments);
+    };
+  }();
   /**
    *
    */
-  const renderResetMenuItem = () => {
-    return React.createElement(MenuItem, {
-      onClick: () => setDialogOpened(true),
-      disabled: isLastCommandRunning
-    }, React.createElement(ListItemIcon, null, React.createElement(EliceIcon, {
-      icon: faRefresh
-    })), React.createElement(ListItemText, null, intl.formatMessage({
-      id: 'runbox.action.reset.title'
-    })));
+  var renderResetMenuItem = function renderResetMenuItem() {
+    return jsxs(MenuItem, {
+      onClick: function onClick() {
+        return setDialogOpened(true);
+      },
+      disabled: isLastCommandRunning,
+      children: [jsx(ListItemIcon, {
+        children: jsx(EliceIcon, {
+          icon: faRefresh
+        })
+      }), jsx(ListItemText, {
+        children: intl.formatMessage({
+          id: 'runbox.action.reset.title'
+        })
+      })]
+    });
   };
   /**
    *
    */
-  const renderConfirmDialog = () => {
+  var renderConfirmDialog = function renderConfirmDialog() {
     if (!isDialogOpened) {
       return null;
     }
-    return React.createElement(Dialog, {
+    return jsxs(Dialog, {
       open: true,
       maxWidth: "xs",
       fullWidth: true,
-      onClose: handleDialogClose
-    }, React.createElement(DialogTitle, null, intl.formatMessage({
-      id: 'runbox.action.reset.title'
-    })), React.createElement(DialogContent, null, React.createElement(DialogContentText, {
-      sx: {
-        whiteSpace: 'pre-line'
-      }
-    }, intl.formatMessage({
-      id: 'runbox.action.reset.dialog.description'
-    }))), React.createElement(DialogActions, null, React.createElement(Button, {
-      color: "inherit",
-      disabled: isLoading,
-      onClick: handleDialogClose
-    }, intl.formatMessage({
-      id: 'runbox.common.close'
-    })), React.createElement(LoadingButton, {
-      variant: "contained",
-      color: "warning",
-      loading: isLoading || isLastCommandRunning,
-      onClick: handleReset
-    }, intl.formatMessage({
-      id: 'runbox.action.reset.dialog.actions.confirm'
-    }))));
+      onClose: handleDialogClose,
+      children: [jsx(DialogTitle, {
+        children: intl.formatMessage({
+          id: 'runbox.action.reset.title'
+        })
+      }), jsx(DialogContent, {
+        children: jsx(DialogContentText, {
+          sx: {
+            whiteSpace: 'pre-line'
+          },
+          children: intl.formatMessage({
+            id: 'runbox.action.reset.dialog.description'
+          })
+        })
+      }), jsxs(DialogActions, {
+        children: [jsx(Button, {
+          color: "inherit",
+          disabled: isLoading,
+          onClick: handleDialogClose,
+          children: intl.formatMessage({
+            id: 'runbox.common.close'
+          })
+        }), jsx(LoadingButton, {
+          variant: "contained",
+          color: "warning",
+          loading: isLoading || isLastCommandRunning,
+          onClick: handleReset,
+          children: intl.formatMessage({
+            id: 'runbox.action.reset.dialog.actions.confirm'
+          })
+        })]
+      })]
+    });
   };
   //
   //
   //
-  return React.createElement(React.Fragment, null, renderResetMenuItem(), renderConfirmDialog());
+  return jsxs(Fragment, {
+    children: [renderResetMenuItem(), renderConfirmDialog()]
+  });
 };
 
 export { MaterialRunboxActionReset as default };

package/es/components/material-runbox/actions/MaterialRunboxActionRestart.js

@@ -1,3 +1,5 @@
+import { slicedToArray as _slicedToArray } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
 import React from 'react';
 import { useRawEliceIntl } from '@elice/intl';
 import { EliceIcon } from '@elice/mui-elements';
@@ -9,35 +11,41 @@ import { useRunboxControl } from '../hooks/useRunboxControl.js';
 //
 //
 //
-const MaterialRunboxActionRestart = ({
-  runbox,
-  courseId,
-  refetch,
-  handleMenuClose
-}) => {
-  const intl = useRawEliceIntl();
-  const [isLoading, setIsLoading] = React.useState(false);
-  const [isDialogOpened, setDialogOpened] = React.useState(false);
+var MaterialRunboxActionRestart = function MaterialRunboxActionRestart(_ref) {
+  var runbox = _ref.runbox,
+    courseId = _ref.courseId,
+    refetch = _ref.refetch,
+    handleMenuClose = _ref.handleMenuClose;
+  var intl = useRawEliceIntl();
+  var _React$useState = React.useState(false),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    isLoading = _React$useState2[0],
+    setIsLoading = _React$useState2[1];
+  var _React$useState3 = React.useState(false),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    isDialogOpened = _React$useState4[0],
+    setDialogOpened = _React$useState4[1];
   // restart
-  const {
-    start
-  } = useRunboxControl({
-    runbox,
-    courseId,
-    refetch
-  });
+  var _useRunboxControl = useRunboxControl({
+      runbox: runbox,
+      courseId: courseId,
+      refetch: refetch
+    }),
+    start = _useRunboxControl.start;
   /**
    *
    */
-  const handleDialogClose = () => {
+  var handleDialogClose = function handleDialogClose() {
     setDialogOpened(false);
   };
   /**
    *
    */
-  const handleRestartAction = () => {
+  var handleRestartAction = function handleRestartAction() {
     setIsLoading(true);
-    start(true).catch(() => void 0).finally(() => {
+    start(true).catch(function () {
+      return void 0;
+    }).finally(function () {
       handleDialogClose();
       handleMenuClose();
       setIsLoading(false);
@@ -46,54 +54,73 @@ const MaterialRunboxActionRestart = ({
   /**
    *
    */
-  const renderRestartMenuItem = () => {
-    return React.createElement(MenuItem, {
-      onClick: () => setDialogOpened(true)
-    }, React.createElement(ListItemIcon, null, React.createElement(EliceIcon, {
-      icon: faRotateRight
-    })), React.createElement(ListItemText, null, intl.formatMessage({
-      id: 'runbox.action.restart.title'
-    })));
+  var renderRestartMenuItem = function renderRestartMenuItem() {
+    return jsxs(MenuItem, {
+      onClick: function onClick() {
+        return setDialogOpened(true);
+      },
+      children: [jsx(ListItemIcon, {
+        children: jsx(EliceIcon, {
+          icon: faRotateRight
+        })
+      }), jsx(ListItemText, {
+        children: intl.formatMessage({
+          id: 'runbox.action.restart.title'
+        })
+      })]
+    });
   };
   /**
    *
    */
-  const renderConfirmDialog = () => {
+  var renderConfirmDialog = function renderConfirmDialog() {
     if (!isDialogOpened) {
       return null;
     }
-    return React.createElement(Dialog, {
+    return jsxs(Dialog, {
       maxWidth: "xs",
       open: true,
       fullWidth: true,
-      onClose: handleDialogClose
-    }, React.createElement(DialogTitle, null, intl.formatMessage({
-      id: 'runbox.action.restart.title'
-    })), React.createElement(DialogContent, null, React.createElement(DialogContentText, {
-      sx: {
-        whiteSpace: 'pre-line'
-      }
-    }, intl.formatMessage({
-      id: 'runbox.action.restart.dialog.description'
-    }))), React.createElement(DialogActions, null, React.createElement(Button, {
-      color: "inherit",
-      disabled: isLoading,
-      onClick: handleDialogClose
-    }, intl.formatMessage({
-      id: 'runbox.common.close'
-    })), React.createElement(LoadingButton, {
-      variant: "contained",
-      color: "warning",
-      loading: isLoading,
-      onClick: handleRestartAction
-    }, intl.formatMessage({
-      id: 'runbox.action.restart.dialog.actions.confirm'
-    }))));
+      onClose: handleDialogClose,
+      children: [jsx(DialogTitle, {
+        children: intl.formatMessage({
+          id: 'runbox.action.restart.title'
+        })
+      }), jsx(DialogContent, {
+        children: jsx(DialogContentText, {
+          sx: {
+            whiteSpace: 'pre-line'
+          },
+          children: intl.formatMessage({
+            id: 'runbox.action.restart.dialog.description'
+          })
+        })
+      }), jsxs(DialogActions, {
+        children: [jsx(Button, {
+          color: "inherit",
+          disabled: isLoading,
+          onClick: handleDialogClose,
+          children: intl.formatMessage({
+            id: 'runbox.common.close'
+          })
+        }), jsx(LoadingButton, {
+          variant: "contained",
+          color: "warning",
+          loading: isLoading,
+          onClick: handleRestartAction,
+          children: intl.formatMessage({
+            id: 'runbox.action.restart.dialog.actions.confirm'
+          })
+        })]
+      })]
+    });
   };
   //
   //
   //
-  return React.createElement(React.Fragment, null, renderRestartMenuItem(), renderConfirmDialog());
+  return jsxs(Fragment, {
+    children: [renderRestartMenuItem(), renderConfirmDialog()]
+  });
 };
 
 export { MaterialRunboxActionRestart as default };

package/es/components/material-runbox/actions/MaterialRunboxActionShare.js

@@ -1,3 +1,5 @@
+import { slicedToArray as _slicedToArray } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { jsxs, jsx } from 'react/jsx-runtime';
 import React from 'react';
 import { useCopyToClipboard } from 'react-use';
 import { useRawEliceIntl } from '@elice/intl';
@@ -13,44 +15,50 @@ import { useMaterialRunboxContext } from '../contexts/MaterialRunboxContext.js';
 //
 //
 //
-const MaterialRunboxActionShare = ({
-  handleMenuClose
-}) => {
-  const intl = useRawEliceIntl();
-  const {
-    enqueueSnackbar
-  } = useSnackbar();
-  const {
-    enableUrlShare
-  } = useMaterialRunboxContext();
-  const {
-    url
-  } = useEliceRunboxRunning();
-  const [{
-    value: clipboardValue,
-    error
-  }, copy] = useCopyToClipboard();
-  const [isClipboardCopied, setClipboardCopied] = React.useState(false);
+var MaterialRunboxActionShare = function MaterialRunboxActionShare(_ref) {
+  var handleMenuClose = _ref.handleMenuClose;
+  var intl = useRawEliceIntl();
+  var _useSnackbar = useSnackbar(),
+    enqueueSnackbar = _useSnackbar.enqueueSnackbar;
+  var _useMaterialRunboxCon = useMaterialRunboxContext(),
+    enableUrlShare = _useMaterialRunboxCon.enableUrlShare;
+  var _useEliceRunboxRunnin = useEliceRunboxRunning(),
+    url = _useEliceRunboxRunnin.url;
+  var _useCopyToClipboard = useCopyToClipboard(),
+    _useCopyToClipboard2 = _slicedToArray(_useCopyToClipboard, 2),
+    _useCopyToClipboard2$ = _useCopyToClipboard2[0],
+    clipboardValue = _useCopyToClipboard2$.value,
+    error = _useCopyToClipboard2$.error,
+    copy = _useCopyToClipboard2[1];
+  var _React$useState = React.useState(false),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    isClipboardCopied = _React$useState2[0],
+    setClipboardCopied = _React$useState2[1];
   /**
    *
    */
-  const renderShareMenuItem = () => {
+  var renderShareMenuItem = function renderShareMenuItem() {
     if (!enableUrlShare) {
       return null;
     }
-    return React.createElement(MenuItem, {
+    return jsxs(MenuItem, {
       disabled: !url,
-      onClick: handleShareAction
-    }, React.createElement(ListItemIcon, null, React.createElement(EliceIcon, {
-      icon: faLinkSimple
-    })), React.createElement(ListItemText, null, intl.formatMessage({
-      id: 'runbox.action.share.title'
-    })));
+      onClick: handleShareAction,
+      children: [jsx(ListItemIcon, {
+        children: jsx(EliceIcon, {
+          icon: faLinkSimple
+        })
+      }), jsx(ListItemText, {
+        children: intl.formatMessage({
+          id: 'runbox.action.share.title'
+        })
+      })]
+    });
   };
   /**
    *
    */
-  const handleShareAction = () => {
+  var handleShareAction = function handleShareAction() {
     if (url) {
       copy(url);
       if (!error) {
@@ -62,7 +70,7 @@ const MaterialRunboxActionShare = ({
   //
   //
   //
-  React.useEffect(() => {
+  React.useEffect(function () {
     if (!isClipboardCopied) {
       return;
     }

package/es/components/material-runbox/contexts/MaterialRunboxApiContext.js

@@ -1,39 +1,47 @@
+import { slicedToArray as _slicedToArray } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { jsx } from 'react/jsx-runtime';
 import React from 'react';
 import { RunboxApi, RuntimeApi, RuntimeTemplateApi } from '@elice/openapi-client-material-runbox';
 
 //
 //
 //
-const MaterialRunboxApiContext = React.createContext({});
-const useMaterialRunboxApiContext = () => {
+var MaterialRunboxApiContext = React.createContext({});
+var useMaterialRunboxApiContext = function useMaterialRunboxApiContext() {
   return React.useContext(MaterialRunboxApiContext);
 };
 //
 //
 //
-const MaterialRunboxApiContextProvider = ({
-  children,
-  eliceMaterialRunboxApiConfiguration
-}) => {
-  const createMaterialRunboxApi = () => Object.freeze({
-    runbox: new RunboxApi(eliceMaterialRunboxApiConfiguration),
-    runtime: new RuntimeApi(eliceMaterialRunboxApiConfiguration),
-    runtimeTemplate: new RuntimeTemplateApi(eliceMaterialRunboxApiConfiguration)
-  });
+var MaterialRunboxApiContextProvider = function MaterialRunboxApiContextProvider(_ref) {
+  var children = _ref.children,
+    eliceMaterialRunboxApiConfiguration = _ref.eliceMaterialRunboxApiConfiguration;
+  var createMaterialRunboxApi = function createMaterialRunboxApi() {
+    return Object.freeze({
+      runbox: new RunboxApi(eliceMaterialRunboxApiConfiguration),
+      runtime: new RuntimeApi(eliceMaterialRunboxApiConfiguration),
+      runtimeTemplate: new RuntimeTemplateApi(eliceMaterialRunboxApiConfiguration)
+    });
+  };
   //
   //
   //
-  const [materialRunboxApi, setMaterialRunboxApi] = React.useState(createMaterialRunboxApi);
+  var _React$useState = React.useState(createMaterialRunboxApi),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    materialRunboxApi = _React$useState2[0],
+    setMaterialRunboxApi = _React$useState2[1];
   //
   //
   //
-  React.useEffect(() => setMaterialRunboxApi(createMaterialRunboxApi),
+  React.useEffect(function () {
+    return setMaterialRunboxApi(createMaterialRunboxApi);
+  },
   // eslint-disable-next-line react-hooks/exhaustive-deps
   [eliceMaterialRunboxApiConfiguration]);
   //
   //
   //
-  return React.createElement(MaterialRunboxApiContext.Provider, {
+  return jsx(MaterialRunboxApiContext.Provider, {
     children: children,
     value: materialRunboxApi
   });