@elice/material-runbox 1.260908.0 → 1.260910.0

package/cjs/components/material-runbox/disk/MaterialRunboxEnvResetButton.js

@@ -0,0 +1,151 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../../../_virtual/_rollupPluginBabelHelpers.js');
+var tslib = require('tslib');
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var intl = require('@elice/intl');
+var muiXSnackbar = require('@elice/mui-x-snackbar');
+var lab = require('@mui/lab');
+var material = require('@mui/material');
+var theme = require('../theme.js');
+var MaterialRunboxEnvResetDialog = require('./MaterialRunboxEnvResetDialog.js');
+var MaterialRunboxApiContext = require('../contexts/MaterialRunboxApiContext.js');
+var MaterialRunboxControlContext = require('../contexts/MaterialRunboxControlContext.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultCompat(React);
+
+//
+//
+//
+var MaterialRunboxEnvResetButton = function MaterialRunboxEnvResetButton(_a) {
+  var runtimeTemplateId = _a.runtimeTemplateId,
+    courseId = _a.courseId,
+    userId = _a.userId,
+    onSuccess = _a.onSuccess,
+    props = tslib.__rest(_a, ["runtimeTemplateId", "courseId", "userId", "onSuccess"]);
+  var intl$1 = intl.useRawEliceIntl();
+  var _useSnackbar = muiXSnackbar.useSnackbar(),
+    enqueueSnackbar = _useSnackbar.enqueueSnackbar;
+  var materialRunboxApi = MaterialRunboxApiContext.useMaterialRunboxApiContext();
+  var _useMaterialRunboxCon = MaterialRunboxControlContext.useMaterialRunboxControlContext(),
+    startRuntime = _useMaterialRunboxCon.start;
+  var _React$useState = React__default.default.useState(false),
+    _React$useState2 = _rollupPluginBabelHelpers.slicedToArray(_React$useState, 2),
+    isDialogOpened = _React$useState2[0],
+    setDialogOpened = _React$useState2[1];
+  var _React$useState3 = React__default.default.useState(false),
+    _React$useState4 = _rollupPluginBabelHelpers.slicedToArray(_React$useState3, 2),
+    isResetting = _React$useState4[0],
+    setResetting = _React$useState4[1];
+  /**
+   *
+   */
+  var handleConfirm = /*#__PURE__*/function () {
+    var _ref = _rollupPluginBabelHelpers.asyncToGenerator(/*#__PURE__*/_rollupPluginBabelHelpers.regenerator().m(function _callee() {
+      var _yield$materialRunbox, _yield$materialRunbox2, runtime;
+      return _rollupPluginBabelHelpers.regenerator().w(function (_context) {
+        while (1) switch (_context.p = _context.n) {
+          case 0:
+            setDialogOpened(false);
+            setResetting(true);
+            _context.p = 1;
+            _context.n = 2;
+            return materialRunboxApi.runtime.runtimeGet({
+              filterRuntimeTemplateId: runtimeTemplateId,
+              skip: 0,
+              count: 1,
+              userId: userId,
+              eliceCourseId: courseId
+            });
+          case 2:
+            _yield$materialRunbox = _context.v;
+            _yield$materialRunbox2 = _rollupPluginBabelHelpers.slicedToArray(_yield$materialRunbox, 1);
+            runtime = _yield$materialRunbox2[0];
+            if (runtime) {
+              _context.n = 3;
+              break;
+            }
+            enqueueSnackbar(intl$1.formatMessage({
+              id: 'runbox.disk.env_reset.noti.no_runtime'
+            }), {
+              variant: 'error'
+            });
+            return _context.a(2);
+          case 3:
+            _context.n = 4;
+            return materialRunboxApi.runtime.runtimeRuntimeIdDiskResetPost({
+              runtimeId: runtime.id,
+              eliceCourseId: courseId
+            });
+          case 4:
+            enqueueSnackbar(intl$1.formatMessage({
+              id: 'runbox.disk.env_reset.noti.success'
+            }), {
+              variant: 'success'
+            });
+            onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess();
+            // The reset replaces the disk, which the server can only do with the
+            // runtime detached, so the session is always gone by now. Start it back
+            // up so the learner lands on the practice screen instead of a dead one.
+            _context.n = 5;
+            return startRuntime({
+              force: true,
+              runPreCheck: false
+            });
+          case 5:
+            _context.n = 7;
+            break;
+          case 6:
+            _context.p = 6;
+            _context.v;
+            enqueueSnackbar(intl$1.formatMessage({
+              id: 'runbox.disk.env_reset.noti.error'
+            }), {
+              variant: 'error'
+            });
+          case 7:
+            _context.p = 7;
+            setResetting(false);
+            return _context.f(7);
+          case 8:
+            return _context.a(2);
+        }
+      }, _callee, null, [[1, 6, 7, 8]]);
+    }));
+    return function handleConfirm() {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  //
+  //
+  //
+  return jsxRuntime.jsxs(jsxRuntime.Fragment, {
+    children: [jsxRuntime.jsx(lab.LoadingButton, Object.assign({}, props, {
+      loading: isResetting,
+      onClick: function onClick() {
+        return setDialogOpened(true);
+      },
+      children: intl$1.formatMessage({
+        id: 'runbox.disk.env_reset.title'
+      })
+    })), jsxRuntime.jsx(material.ThemeProvider, {
+      theme: theme.runboxDarkTheme,
+      children: jsxRuntime.jsx(MaterialRunboxEnvResetDialog.default, {
+        open: isDialogOpened,
+        onClose: function onClose() {
+          return setDialogOpened(false);
+        },
+        onConfirm: function onConfirm() {
+          return void handleConfirm();
+        }
+      })
+    })]
+  });
+};
+
+exports.default = MaterialRunboxEnvResetButton;

package/cjs/components/material-runbox/disk/MaterialRunboxEnvResetDialog.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+export interface MaterialRunboxEnvResetDialogProps {
+    open: boolean;
+    onClose: () => void;
+    onConfirm: () => void;
+}
+/**
+ * Confirms clearing the practice environment. The checkbox is the explicit
+ * acknowledgement `[R-3]` asks for: the delete action stays disabled until it
+ * is ticked.
+ */
+declare const MaterialRunboxEnvResetDialog: React.FC<MaterialRunboxEnvResetDialogProps>;
+export default MaterialRunboxEnvResetDialog;

package/cjs/components/material-runbox/disk/MaterialRunboxEnvResetDialog.js

@@ -0,0 +1,98 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../../../_virtual/_rollupPluginBabelHelpers.js');
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var intl = require('@elice/intl');
+var muiElements = require('@elice/mui-elements');
+var proSolidSvgIcons = require('@fortawesome/pro-solid-svg-icons');
+var material = require('@mui/material');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultCompat(React);
+
+//
+//
+//
+/**
+ * Confirms clearing the practice environment. The checkbox is the explicit
+ * acknowledgement `[R-3]` asks for: the delete action stays disabled until it
+ * is ticked.
+ */
+var MaterialRunboxEnvResetDialog = function MaterialRunboxEnvResetDialog(_ref) {
+  var open = _ref.open,
+    onClose = _ref.onClose,
+    onConfirm = _ref.onConfirm;
+  var intl$1 = intl.useRawEliceIntl();
+  var _React$useState = React__default.default.useState(false),
+    _React$useState2 = _rollupPluginBabelHelpers.slicedToArray(_React$useState, 2),
+    isAcknowledged = _React$useState2[0],
+    setAcknowledged = _React$useState2[1];
+  React__default.default.useEffect(function () {
+    if (!open) {
+      setAcknowledged(false);
+    }
+  }, [open]);
+  //
+  //
+  //
+  return jsxRuntime.jsxs(material.Dialog, {
+    fullWidth: true,
+    open: open,
+    maxWidth: "xs",
+    onClose: onClose,
+    children: [jsxRuntime.jsx(material.DialogTitle, {
+      children: jsxRuntime.jsxs(material.Stack, {
+        direction: "row",
+        alignItems: "center",
+        gap: "0.5rem",
+        children: [jsxRuntime.jsx(muiElements.EliceIcon, {
+          icon: proSolidSvgIcons.faCircleExclamation,
+          color: "error"
+        }), intl$1.formatMessage({
+          id: 'runbox.disk.env_reset.dialog.title'
+        })]
+      })
+    }), jsxRuntime.jsxs(material.DialogContent, {
+      children: [jsxRuntime.jsx(material.DialogContentText, {
+        whiteSpace: "pre-line",
+        children: intl$1.formatMessage({
+          id: 'runbox.disk.env_reset.dialog.description'
+        })
+      }), jsxRuntime.jsx(material.FormControlLabel, {
+        sx: {
+          marginTop: '1rem'
+        },
+        control: jsxRuntime.jsx(material.Checkbox, {
+          checked: isAcknowledged,
+          onChange: function onChange(e) {
+            return setAcknowledged(e.target.checked);
+          }
+        }),
+        label: intl$1.formatMessage({
+          id: 'runbox.disk.env_reset.dialog.acknowledge'
+        })
+      })]
+    }), jsxRuntime.jsxs(material.DialogActions, {
+      children: [jsxRuntime.jsx(material.Button, {
+        color: "inherit",
+        onClick: onClose,
+        children: intl$1.formatMessage({
+          id: 'runbox.disk.env_reset.dialog.actions.cancel'
+        })
+      }), jsxRuntime.jsx(material.Button, {
+        color: "error",
+        disabled: !isAcknowledged,
+        onClick: onConfirm,
+        children: intl$1.formatMessage({
+          id: 'runbox.disk.env_reset.dialog.actions.confirm'
+        })
+      })]
+    })]
+  });
+};
+
+exports.default = MaterialRunboxEnvResetDialog;

package/cjs/components/material-runbox/disk/index.d.ts

@@ -1 +1,8 @@
-export { default as MaterialRunboxDiskAlmostFullSnackbar } from './MaterialRunboxDiskAlmostFullSnackbar';
+export { default as MaterialRunboxDiskUsageAlert } from './MaterialRunboxDiskUsageAlert';
+export { default as MaterialRunboxDiskUsageDialog } from './MaterialRunboxDiskUsageDialog';
+export { default as MaterialRunboxEnvResetButton } from './MaterialRunboxEnvResetButton';
+export { default as MaterialRunboxEnvResetDialog } from './MaterialRunboxEnvResetDialog';
+export type { MaterialRunboxDiskUsageAlertProps } from './MaterialRunboxDiskUsageAlert';
+export type { MaterialRunboxDiskUsageDialogProps } from './MaterialRunboxDiskUsageDialog';
+export type { MaterialRunboxEnvResetButtonProps } from './MaterialRunboxEnvResetButton';
+export type { MaterialRunboxEnvResetDialogProps } from './MaterialRunboxEnvResetDialog';

package/cjs/components/material-runbox/disk/index.js

@@ -1,7 +1,13 @@
 'use strict';
 
-var MaterialRunboxDiskAlmostFullSnackbar = require('./MaterialRunboxDiskAlmostFullSnackbar.js');
+var MaterialRunboxDiskUsageAlert = require('./MaterialRunboxDiskUsageAlert.js');
+var MaterialRunboxDiskUsageDialog = require('./MaterialRunboxDiskUsageDialog.js');
+var MaterialRunboxEnvResetButton = require('./MaterialRunboxEnvResetButton.js');
+var MaterialRunboxEnvResetDialog = require('./MaterialRunboxEnvResetDialog.js');
 
 
 
-exports.MaterialRunboxDiskAlmostFullSnackbar = MaterialRunboxDiskAlmostFullSnackbar.default;
+exports.MaterialRunboxDiskUsageAlert = MaterialRunboxDiskUsageAlert.default;
+exports.MaterialRunboxDiskUsageDialog = MaterialRunboxDiskUsageDialog.default;
+exports.MaterialRunboxEnvResetButton = MaterialRunboxEnvResetButton.default;
+exports.MaterialRunboxEnvResetDialog = MaterialRunboxEnvResetDialog.default;

package/cjs/components/material-runbox/hooks/index.d.ts

@@ -1,4 +1,7 @@
 export * from './useRunboxControl';
+export * from './useRunboxSessionEndWarning';
 export * from './useRunboxTimer';
 export * from './useInfiniteRunboxRunboxIdGrade';
 export * from './useMaterialRunboxRunboxIdStarterGet';
+export * from './useRunboxNetworkStatus';
+export * from './useRunboxDiskUsage';

package/cjs/components/material-runbox/hooks/index.js

@@ -1,9 +1,12 @@
 'use strict';
 
 var useRunboxControl = require('./useRunboxControl.js');
+var useRunboxSessionEndWarning = require('./useRunboxSessionEndWarning.js');
 var useRunboxTimer = require('./useRunboxTimer.js');
 var useInfiniteRunboxRunboxIdGrade = require('./useInfiniteRunboxRunboxIdGrade.js');
 var useMaterialRunboxRunboxIdStarterGet = require('./useMaterialRunboxRunboxIdStarterGet.js');
+var useRunboxNetworkStatus = require('./useRunboxNetworkStatus.js');
+var useRunboxDiskUsage = require('./useRunboxDiskUsage.js');
 
 
 
@@ -12,6 +15,17 @@ Object.defineProperty(exports, "RunboxPreCheckResultType", {
 	get: function () { return useRunboxControl.RunboxPreCheckResultType; }
 });
 exports.useRunboxControl = useRunboxControl.useRunboxControl;
+exports.QUOTA_ALMOST_END_MINUTES = useRunboxSessionEndWarning.QUOTA_ALMOST_END_MINUTES;
+exports.QUOTA_PER_SESSION_ALMOST_END_MINUTES = useRunboxSessionEndWarning.QUOTA_PER_SESSION_ALMOST_END_MINUTES;
+exports.useRunboxSessionEndWarning = useRunboxSessionEndWarning.useRunboxSessionEndWarning;
 exports.useRunboxTimer = useRunboxTimer.useRunboxTimer;
 exports.useInfiniteRunboxRunboxIdGrade = useInfiniteRunboxRunboxIdGrade.useInfiniteRunboxRunboxIdGrade;
 exports.useMaterialRunboxRunboxIdStarterGet = useMaterialRunboxRunboxIdStarterGet.useMaterialRunboxRunboxIdStarterGet;
+Object.defineProperty(exports, "RunboxNetworkStatus", {
+	enumerable: true,
+	get: function () { return useRunboxNetworkStatus.RunboxNetworkStatus; }
+});
+exports.useRunboxNetworkStatus = useRunboxNetworkStatus.useRunboxNetworkStatus;
+exports.DISK_USAGE_ERROR_RATIO = useRunboxDiskUsage.DISK_USAGE_ERROR_RATIO;
+exports.DISK_USAGE_WARNING_RATIO = useRunboxDiskUsage.DISK_USAGE_WARNING_RATIO;
+exports.useRunboxDiskUsage = useRunboxDiskUsage.useRunboxDiskUsage;

package/cjs/components/material-runbox/hooks/useRunboxControl.d.ts

@@ -10,17 +10,18 @@ export type RunboxPreCheckResult = {
     type: RunboxPreCheckResultType.RuntimeRunningOnOtherRunbox;
     runningRunbox: RunningRunbox;
 };
-type UseRunboxControlProps = Pick<RuntimeProps, 'runbox' | 'runtime' | 'courseId' | 'refetch' | 'userId' | 'studentUserId' | 'isTutoring'>;
-interface UseRunboxControlReturn {
+export type UseRunboxControlProps = Pick<RuntimeProps, 'runbox' | 'runtime' | 'courseId' | 'refetch' | 'userId' | 'studentUserId' | 'isTutoring'>;
+export interface UseRunboxControlReturn {
     start: (args?: {
         force?: boolean;
         runPreCheck?: boolean;
     }) => Promise<void>;
     stop: () => Promise<void>;
+    isStarting: boolean;
+    isStopping: boolean;
     preCheckStatus: RunboxPreCheckResult | null;
 }
 /**
  * Hook for runbox control and status.
  */
 export declare const useRunboxControl: (props: UseRunboxControlProps) => UseRunboxControlReturn;
-export {};

package/cjs/components/material-runbox/hooks/useRunboxControl.js

@@ -35,6 +35,14 @@ var useRunboxControl = function useRunboxControl(props) {
     _useState2 = _rollupPluginBabelHelpers.slicedToArray(_useState, 2),
     preCheckStatus = _useState2[0],
     setPreCheckStatus = _useState2[1];
+  var _useState3 = React.useState(false),
+    _useState4 = _rollupPluginBabelHelpers.slicedToArray(_useState3, 2),
+    isStarting = _useState4[0],
+    setStarting = _useState4[1];
+  var _useState5 = React.useState(false),
+    _useState6 = _rollupPluginBabelHelpers.slicedToArray(_useState5, 2),
+    isStopping = _useState6[0],
+    setStopping = _useState6[1];
   var userId = props.isTutoring ? props.studentUserId : props.userId;
   var preCheck = React.useCallback(/*#__PURE__*/_rollupPluginBabelHelpers.asyncToGenerator(/*#__PURE__*/_rollupPluginBabelHelpers.regenerator().m(function _callee() {
     var runningRunbox;
@@ -87,29 +95,33 @@ var useRunboxControl = function useRunboxControl(props) {
       result,
       _args2 = arguments;
     return _rollupPluginBabelHelpers.regenerator().w(function (_context2) {
-      while (1) switch (_context2.n) {
+      while (1) switch (_context2.p = _context2.n) {
         case 0:
           _ref3 = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : {}, _ref3$force = _ref3.force, force = _ref3$force === void 0 ? false : _ref3$force, _ref3$runPreCheck = _ref3.runPreCheck, runPreCheck = _ref3$runPreCheck === void 0 ? true : _ref3$runPreCheck;
           setPreCheckStatus(null);
-          // Run pre-check if needed.
+          setStarting(true);
+          // try/finally, not a promise finally: a rejected pre-check would skip the
+          // chain below and leave the shared flag stuck for every consumer.
+          _context2.p = 1;
           if (!runPreCheck) {
-            _context2.n = 2;
+            _context2.n = 3;
             break;
           }
-          _context2.n = 1;
+          _context2.n = 2;
           return preCheck();
-        case 1:
+        case 2:
           result = _context2.v;
           // Store to state to display UIs.
           setPreCheckStatus(result);
           // Don't start if pre-check is not passed.
           if (!(result && result.type !== exports.RunboxPreCheckResultType.Passed)) {
-            _context2.n = 2;
+            _context2.n = 3;
             break;
           }
           return _context2.a(2);
-        case 2:
-          return _context2.a(2, runboxStart(function (signal) {
+        case 3:
+          _context2.n = 4;
+          return runboxStart(function (signal) {
             return materialRunboxApi.runbox.runboxRunboxIdStartPost({
               runboxId: props.runbox.id,
               eliceCourseId: props.courseId,
@@ -129,9 +141,15 @@ var useRunboxControl = function useRunboxControl(props) {
                 variant: 'error'
               });
             }
-          }));
+          });
+        case 4:
+          _context2.p = 4;
+          setStarting(false);
+          return _context2.f(4);
+        case 5:
+          return _context2.a(2);
       }
-    }, _callee2);
+    }, _callee2, null, [[1,, 4, 5]]);
   })),
   // eslint-disable-next-line react-hooks/exhaustive-deps
   [props.runbox.id, props.courseId, userId, runboxStart]);
@@ -140,9 +158,12 @@ var useRunboxControl = function useRunboxControl(props) {
    */
   var stop = React.useCallback(/*#__PURE__*/_rollupPluginBabelHelpers.asyncToGenerator(/*#__PURE__*/_rollupPluginBabelHelpers.regenerator().m(function _callee3() {
     return _rollupPluginBabelHelpers.regenerator().w(function (_context3) {
-      while (1) switch (_context3.n) {
+      while (1) switch (_context3.p = _context3.n) {
         case 0:
-          return _context3.a(2, runboxStop(function (signal) {
+          setStopping(true);
+          _context3.p = 1;
+          _context3.n = 2;
+          return runboxStop(function (signal) {
             return materialRunboxApi.runbox.runboxRunboxIdStopPost({
               runboxId: props.runbox.id,
               eliceCourseId: props.courseId,
@@ -156,9 +177,15 @@ var useRunboxControl = function useRunboxControl(props) {
             //
           })["catch"](function (err) {
             if (err.name !== 'AbortError') ;
-          }));
+          });
+        case 2:
+          _context3.p = 2;
+          setStopping(false);
+          return _context3.f(2);
+        case 3:
+          return _context3.a(2);
       }
-    }, _callee3);
+    }, _callee3, null, [[1,, 2, 3]]);
   })),
   // eslint-disable-next-line react-hooks/exhaustive-deps
   [props.runbox.id, props.courseId, runboxStop]);
@@ -167,6 +194,8 @@ var useRunboxControl = function useRunboxControl(props) {
   //
   _return.current.start = start;
   _return.current.stop = stop;
+  _return.current.isStarting = isStarting;
+  _return.current.isStopping = isStopping;
   _return.current.preCheckStatus = preCheckStatus;
   return _return.current;
 };

package/cjs/components/material-runbox/hooks/useRunboxDiskUsage.d.ts

@@ -0,0 +1,16 @@
+/** Matches MUI's `Alert` severity, which is where this value ends up. */
+export type RunboxDiskUsageSeverity = 'warning' | 'error';
+interface UseRunboxDiskUsageReturn {
+    /** `null` below the first threshold, or while the container reports no stats. */
+    severity: RunboxDiskUsageSeverity | null;
+    diskCurrent: number;
+    diskTotal: number;
+}
+export declare const DISK_USAGE_WARNING_RATIO = 0.8;
+export declare const DISK_USAGE_ERROR_RATIO = 0.9;
+/**
+ * Disk usage against the 80% / 90% thresholds. The numbers come from the
+ * container stats stream, so they are only available while the runtime is up.
+ */
+export declare const useRunboxDiskUsage: () => UseRunboxDiskUsageReturn;
+export {};

package/cjs/components/material-runbox/hooks/useRunboxDiskUsage.js

@@ -0,0 +1,50 @@
+'use strict';
+
+var React = require('react');
+var runboxClient = require('@elice/runbox-client');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultCompat(React);
+
+//
+//
+//
+var DISK_USAGE_WARNING_RATIO = 0.8;
+var DISK_USAGE_ERROR_RATIO = 0.9;
+//
+//
+//
+/**
+ * Disk usage against the 80% / 90% thresholds. The numbers come from the
+ * container stats stream, so they are only available while the runtime is up.
+ */
+var useRunboxDiskUsage = function useRunboxDiskUsage() {
+  var _a, _b;
+  var contStats = runboxClient.useEliceRunboxContainerStats();
+  var stats = contStats ? contStats[contStats.length - 1] : null;
+  var diskCurrent = (_a = stats === null || stats === void 0 ? void 0 : stats.diskCurrent) !== null && _a !== void 0 ? _a : 0;
+  var diskTotal = (_b = stats === null || stats === void 0 ? void 0 : stats.diskTotal) !== null && _b !== void 0 ? _b : 0;
+  var severity = React__default.default.useMemo(function () {
+    if (!stats || diskTotal <= 0) {
+      return null;
+    }
+    var ratio = diskCurrent / diskTotal;
+    if (ratio >= DISK_USAGE_ERROR_RATIO) {
+      return 'error';
+    }
+    if (ratio >= DISK_USAGE_WARNING_RATIO) {
+      return 'warning';
+    }
+    return null;
+  }, [stats, diskCurrent, diskTotal]);
+  return {
+    severity: severity,
+    diskCurrent: diskCurrent,
+    diskTotal: diskTotal
+  };
+};
+
+exports.DISK_USAGE_ERROR_RATIO = DISK_USAGE_ERROR_RATIO;
+exports.DISK_USAGE_WARNING_RATIO = DISK_USAGE_WARNING_RATIO;
+exports.useRunboxDiskUsage = useRunboxDiskUsage;

package/cjs/components/material-runbox/hooks/useRunboxNetworkStatus.d.ts

@@ -0,0 +1,14 @@
+export declare enum RunboxNetworkStatus {
+    Good = "good",
+    NotGood = "not_good",
+    Bad = "bad"
+}
+/**
+ * Runbox network quality, derived from the heartbeat round trip.
+ *
+ * `null` until the first sample arrives.
+ */
+export declare const useRunboxNetworkStatus: () => {
+    avgRtt: number | null;
+    status: RunboxNetworkStatus | null;
+};

package/cjs/components/material-runbox/hooks/useRunboxNetworkStatus.js

@@ -0,0 +1,65 @@
+'use strict';
+
+var React = require('react');
+var runboxClient = require('@elice/runbox-client');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultCompat(React);
+
+//
+//
+//
+exports.RunboxNetworkStatus = void 0;
+(function (RunboxNetworkStatus) {
+  RunboxNetworkStatus["Good"] = "good";
+  RunboxNetworkStatus["NotGood"] = "not_good";
+  RunboxNetworkStatus["Bad"] = "bad";
+})(exports.RunboxNetworkStatus || (exports.RunboxNetworkStatus = {}));
+//
+//
+//
+var RTT_THRESHOLD_GOOD = 600; // Fast 3G
+var RTT_THRESHOLD_BAD = 1200; // Slow 3G
+/** A failed heartbeat carries no `__rtt`, which counts as the worst latency. */
+var MISSING_RTT = 1e10;
+//
+//
+//
+/**
+ * Runbox network quality, derived from the heartbeat round trip.
+ *
+ * `null` until the first sample arrives.
+ */
+var useRunboxNetworkStatus = function useRunboxNetworkStatus() {
+  var stats = runboxClient.useEliceRunboxContainerStats();
+  /** Averaged over the newer half, so a recovered connection is not held back. */
+  var avgRtt = React__default.default.useMemo(function () {
+    if (!stats.length) {
+      return null;
+    }
+    var recent = stats.slice(stats.length / 2, stats.length);
+    return recent.reduce(function (acc, stat) {
+      var _a;
+      return acc + ((_a = stat === null || stat === void 0 ? void 0 : stat.__rtt) !== null && _a !== void 0 ? _a : MISSING_RTT);
+    }, 0) / recent.length;
+  }, [stats]);
+  var status = React__default.default.useMemo(function () {
+    if (avgRtt === null) {
+      return null;
+    }
+    if (avgRtt < RTT_THRESHOLD_GOOD) {
+      return exports.RunboxNetworkStatus.Good;
+    }
+    if (avgRtt < RTT_THRESHOLD_BAD) {
+      return exports.RunboxNetworkStatus.NotGood;
+    }
+    return exports.RunboxNetworkStatus.Bad;
+  }, [avgRtt]);
+  return {
+    avgRtt: avgRtt,
+    status: status
+  };
+};
+
+exports.useRunboxNetworkStatus = useRunboxNetworkStatus;

package/cjs/components/material-runbox/hooks/useRunboxSessionEndWarning.d.ts

@@ -0,0 +1,18 @@
+export type RunboxSessionEndWarning = 'quota' | 'quotaPerSession';
+interface UseRunboxSessionEndWarningParams {
+    runboxId: string;
+    /**
+     * Suppress every warning.
+     * @default false
+     */
+    disabled?: boolean;
+}
+interface UseRunboxSessionEndWarningReturn {
+    warning: RunboxSessionEndWarning | null;
+    /** Marks the current warning as seen, which is what closes it. */
+    dismiss: () => void;
+}
+export declare const QUOTA_ALMOST_END_MINUTES = 30;
+export declare const QUOTA_PER_SESSION_ALMOST_END_MINUTES = 10;
+export declare function useRunboxSessionEndWarning({ runboxId, disabled, }: UseRunboxSessionEndWarningParams): UseRunboxSessionEndWarningReturn;
+export {};