dce-reactkit 3.12.3 → 4.0.0-beta.1

package/dist/cjs/index.js

@@ -7,7 +7,6 @@ var freeSolidSvgIcons = require('@fortawesome/free-solid-svg-icons');
 var reactFontawesome = require('@fortawesome/react-fontawesome');
 var ReactDOM = require('react-dom');
 var freeRegularSvgIcons = require('@fortawesome/free-regular-svg-icons');
-var qs = require('qs');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -32,7 +31,6 @@ function _interopNamespace(e) {
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
 var ReactDOM__default = /*#__PURE__*/_interopDefaultLegacy(ReactDOM);
-var qs__default = /*#__PURE__*/_interopDefaultLegacy(qs);
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -59,7 +57,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-// Highest error code = DRK18
+// Highest error code = DRK34
 /**
  * List of error codes built into the react kit
  * @author Gabe Abrams
@@ -69,22 +67,7 @@ var ReactKitErrorCode;
     ReactKitErrorCode["NoResponse"] = "DRK1";
     ReactKitErrorCode["NoCode"] = "DRK2";
     ReactKitErrorCode["SessionExpired"] = "DRK3";
-    ReactKitErrorCode["MissingParameter"] = "DRK4";
-    ReactKitErrorCode["InvalidParameter"] = "DRK5";
-    ReactKitErrorCode["HostNotAllowed"] = "DRK17";
-    ReactKitErrorCode["HostBanned"] = "DRK18";
-    ReactKitErrorCode["WrongCourse"] = "DRK6";
     ReactKitErrorCode["NoCACCLSendRequestFunction"] = "DRK7";
-    ReactKitErrorCode["NoCACCLGetLaunchInfoFunction"] = "DRK8";
-    ReactKitErrorCode["NotTTM"] = "DRK9";
-    ReactKitErrorCode["NotAdmin"] = "DRK10";
-    ReactKitErrorCode["NotAllowedToReviewLogs"] = "DRK11";
-    ReactKitErrorCode["ThemeCheckedBeforeReactKitReady"] = "DRK12";
-    ReactKitErrorCode["SessionExpiredMessageGottenBeforeReactKitReady"] = "DRK13";
-    // Server-to-server requests
-    ReactKitErrorCode["NotConnected"] = "DRK14";
-    ReactKitErrorCode["SelfSigned"] = "DRK15";
-    ReactKitErrorCode["ResponseParseError"] = "DRK16";
 })(ReactKitErrorCode || (ReactKitErrorCode = {}));
 var ReactKitErrorCode$1 = ReactKitErrorCode;
 
@@ -216,98 +199,6 @@ const LogBuiltInMetadata = {
     },
 };
 
-/**
- * Loading spinner/indicator
- * @author Gabe Abrams
- */
-/*------------------------------------------------------------------------*/
-/* -------------------------------- Style ------------------------------- */
-/*------------------------------------------------------------------------*/
-const style$a = `
-/* Container fades in */
-.LoadingSpinner-container {
-  animation-name: LoadingSpinner-container-fade-in;
-  animation-duration: 0.3s;
-  animation-delay: 0.4s;
-  animation-fill-mode: both;
-  animation-timing-function: ease-out;
-}
-@keyframes LoadingSpinner-container-fade-in {
-  0% {
-    opacity: 0;
-  }
-  100% {
-    opacity: 1;
-  }
-}
-
-/* Blips */
-.LoadingSpinner-blip-1,
-.LoadingSpinner-blip-2,
-.LoadingSpinner-blip-3,
-.LoadingSpinner-blip-4 {
-  font-size: 1.8rem;
-  opacity: 0.6;
-  margin-top: 1rem;
-  margin-bottom: 1rem;
-}
-
-/* First Blip */
-.LoadingSpinner-blip-1 {
-  animation: LoadingSpinner-pop-animation 2s infinite;
-}
-
-/* Second Blip */
-.LoadingSpinner-blip-2 {
-  animation: LoadingSpinner-pop-animation 2s infinite;
-  -webkit-animation-delay: 0.1s;
-  animation-delay: 0.1s;
-}
-
-/* Third Blip */
-.LoadingSpinner-blip-3 {
-  animation: LoadingSpinner-pop-animation 2s infinite;
-  animation-delay: 0.2s;
-}
-
-/* Fourth Blip */
-.LoadingSpinner-blip-4 {
-  animation: LoadingSpinner-pop-animation 2s infinite;
-  animation-delay: 0.3s;
-}
-
-/* Pop Animation for Each Blip */
-@keyframes LoadingSpinner-pop-animation {
-  0%  {
-    transform: scale(1.0);
-  }
-  10% {
-    transform: scale(1.5);
-  }
-  30% {
-    transform: scale(1.0);
-  }
-  100% {
-    transform: scale(1.0);
-  }
-}
-`;
-/*------------------------------------------------------------------------*/
-/* ------------------------------ Component ----------------------------- */
-/*------------------------------------------------------------------------*/
-const LoadingSpinner = () => {
-    /*------------------------------------------------------------------------*/
-    /* ------------------------------- Render ------------------------------- */
-    /*------------------------------------------------------------------------*/
-    // Add all four blips to a container
-    return (React__default["default"].createElement("div", { className: "text-center LoadingSpinner LoadingSpinner-container" },
-        React__default["default"].createElement("style", null, style$a),
-        React__default["default"].createElement(reactFontawesome.FontAwesomeIcon, { icon: freeSolidSvgIcons.faCircle, className: "LoadingSpinner-blip-1 me-1" }),
-        React__default["default"].createElement(reactFontawesome.FontAwesomeIcon, { icon: freeSolidSvgIcons.faCircle, className: "LoadingSpinner-blip-2 me-1" }),
-        React__default["default"].createElement(reactFontawesome.FontAwesomeIcon, { icon: freeSolidSvgIcons.faCircle, className: "LoadingSpinner-blip-3 me-1" }),
-        React__default["default"].createElement(reactFontawesome.FontAwesomeIcon, { icon: freeSolidSvgIcons.faCircle, className: "LoadingSpinner-blip-4" })));
-};
-
 /**
  * Wait for a certain number of ms
  * @author Gabe Abrams
@@ -358,6 +249,15 @@ let onInitialized;
 const initialized = new Promise((resolve) => {
     onInitialized = resolve;
 });
+/* ------------ No Server ----------- */
+let noServer = false;
+/**
+ * Check if there is no server for this app
+ * @author Gabe Abrams
+ */
+const appHasNoServer = () => {
+    return noServer;
+};
 /* ---------- Send Request ---------- */
 let storedSendRequest;
 /**
@@ -419,11 +319,13 @@ const initClient = (opts) => {
         storedSendRequest = () => __awaiter(void 0, void 0, void 0, function* () {
             throw new Error('Cannot send requests because there is no server');
         });
+        noServer = true;
     }
     else {
         // Store values
         storedSendRequest = opts.sendRequest;
         sessionExpiredMessage = opts.sessionExpiredMessage;
+        noServer = false;
     }
     // Handle universal parts
     darkModeOn = !!opts.darkModeOn;
@@ -440,7 +342,6 @@ const BASE_Z_INDEX = 1000000000;
 const BASE_Z_INDEX_ON_TOP = 2000000000;
 // Constants
 const MS_TO_ANIMATE = 200; // Animation duration
-const MS_TO_WAIT_BEFORE_SHOWING_LOADING_INDICATOR = 1000;
 // Modal type to list of buttons
 const modalTypeToModalButtonTypes = {
     [ModalType$1.Okay]: [
@@ -554,7 +455,7 @@ const getNextUniqueId = () => {
 /*------------------------------------------------------------------------*/
 /* -------------------------------- Style ------------------------------- */
 /*------------------------------------------------------------------------*/
-const style$9 = `
+const style$a = `
   .Modal-backdrop {
     position: fixed;
     top: 0;
@@ -626,14 +527,13 @@ const Modal = (props) => {
     /*------------------------------------------------------------------------*/
     var _a;
     /* -------------- Props ------------- */
-    const { type = ModalType$1.NoButtons, size = ModalSize$1.Large, title, largeTitle, children, onClose, dontAllowBackdropExit, dontShowXButton, onTopOfOtherModals, isLoading, isLoadingCancelable, } = props;
+    const { type = ModalType$1.NoButtons, size = ModalSize$1.Large, title, largeTitle, children, onClose, dontAllowBackdropExit, dontShowXButton, onTopOfOtherModals, } = props;
     // Determine if no header either
     const noHeader = (!title && type === ModalType$1.NoButtons);
     /* -------------- State ------------- */
     // True if animation is in use
     const [animatingIn, setAnimatingIn] = React.useState(true);
     const [animatingPop, setAnimatingPop] = React.useState(false);
-    const [showModal, setShowModal] = React.useState(false);
     /* -------------- Refs -------------- */
     // Keep track of whether modal is still mounted
     const mounted = React.useRef(false);
@@ -660,16 +560,6 @@ const Modal = (props) => {
             if (mounted.current) {
                 setAnimatingIn(false);
             }
-            if (isLoading) {
-                // wait before showing modal
-                yield waitMs(MS_TO_WAIT_BEFORE_SHOWING_LOADING_INDICATOR);
-                if (mounted.current) {
-                    setShowModal(true);
-                }
-            }
-            else {
-                setShowModal(true);
-            }
         }))();
         return () => {
             mounted.current = false;
@@ -736,15 +626,6 @@ const Modal = (props) => {
     else if (animatingPop) {
         animationClass = 'Modal-animating-pop';
     }
-    // default to show close button when not loading and not show close button when loading
-    // unless downShowXButton or isLoadingCancelable
-    const showCloseButton = (
-    // The modal must have an onClose function
-    onClose
-        // ...and the close button is allowed to be visible
-        && !dontShowXButton
-        // ...and should not be shown if the modal is loading and not cancelable
-        && !(isLoading && !isLoadingCancelable));
     // Render the modal
     const contentToRender = (React__default["default"].createElement("div", { className: "modal show", tabIndex: -1, style: {
             zIndex: baseZIndex,
@@ -753,7 +634,7 @@ const Modal = (props) => {
             left: 0,
             right: 0,
         } },
-        React__default["default"].createElement("style", null, style$9),
+        React__default["default"].createElement("style", null, style$a),
         React__default["default"].createElement("div", { className: `Modal-backdrop ${backdropAnimationClass}`, style: {
                 zIndex: baseZIndex + 1,
             }, onClick: () => __awaiter(void 0, void 0, void 0, function* () {
@@ -771,7 +652,7 @@ const Modal = (props) => {
                 // Handle close
                 handleClose(ModalButtonType$1.Cancel);
             }) }),
-        showModal && (React__default["default"].createElement("div", { className: `modal-dialog modal-${size} ${animationClass} modal-dialog-scrollable modal-dialog-centered`, style: {
+        React__default["default"].createElement("div", { className: `modal-dialog modal-${size} ${animationClass} modal-dialog-scrollable modal-dialog-centered`, style: {
                 zIndex: baseZIndex + 2,
                 // Override sizes for even larger for XL
                 width: (size === ModalSize$1.ExtraLarge
@@ -803,7 +684,7 @@ const Modal = (props) => {
                                 ? '1.6rem'
                                 : undefined),
                         } }, title),
-                    showCloseButton && (React__default["default"].createElement("button", { type: "button", className: "Modal-x-button btn-close", "aria-label": "Close", style: {
+                    (onClose && !dontShowXButton) && (React__default["default"].createElement("button", { type: "button", className: "Modal-x-button btn-close", "aria-label": "Close", style: {
                             backgroundColor: (isDarkModeOn()
                                 ? 'white'
                                 : undefined),
@@ -811,18 +692,14 @@ const Modal = (props) => {
                             // Handle close
                             handleClose(ModalButtonType$1.Cancel);
                         } })))),
-                React__default["default"].createElement("div", { className: "modal-body", style: {
+                children && (React__default["default"].createElement("div", { className: "modal-body", style: {
                         color: (isDarkModeOn()
                             ? 'white'
                             : undefined),
                         backgroundColor: (isDarkModeOn()
                             ? '#444'
                             : undefined),
-                    } }, isLoading
-                    ? (React__default["default"].createElement(React__default["default"].Fragment, null,
-                        React__default["default"].createElement(LoadingSpinner, null),
-                        React__default["default"].createElement("span", { className: "sr-only" }, "Content loading")))
-                    : children),
+                    } }, children)),
                 footer && (React__default["default"].createElement("div", { className: "modal-footer pt-1 pb-1", style: {
                         color: (isDarkModeOn()
                             ? 'white'
@@ -833,7 +710,7 @@ const Modal = (props) => {
                         borderTop: (isDarkModeOn()
                             ? '0.1rem solid gray'
                             : undefined),
-                    } }, footer)))))));
+                    } }, footer))))));
     // Determine which portal to use
     const portalNumber = id.current % NUM_MODAL_PORTALS;
     // Render in a portal
@@ -1004,6 +881,10 @@ const setClientEventMetadataPopulator = (newMetadataPopulator) => {
  */
 const logClientEvent = (opts) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b, _c, _d, _e, _f, _g;
+    // Don't write to the server if there is none
+    if (appHasNoServer()) {
+        return;
+    }
     // Populate metadata
     let metadata = ((_a = opts.metadata) !== null && _a !== void 0 ? _a : {});
     if (metadataPopulator) {
@@ -1400,7 +1281,7 @@ const showSessionExpiredMessage = () => __awaiter(void 0, void 0, void 0, functi
 /*------------------------------------------------------------------------*/
 /* -------------------------------- Style ------------------------------- */
 /*------------------------------------------------------------------------*/
-const style$8 = `
+const style$9 = `
   .AppWrapper-leave-to-url-notice {
     opacity: 0;
 
@@ -1614,13 +1495,105 @@ const AppWrapper = (props) => {
     /* --------------- Main UI -------------- */
     /*----------------------------------------*/
     return (React__default["default"].createElement(React__default["default"].Fragment, null,
-        React__default["default"].createElement("style", null, style$8),
+        React__default["default"].createElement("style", null, style$9),
         React__default["default"].createElement("style", null, tooltipStyle),
         modal,
         customModalPortals,
         body));
 };
 
+/**
+ * Loading spinner/indicator
+ * @author Gabe Abrams
+ */
+/*------------------------------------------------------------------------*/
+/* -------------------------------- Style ------------------------------- */
+/*------------------------------------------------------------------------*/
+const style$8 = `
+/* Container fades in */
+.LoadingSpinner-container {
+  animation-name: LoadingSpinner-container-fade-in;
+  animation-duration: 0.3s;
+  animation-delay: 0.4s;
+  animation-fill-mode: both;
+  animation-timing-function: ease-out;
+}
+@keyframes LoadingSpinner-container-fade-in {
+  0% {
+    opacity: 0;
+  }
+  100% {
+    opacity: 1;
+  }
+}
+
+/* Blips */
+.LoadingSpinner-blip-1,
+.LoadingSpinner-blip-2,
+.LoadingSpinner-blip-3,
+.LoadingSpinner-blip-4 {
+  font-size: 1.8rem;
+  opacity: 0.6;
+  margin-top: 1rem;
+  margin-bottom: 1rem;
+}
+
+/* First Blip */
+.LoadingSpinner-blip-1 {
+  animation: LoadingSpinner-pop-animation 2s infinite;
+}
+
+/* Second Blip */
+.LoadingSpinner-blip-2 {
+  animation: LoadingSpinner-pop-animation 2s infinite;
+  -webkit-animation-delay: 0.1s;
+  animation-delay: 0.1s;
+}
+
+/* Third Blip */
+.LoadingSpinner-blip-3 {
+  animation: LoadingSpinner-pop-animation 2s infinite;
+  animation-delay: 0.2s;
+}
+
+/* Fourth Blip */
+.LoadingSpinner-blip-4 {
+  animation: LoadingSpinner-pop-animation 2s infinite;
+  animation-delay: 0.3s;
+}
+
+/* Pop Animation for Each Blip */
+@keyframes LoadingSpinner-pop-animation {
+  0%  {
+    transform: scale(1.0);
+  }
+  10% {
+    transform: scale(1.5);
+  }
+  30% {
+    transform: scale(1.0);
+  }
+  100% {
+    transform: scale(1.0);
+  }
+}
+`;
+/*------------------------------------------------------------------------*/
+/* ------------------------------ Component ----------------------------- */
+/*------------------------------------------------------------------------*/
+const LoadingSpinner = () => {
+    /*------------------------------------------------------------------------*/
+    /* ------------------------------- Render ------------------------------- */
+    /*------------------------------------------------------------------------*/
+    // Add all four blips to a container
+    return (React__default["default"].createElement("div", { className: "text-center LoadingSpinner LoadingSpinner-container" },
+        React__default["default"].createElement("style", null, style$8),
+        React__default["default"].createElement(reactFontawesome.FontAwesomeIcon, { icon: freeSolidSvgIcons.faCircle, className: "LoadingSpinner-blip-1 me-1" }),
+        React__default["default"].createElement(reactFontawesome.FontAwesomeIcon, { icon: freeSolidSvgIcons.faCircle, className: "LoadingSpinner-blip-2 me-1" }),
+        React__default["default"].createElement(reactFontawesome.FontAwesomeIcon, { icon: freeSolidSvgIcons.faCircle, className: "LoadingSpinner-blip-3 me-1" }),
+        React__default["default"].createElement(reactFontawesome.FontAwesomeIcon, { icon: freeSolidSvgIcons.faCircle, className: "LoadingSpinner-blip-4" })));
+};
+
 /**
  * A box with a tab on the top that holds buttons and other content
  * @author Gabe Abrams
@@ -1652,9 +1625,7 @@ const style$7 = `
 
   /* Container for Title */
   .TabBox-title-container {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
+    /* Place on Left */
     position: relative;
     left: 0;
     text-align: left;
@@ -1687,19 +1658,6 @@ const style$7 = `
     background: #fdfdfd;
   }
 
-  .TabBox-title-right-container {
-    display: flex;
-    flex-direction: row;
-    align-items: bottom;
-    height: 2.4rem;
-    overflow: visible;
-  }
-
-  .TabBox-title-right-contents {
-    margin-right: 0.5rem;
-    margin-bottom: 0.2rem;
-  }
-
   /* Make the TabBox's Children Appear Above Title if Overlap Occurs */
   .TabBox-children {
     position: relative;
@@ -1713,16 +1671,19 @@ const TabBox = (props) => {
     /*------------------------------------------------------------------------*/
     /* -------------------------------- Setup ------------------------------- */
     /*------------------------------------------------------------------------*/
-    const { title, children, topRightChildren, noBottomPadding, noBottomMargin, } = props;
+    /* -------------- Props ------------- */
+    const { title, children, noBottomPadding, noBottomMargin, } = props;
     /*------------------------------------------------------------------------*/
     /* ------------------------------- Render ------------------------------- */
     /*------------------------------------------------------------------------*/
+    /*----------------------------------------*/
+    /* --------------- Main UI -------------- */
+    /*----------------------------------------*/
+    // Full UI
     return (React__default["default"].createElement("div", { className: `TabBox-container ${noBottomMargin ? '' : 'mb-2'}` },
         React__default["default"].createElement("style", null, style$7),
         React__default["default"].createElement("div", { className: "TabBox-title-container" },
-            React__default["default"].createElement("div", { className: "TabBox-title" }, title),
-            topRightChildren && (React__default["default"].createElement("div", { className: "TabBox-title-right-container" },
-                React__default["default"].createElement("div", { className: "TabBox-title-right-contents" }, topRightChildren)))),
+            React__default["default"].createElement("div", { className: "TabBox-title" }, title)),
         React__default["default"].createElement("div", { className: `TabBox-box ps-2 pt-2 pe-2 ${noBottomPadding ? '' : 'pb-2'}` },
             React__default["default"].createElement("div", { className: "TabBox-children" }, children))));
 };
@@ -2709,7 +2670,7 @@ const NestableItemList = (props) => {
                 React__default["default"].createElement(reactFontawesome.FontAwesomeIcon, { icon: childExpanded[item.id] ? freeSolidSvgIcons.faChevronDown : freeSolidSvgIcons.faChevronRight })))),
             React__default["default"].createElement(CheckboxButton, { className: `NestableItemList-CheckboxButton-${item.id}`, text: item.name, checked: item.isGroup ? allChecked(item.children) : item.checked, dashed: item.isGroup ? !noneChecked(item.children) : false, onChanged: (checked) => {
                     onChanged(changeChecked(item.id, checked, items));
-                }, ariaLabel: `Select ${item.name}`, checkedVariant: Variant$1.Light, uncheckedVariant: Variant$1.Light }),
+                }, ariaLabel: `Select ${item.name}`, checkedVariant: Variant$1.Light }),
             (item.isGroup && childExpanded[item.id]) && (React__default["default"].createElement("div", { className: "NestableItemList-children-container", style: {
                     paddingLeft: '2.2rem',
                 } },
@@ -2732,62 +2693,17 @@ const ItemPicker = (props) => {
     /*------------------------------------------------------------------------*/
     /* -------------- Props ------------- */
     // Destructure all props
-    const { title, items, onChanged, noBottomMargin, hideSelectAllOrNoneButtons, } = props;
+    const { title, items, onChanged, noBottomMargin, } = props;
     /*------------------------------------------------------------------------*/
     /* ------------------------- Component Functions ------------------------ */
     /*------------------------------------------------------------------------*/
-    /**
-     * Updates the checked state of an item (including all children)
-     * @author Yuen Ler Chow
-     * @param item the item to update
-     * @param checked the new checked state
-     * @returns the updated item
-     */
-    const updateItemChecked = (item, checked) => {
-        if (item.isGroup) {
-            return Object.assign(Object.assign({}, item), { children: item.children.map((child) => {
-                    return updateItemChecked(child, checked);
-                }) });
-        }
-        return Object.assign(Object.assign({}, item), { checked });
-    };
-    /**
-     * Selects all items in the list
-     * @author Yuen Ler Chow
-     */
-    const handleSelectAll = () => {
-        const updatedItems = items.map((item) => {
-            return updateItemChecked(item, true);
-        });
-        onChanged(updatedItems);
-    };
-    /**
-     * Deselects all items in the list
-     * @author Yuen Ler Chow
-     */
-    const handleDeselectAll = () => {
-        const updatedItems = items.map((item) => {
-            return updateItemChecked(item, false);
-        });
-        onChanged(updatedItems);
-    };
     /*------------------------------------------------------------------------*/
     /* ------------------------------- Render ------------------------------- */
     /*------------------------------------------------------------------------*/
     /*----------------------------------------*/
     /* --------------- Main UI -------------- */
     /*----------------------------------------*/
-    // Select all/none
-    const selectAllOrNone = (!hideSelectAllOrNoneButtons
-        ? (React__default["default"].createElement("div", { className: "d-flex h-100 align-items-end flex-row" },
-            React__default["default"].createElement("div", { className: "d-flex justify-content-end" },
-                React__default["default"].createElement("div", { className: "me-2", style: { fontSize: '1.2rem' } }, "Select"),
-                React__default["default"].createElement("div", { className: "btn-group", role: "group" },
-                    React__default["default"].createElement("button", { type: "button", style: { borderRight: '0.1rem solid white' }, "aria-label": "Select all contexts", className: "btn btn-secondary py-0", onClick: handleSelectAll }, "All"),
-                    React__default["default"].createElement("button", { type: "button", "aria-label": "Deselect all contexts", className: "btn btn-secondary py-0", onClick: handleDeselectAll }, "None")))))
-        : undefined);
-    // Main UI
-    return (React__default["default"].createElement(TabBox, { title: title, noBottomMargin: noBottomMargin, topRightChildren: selectAllOrNone },
+    return (React__default["default"].createElement(TabBox, { title: title, noBottomMargin: noBottomMargin },
         React__default["default"].createElement("div", { style: { overflowX: 'auto' } },
             React__default["default"].createElement(NestableItemList, { items: items, onChanged: onChanged }))));
 };
@@ -2902,16 +2818,16 @@ var LogAction$1 = LogAction;
  */
 var ParamType;
 (function (ParamType) {
-    ParamType["Boolean"] = "boolean";
-    ParamType["BooleanOptional"] = "boolean-optional";
-    ParamType["Float"] = "float";
-    ParamType["FloatOptional"] = "float-optional";
-    ParamType["Int"] = "int";
-    ParamType["IntOptional"] = "int-optional";
-    ParamType["JSON"] = "json";
-    ParamType["JSONOptional"] = "json-optional";
-    ParamType["String"] = "string";
-    ParamType["StringOptional"] = "string-optional";
+    ParamType["Boolean"] = "Boolean";
+    ParamType["BooleanOptional"] = "BooleanOptional";
+    ParamType["Float"] = "Float";
+    ParamType["FloatOptional"] = "FloatOptional";
+    ParamType["Int"] = "Int";
+    ParamType["IntOptional"] = "IntOptional";
+    ParamType["JSON"] = "JSON";
+    ParamType["JSONOptional"] = "JSONOptional";
+    ParamType["String"] = "String";
+    ParamType["StringOptional"] = "StringOptional";
 })(ParamType || (ParamType = {}));
 var ParamType$1 = ParamType;
 
@@ -3159,7 +3075,7 @@ const IntelliTable = (props) => {
                             param: column.param,
                             visible: checked,
                         });
-                    }, checked: columnVisibilityMap[column.param], ariaLabel: `show "${column.title}" column in the ${title} table`, checkedVariant: Variant$1.Light, uncheckedVariant: Variant$1.Light }));
+                    }, checked: columnVisibilityMap[column.param], ariaLabel: `show "${column.title}" column in the ${title} table`, checkedVariant: Variant$1.Light, uncheckedVariant: Variant$1.Secondary }));
             }),
             React__default["default"].createElement("div", { className: "mt-3" }, "Or you can:"),
             React__default["default"].createElement("button", { type: "button", id: `IntelliTable-${id}-select-all-columns`, className: "btn btn-secondary me-2", "aria-label": `show all columns in the ${title} table`, onClick: () => {
@@ -14121,1295 +14037,23 @@ const padZerosLeft = (num, numDigits) => {
 };
 
 /**
- * Route for checking the status of the current user's
- *   access to log review
+ * Stub a server endpoint response
  * @author Gabe Abrams
+ * @param opts object containing all arguments
+ * @param [opts.method=GET] http method to stub
+ * @param opts.path full pathname to stub
+ * @param opts.body body of response if stubbing a successful response
+ * @param opts.errorMessage message of error if stubbing a failed response
+ * @param [opts.errorCode] error code if stubbing a failed response
  */
-const LOG_REVIEW_STATUS_ROUTE = `${ROUTE_PATH_PREFIX}/logs/access_allowed`;
+const stubServerEndpoint = _setStubResponse;
 
-// Stored copy of caccl functions
-let _cacclGetLaunchInfo;
-// Stored copy of dce-mango log collection
-let _logCollection;
-/*------------------------------------------------------------------------*/
-/*                                 Helpers                                */
-/*------------------------------------------------------------------------*/
-/**
- * Get launch info via CACCL
- * @author Gabe Abrams
- * @param req express request object
- * @returns object { launched, launchInfo }
- */
-const cacclGetLaunchInfo = (req) => {
-    if (!_cacclGetLaunchInfo) {
-        throw new ErrorWithCode('Could not get launch info because server was not initialized with dce-reactkit\'s initServer function', ReactKitErrorCode$1.NoCACCLGetLaunchInfoFunction);
-    }
-    return _cacclGetLaunchInfo(req);
-};
 /**
- * Get log collection
+ * Start a dynamic wait, call the function once the operation has completed and
+ *   the dynamic wait will continue waiting for the rest of the minimum time
  * @author Gabe Abrams
- * @returns log collection if one was included during launch or null if we don't
- *   have a log collection (yet)
- */
-const internalGetLogCollection = () => {
-    return _logCollection !== null && _logCollection !== void 0 ? _logCollection : null;
-};
-/*------------------------------------------------------------------------*/
-/*                                  Main                                  */
-/*------------------------------------------------------------------------*/
-/**
- * Prepare dce-reactkit to run on the server
- * @author Gabe Abrams
- * @param opts object containing all arguments
- * @param opts.app express app from inside of the postprocessor function that
- *   we will add routes to
- * @param opts.getLaunchInfo CACCL LTI's get launch info function
- * @param [opts.logCollection] mongo collection from dce-mango to use for
- *   storing logs. If none is included, logs are written to the console
- * @param [opts.logReviewAdmins=all] info on which admins can review
- *   logs from the client. If not included, all Canvas admins are allowed to
- *   review logs. If null, no Canvas admins are allowed to review logs.
- *   If an array of Canvas userIds (numbers), only Canvas admins with those
- *   userIds are allowed to review logs. If a dce-mango collection, only
- *   Canvas admins with entries in that collection ({ userId, ...}) are allowed
- *   to review logs
- */
-const initServer = (opts) => {
-    _cacclGetLaunchInfo = opts.getLaunchInfo;
-    _logCollection = opts.logCollection;
-    /*----------------------------------------*/
-    /*                Logging                 */
-    /*----------------------------------------*/
-    /**
-     * Log an event
-     * @author Gabe Abrams
-     * @param {string} context Context of the event (each app determines how to
-     *   organize its contexts)
-     * @param {string} subcontext Subcontext of the event (each app determines
-     *   how to organize its subcontexts)
-     * @param {string} tags stringified list of tags that apply to this action
-     *   (each app determines tag usage)
-     * @param {string} metadata stringified object containing optional custom metadata
-     * @param {string} level log level
-     * @param {string} [errorMessage] error message if type is an error
-     * @param {string} [errorCode] error code if type is an error
-     * @param {string} [errorStack] error stack if type is an error
-     * @param {string} [target] Target of the action (each app determines the list
-     *   of targets) These are usually buttons, panels, elements, etc.
-     * @param {LogAction} [action] the type of action performed on the target
-     * @returns {Log}
-     */
-    opts.app.post(LOG_ROUTE_PATH, genRouteHandler({
-        paramTypes: {
-            context: ParamType$1.String,
-            subcontext: ParamType$1.String,
-            tags: ParamType$1.JSON,
-            level: ParamType$1.String,
-            metadata: ParamType$1.JSON,
-            errorMessage: ParamType$1.StringOptional,
-            errorCode: ParamType$1.StringOptional,
-            errorStack: ParamType$1.StringOptional,
-            target: ParamType$1.StringOptional,
-            action: ParamType$1.StringOptional,
-        },
-        handler: ({ params, logServerEvent }) => {
-            // Create log info
-            const logInfo = ((params.errorMessage || params.errorCode || params.errorStack)
-                // Error
-                ? {
-                    context: params.context,
-                    subcontext: params.subcontext,
-                    tags: params.tags,
-                    level: params.level,
-                    metadata: params.metadata,
-                    error: {
-                        message: params.errorMessage,
-                        code: params.errorCode,
-                        stack: params.errorStack,
-                    },
-                }
-                // Action
-                : {
-                    context: params.context,
-                    subcontext: params.subcontext,
-                    tags: params.tags,
-                    level: params.level,
-                    metadata: params.metadata,
-                    target: params.target,
-                    action: params.action,
-                });
-            // Add hidden boolean to change source to "client"
-            const logInfoForcedFromClient = Object.assign(Object.assign({}, logInfo), { overrideAsClientEvent: true });
-            // Write the log
-            const log = logServerEvent(logInfoForcedFromClient);
-            // Return
-            return log;
-        },
-    }));
-    /*----------------------------------------*/
-    /*              Log Reviewer              */
-    /*----------------------------------------*/
-    /**
-     * Check if a given user is allowed to review logs
-     * @author Gabe Abrams
-     * @param userId the id of the user
-     * @param isAdmin if true, the user is an admin
-     * @returns true if the user can review logs
-     */
-    const canReviewLogs = (userId, isAdmin) => __awaiter(void 0, void 0, void 0, function* () {
-        // Immediately deny access if user is not an admin
-        if (!isAdmin) {
-            return false;
-        }
-        // If all admins are allowed, we're done
-        if (!opts.logReviewAdmins) {
-            return true;
-        }
-        // Do a dynamic check
-        try {
-            // Array of userIds
-            if (Array.isArray(opts.logReviewAdmins)) {
-                return opts.logReviewAdmins.some((allowedId) => {
-                    return (userId === allowedId);
-                });
-            }
-            // Must be a collection
-            const matches = yield opts.logReviewAdmins.find({ userId });
-            // Make sure at least one entry matches
-            return matches.length > 0;
-        }
-        catch (err) {
-            // If an error occurred, simply return false
-            return false;
-        }
-    });
-    /**
-     * Check if the current user has access to logs
-     * @author Gabe Abrams
-     * @returns {boolean} true if user has access
-     */
-    opts.app.get(LOG_REVIEW_STATUS_ROUTE, genRouteHandler({
-        handler: ({ params }) => __awaiter(void 0, void 0, void 0, function* () {
-            const { userId, isAdmin } = params;
-            const canReview = yield canReviewLogs(userId, isAdmin);
-            return canReview;
-        }),
-    }));
-    /**
-     * Get all logs for a certain month
-     * @author Gabe Abrams
-     * @param {number} year the year to query (e.g. 2022)
-     * @param {number} month the month to query (e.g. 1 = January)
-     * @returns {Log[]} list of logs from the given month
-     */
-    opts.app.get(`${LOG_REVIEW_ROUTE_PATH_PREFIX}/years/:year/months/:month`, genRouteHandler({
-        paramTypes: {
-            year: ParamType$1.Int,
-            month: ParamType$1.Int,
-            pageNumber: ParamType$1.Int,
-        },
-        handler: ({ params }) => __awaiter(void 0, void 0, void 0, function* () {
-            // Get user info
-            const { year, month, pageNumber, userId, isAdmin, } = params;
-            // Validate user
-            const canReview = yield canReviewLogs(userId, isAdmin);
-            if (!canReview) {
-                throw new ErrorWithCode('You cannot access this resource because you do not have the appropriate permissions.', ReactKitErrorCode$1.NotAllowedToReviewLogs);
-            }
-            // Query for logs
-            const response = yield _logCollection.findPaged({
-                query: {
-                    year,
-                    month,
-                },
-                perPage: 1000,
-                pageNumber,
-            });
-            // Return response
-            return response;
-        }),
-    }));
-};
-
-// Import shared types
-/**
- * Handle an error and respond to the client
- * @author Gabe Abrams
- * @param res express response
- * @param error error info
- * @param opts.err the error to send to the client
- *   or the error message
- * @param [opts.code] an error code (only used if err.code is not
- *   included)
- * @param [opts.status=500] the https status code to use
- *   defined)
- */
-const handleError = (res, error) => {
-    // Get the error message
-    let message;
-    if (error && error.message) {
-        message = (error.message || 'An unknown error occurred.');
-    }
-    else if (typeof error === 'string') {
-        message = (error.trim().length > 0
-            ? error
-            : 'An unknown error occurred.');
-    }
-    else {
-        message = 'An unknown error occurred.';
-    }
-    // Get the error code
-    const code = (error.code || ReactKitErrorCode$1.NoCode);
-    // Get the status code
-    const status = (error.status || 500);
-    // Respond to user
-    res
-        // Set the http status code
-        .status(status)
-        // Send a JSON response
-        .json({
-        // Error message
-        message,
-        // Error code
-        code,
-        // Success = false flag so client can detect server-side errors
-        success: false,
-    });
-    return undefined;
-};
-
-/**
- * Send successful API response
- * @author Gabe Abrams
- * @param res express response
- * @param body the body of the response to send to the client
- */
-const handleSuccess = (res, body) => {
-    // Send a http 200 json response
-    res.json({
-        // Include the body as a parameter
-        body,
-        // Success = true flag so client can detect successful responses
-        success: true,
-    });
-    return undefined;
-};
-
-// Import shared types
-/**
- * Generate a static error page
- * @author Gabe Abrams
- * @param opts object containing all arguments
- * @param [opts.title=An Error Occurred] title of the error box
- * @param [opts.description=An unknown server error occurred. Please contact support.]
- *   a human-readable description of the error
- * @param [opts.code=ReactKitErrorCode.NoCode] error code to show
- * @param [opts.pageTitle=opts.title] title of the page/tab if it differs from
- *   the title of the error
- * @returns html of the page
- */
-const genErrorPage = (opts = {}) => {
-    var _a, _b, _c, _d;
-    const title = ((_a = opts.title) !== null && _a !== void 0 ? _a : 'An Error Occurred');
-    const pageTitle = ((_b = opts.pageTitle) !== null && _b !== void 0 ? _b : title);
-    const description = ((_c = opts.description) !== null && _c !== void 0 ? _c : 'An unknown server error occurred. Please contact support.');
-    const code = ((_d = opts.code) !== null && _d !== void 0 ? _d : ReactKitErrorCode$1.NoCode);
-    return `
-<head>
-  <!-- Metadata -->
-  <meta
-    name="viewport"
-    content="width=device-width, height=device-height, initial-scale=1.0, minimum-scale=1.0"
-  >
-
-  <!-- Title -->
-  <title>${pageTitle}</title>
-
-  <!-- Bootstrap -->
-  <link
-    rel="stylesheet"
-    href="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.2.1/css/bootstrap.min.css"
-    integrity="sha512-siwe/oXMhSjGCwLn+scraPOWrJxHlUgMBMZXdPe2Tnk3I0x3ESCoLz7WZ5NTH6SZrywMY+PB1cjyqJ5jAluCOg=="
-    crossorigin="anonymous"
-    referrerpolicy="no-referrer"
-  />
-  <script
-    src="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.2.1/js/bootstrap.min.js"
-    integrity="sha512-vyRAVI0IEm6LI/fVSv/Wq/d0KUfrg3hJq2Qz5FlfER69sf3ZHlOrsLriNm49FxnpUGmhx+TaJKwJ+ByTLKT+Yg=="
-    crossorigin="anonymous"
-    referrerpolicy="no-referrer"
-  ></script>
-
-  <!-- FontAwesome -->
-  <link
-    rel="stylesheet"
-    href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.2.0/css/all.min.css"
-    integrity="sha512-xh6O/CkQoPOWDdYTDqeRdPCVd1SpvCA9XXcUnZS2FmJNp1coAFzvtCN9BmamE+4aHK8yyUHUSCcJHgXloTyT2A=="
-    crossorigin="anonymous"
-    referrerpolicy="no-referrer"
-  />
-
-  <!-- Style -->
-  <style>
-    .DCEReactKit-pop-in {
-      animation-name: DCEReactKit-pop-in;
-      animation-duration: 0.5s;
-      animation-iteration-count: 1;
-      animation-timing-function: ease-out;
-      animation-fill-mode: both;
-
-      transform-origin: center;
-    }
-
-    @keyframes DCEReactKit-pop-in {
-      0% {
-        opacity: 0;
-        transform: scale(0.9);
-      }
-      100% {
-        opacity: 1;
-        transform: scale(1);
-      }
-    }
-
-    .DCEReactKit-slide-in {
-      animation-name: DCEReactKit-slide-in;
-      animation-duration: 1s;
-      animation-iteration-count: 1;
-      animation-timing-function: ease-out;
-      animation-fill-mode: both;
-      animation-delay: 0.2s;
-    }
-
-    @keyframes DCEReactKit-slide-in {
-      0% {
-        opacity: 0;
-        transform: translate(0, 0.3em);
-      }
-      100% {
-        opacity: 1;
-        transform: translate(0, 0);
-      }
-    }
-  </style>
-</head>
-
-<!-- Body -->
-<body class="bg-dark text-center pt-3 ps-3 pe-3">
-  <!-- Alert -->
-  <div
-    class="DCEReactKit-pop-in alert alert-warning d-inline-block"
-    style="width: 50em; max-width: 100%"
-  >
-    <!-- Title -->
-    <h2>
-      <i class="me-1 fa-solid fa-triangle-exclamation"></i>
-      ${title}
-    </h2>
-    <!-- Description -->
-    <div>
-      ${description}
-    </div>
-  </div>
-
-  <!-- Error Code -->
-  <div class="DCEReactKit-slide-in text-light">
-    <strong>
-      Error Code:
-    </strong>
-    ${code}
-  </div>
-</body>
-  `;
-};
-
-/**
- * Generate a static info page
- * @author Gabe Abrams
- * @param opts object containing all arguments
- * @param opts.title title of the info box
- * @param opts.body a human-readable text body for the info alert
- * @returns the HTML for the info page
- */
-const genInfoPage = (opts) => {
-    const { title, body, } = opts;
-    return `
-<head>
-  <!-- Metadata -->
-  <meta
-    name="viewport"
-    content="width=device-width, height=device-height, initial-scale=1.0, minimum-scale=1.0"
-  >
-
-  <!-- Title -->
-  <title>${title}</title>
-
-  <!-- Bootstrap -->
-  <link
-    rel="stylesheet"
-    href="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.2.1/css/bootstrap.min.css"
-    integrity="sha512-siwe/oXMhSjGCwLn+scraPOWrJxHlUgMBMZXdPe2Tnk3I0x3ESCoLz7WZ5NTH6SZrywMY+PB1cjyqJ5jAluCOg=="
-    crossorigin="anonymous"
-    referrerpolicy="no-referrer"
-  />
-  <script
-    src="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.2.1/js/bootstrap.min.js"
-    integrity="sha512-vyRAVI0IEm6LI/fVSv/Wq/d0KUfrg3hJq2Qz5FlfER69sf3ZHlOrsLriNm49FxnpUGmhx+TaJKwJ+ByTLKT+Yg=="
-    crossorigin="anonymous"
-    referrerpolicy="no-referrer"
-  ></script>
-
-  <!-- FontAwesome -->
-  <link
-    rel="stylesheet"
-    href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.2.0/css/all.min.css"
-    integrity="sha512-xh6O/CkQoPOWDdYTDqeRdPCVd1SpvCA9XXcUnZS2FmJNp1coAFzvtCN9BmamE+4aHK8yyUHUSCcJHgXloTyT2A=="
-    crossorigin="anonymous"
-    referrerpolicy="no-referrer"
-  />
-
-  <!-- Style -->
-  <style>
-    .DCEReactKit-pop-in {
-      animation-name: DCEReactKit-pop-in;
-      animation-duration: 0.5s;
-      animation-iteration-count: 1;
-      animation-timing-function: ease-out;
-      animation-fill-mode: both;
-
-      transform-origin: center;
-    }
-
-    @keyframes DCEReactKit-pop-in {
-      0% {
-        opacity: 0;
-        transform: scale(0.9);
-      }
-      100% {
-        opacity: 1;
-        transform: scale(1);
-      }
-    }
-  </style>
-</head>
-
-<!-- Body -->
-<body class="bg-dark text-center pt-3 ps-3 pe-3">
-  <!-- Alert -->
-  <div
-    class="DCEReactKit-pop-in alert alert-info d-inline-block"
-    style="width: 50em; max-width: 100%"
-  >
-    <!-- Title -->
-    <h2>
-      <i class="me-1 fa-solid fa-circle-info"></i>
-      ${title}
-    </h2>
-    <!-- Body -->
-    <div>
-      ${body}
-    </div>
-  </div>
-</body>
-  `;
-};
-
-/**
- * Perform a rudimentary parsing of the user's browser agent string
- * @author Gabe Abrams
- * @param userAgent the user's browser agent
- * @returns user info
- */
-const parseUserAgent = (userAgent) => {
-    /* ------------- Browser ------------ */
-    let browser = {
-        name: 'Unknown',
-        version: 'Unknown',
-    };
-    // Parse user agent
-    let verOffset;
-    let nameOffset;
-    if ((verOffset = userAgent.indexOf('Opera')) !== -1) {
-        // In Opera, the true version is after 'Opera' or after 'Version'
-        browser = {
-            name: 'Opera',
-            version: userAgent.substring(verOffset + 6),
-        };
-        if ((verOffset = userAgent.indexOf('Version')) !== -1) {
-            browser.version = userAgent.substring(verOffset + 8);
-        }
-    }
-    else if ((verOffset = userAgent.indexOf('MSIE')) !== -1) {
-        // In MSIE, the true version is after 'MSIE' in userAgent
-        browser = {
-            name: 'Internet Explorer',
-            version: userAgent.substring(verOffset + 5),
-        };
-    }
-    else if ((verOffset = userAgent.indexOf('Chrome')) !== -1) {
-        // In Chrome, the true version is after 'Chrome'
-        browser = {
-            name: 'Chrome',
-            version: userAgent.substring(verOffset + 7),
-        };
-    }
-    else if ((verOffset = userAgent.indexOf('Safari')) !== -1) {
-        // In Safari, the true version is after 'Safari' or after 'Version'
-        browser = {
-            name: 'Safari',
-            version: userAgent.substring(verOffset + 7),
-        };
-        if ((verOffset = userAgent.indexOf('Version')) !== -1) {
-            browser.version = userAgent.substring(verOffset + 8);
-        }
-    }
-    else if ((verOffset = userAgent.indexOf('Firefox')) != -1) {
-        // In Firefox, the true version is after 'Firefox'
-        browser = {
-            name: 'Firefox',
-            version: userAgent.substring(verOffset + 8),
-        };
-    }
-    else if ((nameOffset = userAgent.lastIndexOf(' ') + 1)
-        < (verOffset = userAgent.lastIndexOf('/'))) {
-        browser = {
-            name: userAgent.substring(nameOffset, verOffset),
-            version: userAgent.substring(verOffset + 1),
-        };
-    }
-    // Postprocess version
-    // trim the fullVersion string at semicolon/space if present
-    let ix;
-    if ((ix = browser.version.indexOf(';')) !== -1) {
-        browser.version = browser.version.substring(0, ix);
-    }
-    if ((ix = browser.version.indexOf(' ')) !== -1) {
-        browser.version = browser.version.substring(0, ix);
-    }
-    /* ------------- Device ------------- */
-    // Detect os
-    let os = 'Unknown';
-    if (userAgent.includes('Linux')) {
-        os = 'Linux';
-    }
-    else if (userAgent.includes('like Mac')) {
-        os = 'iOS';
-    }
-    else if (userAgent.includes('Mac')) {
-        os = 'Mac';
-    }
-    else if (userAgent.includes('Android')) {
-        os = 'Android';
-    }
-    else if (userAgent.includes('Win')) {
-        os = 'Win';
-    }
-    // Check if mobile
-    const isMobile = !!userAgent.match(/(iPhone|iPod|iPad|Android|BlackBerry)/);
-    // Device
-    const device = {
-        isMobile,
-        os,
-    };
-    /* ------------- Finish ------------- */
-    // Return info
-    return {
-        browser,
-        device,
-    };
-};
-
-/**
- * Generate an express API route handler
- * @author Gabe Abrams
- * @param opts object containing all arguments
- * @param opts.paramTypes map containing the types for each parameter that is
- *   included in the request (map: param name => type)
- * @param opts.handler function that processes the request
- * @param [opts.skipSessionCheck] if true, skip the session check (allow users
- *   to not be logged in and launched via LTI)
- * @param [opts.allowedHosts] if included, only allow requests from these hosts
- *   (start a hostname with a "*" to only check the end of the hostname)
- *   you can include just one string instead of an array
- * @param [opts.bannedHosts] if included, do not allow requests from these hosts
- *   (start a hostname with a "*" to only check the end of the hostname)
- *   you can include just one string instead of an array
- * @param [opts.unhandledErrorMessagePrefix] if included, when an error that
- *   is not of type ErrorWithCode is thrown, the client will receive an error
- *   where the error message is prefixed with this string. For example,
- *   if unhandledErrorMessagePrefix is
- *   'While saving progress, we encountered an error:'
- *   and the error is 'progressInfo is not an object',
- *   the client will receive an error with the message
- *   'While saving progress, we encountered an error: progressInfo is not an object'
- * @returns express route handler that takes the following arguments:
- *   params (map: param name => value),
- *   req (express request object),
- *   next (express next function),
- *   send (a function that sends a string to the client),
- *   redirect (takes a url and redirects the user to that url),
- *   renderErrorPage (shows a static error page to the user),
- *   renderInfoPage (shows a static info page to the user),
- *   renderCustomHTML (renders custom html and sends it to the user),
- *   and returns the value to send to the client as a JSON API response, or
- *   calls next() or redirect(...) or send(...) or renderErrorPage(...).
- *   Note: params also has userId, userFirstName,
- *   userLastName, userEmail, userAvatarURL, isLearner, isTTM, isAdmin,
- *   and any other variables that
- *   are directly added to the session, if the user does have a session.
- */
-const genRouteHandler = (opts) => {
-    // Return a route handler
-    return (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
-        // Output params
-        const output = {};
-        /*----------------------------------------*/
-        /* ----------- Hostname Check ----------- */
-        /*----------------------------------------*/
-        // Get hostnames
-        const originURL = String(req.get('origin')
-            || req.headers.origin
-            || req.headers.referer);
-        const originHostname = (originURL
-            // Remove protocol
-            .replace(/(^\w+:|^)\/\//, '')
-            // Remove port
-            .replace(/:\d+$/, ''));
-        const serverHostname = String(req.hostname);
-        // Check allowed
-        if (opts.allowedHosts) {
-            // Only accept requests from allowed hosts
-            const allowedArray = (Array.isArray(opts.allowedHosts)
-                ? opts.allowedHosts
-                : [opts.allowedHosts]);
-            // Check if server is localhost
-            if (serverHostname === 'localhost') {
-                // Allow localhost
-                allowedArray.push('localhost');
-            }
-            // Check if current host is allowed
-            const allowed = allowedArray.some((allowedHost) => {
-                if (allowedHost.startsWith('*')) {
-                    // Check end of hostname
-                    return originHostname.endsWith(allowedHost.substring(1));
-                }
-                // Check full hostname
-                return originHostname.toLowerCase() === allowedHost.toLowerCase();
-            });
-            // If not allowed, return error
-            if (!allowed) {
-                return handleError(res, {
-                    message: 'You are not allowed to access this endpoint.',
-                    code: ReactKitErrorCode$1.HostNotAllowed,
-                    status: 403,
-                });
-            }
-        }
-        // Check banned
-        if (opts.bannedHosts) {
-            // Do not allow requests from banned hosts
-            const bannedArray = (Array.isArray(opts.bannedHosts)
-                ? opts.bannedHosts
-                : [opts.bannedHosts]);
-            // Check if current host is banned
-            const banned = bannedArray.some((bannedHost) => {
-                if (bannedHost.startsWith('*')) {
-                    // Check end of hostname
-                    return originHostname.endsWith(bannedHost.substring(1));
-                }
-                // Check full hostname
-                return originHostname.toLowerCase() === bannedHost.toLowerCase();
-            });
-            // If banned, return error
-            if (banned) {
-                return handleError(res, {
-                    message: 'You are not allowed to access this endpoint.',
-                    code: ReactKitErrorCode$1.HostBanned,
-                    status: 403,
-                });
-            }
-        }
-        /*----------------------------------------*/
-        /* ------------ Parse Params ------------ */
-        /*----------------------------------------*/
-        // Process items one by one
-        const paramList = Object.entries((_a = opts.paramTypes) !== null && _a !== void 0 ? _a : {});
-        for (let i = 0; i < paramList.length; i++) {
-            const [name, type] = paramList[i];
-            // Find the value as a string
-            const value = (req.params[name]
-                || req.query[name]
-                || req.body[name]);
-            // Parse
-            if (type === ParamType$1.Boolean || type === ParamType$1.BooleanOptional) {
-                // Boolean
-                // Handle case where value doesn't exist
-                if (value === undefined) {
-                    if (type === ParamType$1.BooleanOptional) {
-                        output[name] = undefined;
-                    }
-                    else {
-                        return handleError(res, {
-                            message: `Parameter ${name} is required, but it was not included.`,
-                            code: ReactKitErrorCode$1.MissingParameter,
-                            status: 422,
-                        });
-                    }
-                }
-                else {
-                    // Value exists
-                    // Simplify value
-                    const simpleVal = (String(value)
-                        .trim()
-                        .toLowerCase());
-                    // Parse
-                    output[name] = ([
-                        'true',
-                        'yes',
-                        'y',
-                        '1',
-                        't',
-                    ].indexOf(simpleVal) >= 0);
-                }
-            }
-            else if (type === ParamType$1.Float || type === ParamType$1.FloatOptional) {
-                // Float
-                // Handle case where value doesn't exist
-                if (value === undefined) {
-                    if (type === ParamType$1.FloatOptional) {
-                        output[name] = undefined;
-                    }
-                    else {
-                        return handleError(res, {
-                            message: `Parameter ${name} is required, but it was not included.`,
-                            code: ReactKitErrorCode$1.MissingParameter,
-                            status: 422,
-                        });
-                    }
-                }
-                else if (!Number.isNaN(Number.parseFloat(String(value)))) {
-                    // Value is a number
-                    output[name] = Number.parseFloat(String(value));
-                }
-                else {
-                    // Issue!
-                    return handleError(res, {
-                        message: `Request data was malformed: ${name} was not a valid float.`,
-                        code: ReactKitErrorCode$1.InvalidParameter,
-                        status: 422,
-                    });
-                }
-            }
-            else if (type === ParamType$1.Int || type === ParamType$1.IntOptional) {
-                // Int
-                // Handle case where value doesn't exist
-                if (value === undefined) {
-                    if (type === ParamType$1.IntOptional) {
-                        output[name] = undefined;
-                    }
-                    else {
-                        return handleError(res, {
-                            message: `Parameter ${name} is required, but it was not included.`,
-                            code: ReactKitErrorCode$1.MissingParameter,
-                            status: 422,
-                        });
-                    }
-                }
-                else if (!Number.isNaN(Number.parseInt(String(value), 10))) {
-                    // Value is a number
-                    output[name] = Number.parseInt(String(value), 10);
-                }
-                else {
-                    // Issue!
-                    return handleError(res, {
-                        message: `Request data was malformed: ${name} was not a valid int.`,
-                        code: ReactKitErrorCode$1.InvalidParameter,
-                        status: 422,
-                    });
-                }
-            }
-            else if (type === ParamType$1.JSON || type === ParamType$1.JSONOptional) {
-                // Stringified JSON
-                // Handle case where value doesn't exist
-                if (value === undefined) {
-                    if (type === ParamType$1.JSONOptional) {
-                        output[name] = undefined;
-                    }
-                    else {
-                        return handleError(res, {
-                            message: `Parameter ${name} is required, but it was not included.`,
-                            code: ReactKitErrorCode$1.MissingParameter,
-                            status: 422,
-                        });
-                    }
-                }
-                else {
-                    // Value exists
-                    // Parse
-                    try {
-                        output[name] = JSON.parse(String(value));
-                    }
-                    catch (err) {
-                        return handleError(res, {
-                            message: `Request data was malformed: ${name} was not a valid JSON payload.`,
-                            code: ReactKitErrorCode$1.InvalidParameter,
-                            status: 422,
-                        });
-                    }
-                }
-            }
-            else if (type === ParamType$1.String || type === ParamType$1.StringOptional) {
-                // String
-                // Handle case where value doesn't exist
-                if (value === undefined) {
-                    if (type === ParamType$1.StringOptional) {
-                        output[name] = undefined;
-                    }
-                    else {
-                        return handleError(res, {
-                            message: `Parameter ${name} is required, but it was not included.`,
-                            code: ReactKitErrorCode$1.MissingParameter,
-                            status: 422,
-                        });
-                    }
-                }
-                else {
-                    // Value exists
-                    // Leave as is
-                    output[name] = value;
-                }
-            }
-            else {
-                // No valid data type
-                return handleError(res, {
-                    message: `An internal error occurred: we could not determine the type of ${name}.`,
-                    code: ReactKitErrorCode$1.InvalidParameter,
-                    status: 422,
-                });
-            }
-        }
-        /*----------------------------------------*/
-        /* ------------- Launch Info ------------ */
-        /*----------------------------------------*/
-        // Get launch info
-        const { launched, launchInfo } = cacclGetLaunchInfo(req);
-        if (
-        // Not launched
-        (!launched || !launchInfo)
-            // Not skipping the session check
-            && !opts.skipSessionCheck) {
-            return handleError(res, {
-                message: 'Your session has expired. Please refresh the page and try again.',
-                code: ReactKitErrorCode$1.SessionExpired,
-                status: 401,
-            });
-        }
-        // Error if user info cannot be found
-        if (
-        // User information is incomplete
-        (!launchInfo
-            || !launchInfo.userId
-            || !launchInfo.userFirstName
-            || !launchInfo.userLastName
-            || (launchInfo.notInCourse
-                && !launchInfo.isAdmin)
-            || (!launchInfo.isTTM
-                && !launchInfo.isLearner
-                && !launchInfo.isAdmin))
-            // Not skipping the session check
-            && !opts.skipSessionCheck) {
-            return handleError(res, {
-                message: 'Your session was invalid. Please refresh the page and try again.',
-                code: ReactKitErrorCode$1.SessionExpired,
-                status: 401,
-            });
-        }
-        // Add launch info to output
-        output.userId = (launchInfo
-            ? launchInfo.userId
-            : ((_b = output.userId) !== null && _b !== void 0 ? _b : undefined));
-        output.userFirstName = (launchInfo
-            ? launchInfo.userFirstName
-            : ((_c = output.userFirstName) !== null && _c !== void 0 ? _c : undefined));
-        output.userLastName = (launchInfo
-            ? launchInfo.userLastName
-            : ((_d = output.userLastName) !== null && _d !== void 0 ? _d : undefined));
-        output.userEmail = (launchInfo
-            ? launchInfo.userEmail
-            : ((_e = output.userEmail) !== null && _e !== void 0 ? _e : undefined));
-        output.userAvatarURL = (launchInfo
-            ? ((_f = launchInfo.userImage) !== null && _f !== void 0 ? _f : 'http://www.gravatar.com/avatar/?d=identicon')
-            : ((_g = output.userAvatarURL) !== null && _g !== void 0 ? _g : undefined));
-        output.isLearner = (launchInfo
-            ? !!launchInfo.isLearner
-            : ((_h = output.isLearner) !== null && _h !== void 0 ? _h : undefined));
-        output.isTTM = (launchInfo
-            ? !!launchInfo.isTTM
-            : ((_j = output.isTTM) !== null && _j !== void 0 ? _j : undefined));
-        output.isAdmin = (launchInfo
-            ? !!launchInfo.isAdmin
-            : ((_k = output.isAdmin) !== null && _k !== void 0 ? _k : undefined));
-        output.courseId = (launchInfo
-            ? ((_l = output.courseId) !== null && _l !== void 0 ? _l : launchInfo.courseId)
-            : ((_m = output.courseId) !== null && _m !== void 0 ? _m : undefined));
-        output.courseName = (launchInfo
-            ? launchInfo.contextLabel
-            : ((_o = output.courseName) !== null && _o !== void 0 ? _o : undefined));
-        // Add other session variables
-        Object.keys(req.session).forEach((propName) => {
-            // Skip if prop already in output
-            if (output[propName] !== undefined) {
-                return;
-            }
-            // Add to output
-            const value = req.session[propName];
-            if (typeof value === 'string'
-                || typeof value === 'boolean'
-                || typeof value === 'number') {
-                output[propName] = value;
-            }
-        });
-        /*----------------------------------------*/
-        /* ----- Require Course Consistency ----- */
-        /*----------------------------------------*/
-        // Make sure the user actually launched from the appropriate course
-        if (output.courseId
-            && launchInfo
-            && launchInfo.courseId
-            && output.courseId !== launchInfo.courseId
-            && !output.isTTM
-            && !output.isAdmin) {
-            // Course of interest is not the launch course
-            return handleError(res, {
-                message: 'You switched sessions by opening this app in another tab. Please refresh the page and try again.',
-                code: ReactKitErrorCode$1.WrongCourse,
-                status: 401,
-            });
-        }
-        /*----------------------------------------*/
-        /*       Require Proper Permissions       */
-        /*----------------------------------------*/
-        // Add TTM endpoint security
-        if (
-        // This is a TTM endpoint
-        req.path.startsWith('/api/ttm')
-            // User is not a TTM
-            && (
-            // User is not a TTM
-            !output.isTTM
-                // User is not an admin
-                && !output.isAdmin)) {
-            // User does not have access
-            return handleError(res, {
-                message: 'This action is only allowed if you are a teaching team member for the course. Please go back to Canvas, log in as a teaching team member, and try again.',
-                code: ReactKitErrorCode$1.NotTTM,
-                status: 401,
-            });
-        }
-        // Add Admin endpoint security
-        if (
-        // This is an admin endpoint
-        req.path.startsWith('/api/admin')
-            // User is not an admin
-            && !output.isAdmin) {
-            // User does not have access
-            return handleError(res, {
-                message: 'This action is only allowed if you are a Canvas admin. Please go back to Canvas, log in as an admin, and try again.',
-                code: ReactKitErrorCode$1.NotAdmin,
-                status: 401,
-            });
-        }
-        /*----------------------------------------*/
-        /* ------------- Log Handler ------------ */
-        /*----------------------------------------*/
-        // Create a log handler function
-        /**
-         * Log an event on the server
-         * @author Gabe Abrams
-         */
-        const logServerEvent = (logOpts) => __awaiter(void 0, void 0, void 0, function* () {
-            var _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1;
-            // NOTE: internally, we slip through an opts.overrideAsClientEvent boolean
-            // that indicates that this is actually a client event, but we don't
-            // include that in the LogFunction type because this is internal and
-            // hidden from users
-            try {
-                // Parse user agent
-                const { browser, device, } = parseUserAgent(req.headers['user-agent']);
-                // Get time info in ET
-                const { timestamp, year, month, day, hour, minute, } = getTimeInfoInET();
-                // Main log info
-                const mainLogInfo = {
-                    id: `${launchInfo ? launchInfo.userId : 'unknown'}-${Date.now()}-${Math.floor(Math.random() * 100000)}-${Math.floor(Math.random() * 100000)}`,
-                    userFirstName: (launchInfo ? launchInfo.userFirstName : 'unknown'),
-                    userLastName: (launchInfo ? launchInfo.userLastName : 'unknown'),
-                    userEmail: (launchInfo ? launchInfo.userEmail : 'unknown'),
-                    userId: (launchInfo ? launchInfo.userId : 'unknown'),
-                    isLearner: (launchInfo && !!launchInfo.isLearner),
-                    isAdmin: (launchInfo && !!launchInfo.isAdmin),
-                    isTTM: (launchInfo && !!launchInfo.isTTM),
-                    courseId: (launchInfo ? launchInfo.courseId : 'unknown'),
-                    courseName: (launchInfo ? launchInfo.contextLabel : 'unknown'),
-                    browser,
-                    device,
-                    year,
-                    month,
-                    day,
-                    hour,
-                    minute,
-                    timestamp,
-                    context: (typeof logOpts.context === 'string'
-                        ? logOpts.context
-                        : ((_q = ((_p = logOpts.context) !== null && _p !== void 0 ? _p : {})._) !== null && _q !== void 0 ? _q : LogBuiltInMetadata.Context.Uncategorized)),
-                    subcontext: ((_r = logOpts.subcontext) !== null && _r !== void 0 ? _r : LogBuiltInMetadata.Context.Uncategorized),
-                    tags: ((_s = logOpts.tags) !== null && _s !== void 0 ? _s : []),
-                    level: ((_t = logOpts.level) !== null && _t !== void 0 ? _t : LogLevel$1.Info),
-                    metadata: ((_u = logOpts.metadata) !== null && _u !== void 0 ? _u : {}),
-                };
-                // Type-specific info
-                const typeSpecificInfo = (('error' in opts && opts.error)
-                    ? {
-                        type: LogType$1.Error,
-                        errorMessage: (_v = logOpts.error.message) !== null && _v !== void 0 ? _v : 'Unknown message',
-                        errorCode: (_w = logOpts.error.code) !== null && _w !== void 0 ? _w : ReactKitErrorCode$1.NoCode,
-                        errorStack: (_x = logOpts.error.stack) !== null && _x !== void 0 ? _x : 'No stack',
-                    }
-                    : {
-                        type: LogType$1.Action,
-                        target: ((_y = logOpts.target) !== null && _y !== void 0 ? _y : LogBuiltInMetadata.Target.NoTarget),
-                        action: ((_z = logOpts.action) !== null && _z !== void 0 ? _z : LogAction$1.Unknown),
-                    });
-                // Source-specific info
-                const sourceSpecificInfo = (logOpts.overrideAsClientEvent
-                    ? {
-                        source: LogSource$1.Client,
-                    }
-                    : {
-                        source: LogSource$1.Server,
-                        routePath: req.path,
-                        routeTemplate: req.route.path,
-                    });
-                // Build log event
-                const log = Object.assign(Object.assign(Object.assign({}, mainLogInfo), typeSpecificInfo), sourceSpecificInfo);
-                // Either print to console or save to db
-                const logCollection = internalGetLogCollection();
-                if (logCollection) {
-                    // Store to the log collection
-                    yield logCollection.insert(log);
-                }
-                else if (log.type === LogType$1.Error) {
-                    // Print to console
-                    // eslint-disable-next-line no-console
-                    console.error('dce-reactkit error log:', log);
-                }
-                else {
-                    // eslint-disable-next-line no-console
-                    console.log('dce-reactkit action log:', log);
-                }
-                // Return log entry
-                return log;
-            }
-            catch (err) {
-                // Print because we cannot store the error
-                // eslint-disable-next-line no-console
-                console.error('Could not log the following:', logOpts, 'due to this error:', ((_0 = err) !== null && _0 !== void 0 ? _0 : {}).message, ((_1 = err) !== null && _1 !== void 0 ? _1 : {}).stack);
-                // Create a dummy log to return
-                const dummyMainInfo = {
-                    id: '-1',
-                    userFirstName: 'Unknown',
-                    userLastName: 'Unknown',
-                    userEmail: 'unknown@harvard.edu',
-                    userId: 1,
-                    isLearner: false,
-                    isAdmin: false,
-                    isTTM: false,
-                    courseId: 1,
-                    courseName: 'Unknown',
-                    browser: {
-                        name: 'Unknown',
-                        version: 'Unknown',
-                    },
-                    device: {
-                        isMobile: false,
-                        os: 'Unknown',
-                    },
-                    year: 1,
-                    month: 1,
-                    day: 1,
-                    hour: 1,
-                    minute: 1,
-                    timestamp: Date.now(),
-                    tags: [],
-                    level: LogLevel$1.Warn,
-                    metadata: {},
-                    context: LogBuiltInMetadata.Context.Uncategorized,
-                    subcontext: LogBuiltInMetadata.Context.Uncategorized,
-                };
-                const dummyTypeSpecificInfo = {
-                    type: LogType$1.Error,
-                    errorMessage: 'Unknown',
-                    errorCode: 'Unknown',
-                    errorStack: 'No Stack',
-                };
-                const dummySourceSpecificInfo = {
-                    source: LogSource$1.Server,
-                    routePath: req.path,
-                    routeTemplate: req.route.path,
-                };
-                const log = Object.assign(Object.assign(Object.assign({}, dummyMainInfo), dummyTypeSpecificInfo), dummySourceSpecificInfo);
-                return log;
-            }
-        });
-        /*------------------------------------------------------------------------*/
-        /*                              Call handler                              */
-        /*------------------------------------------------------------------------*/
-        // Keep track of whether a response was already sent
-        let responseSent = false;
-        /**
-         * Redirect the user to another path or url
-         * @author Gabe Abrams
-         * @param pathOrURL the path or url to redirect to
-         */
-        const redirect = (pathOrURL) => {
-            responseSent = true;
-            res.redirect(pathOrURL);
-        };
-        /**
-         * Send text to the client (with an optional status code)
-         * @author Gabe Abrams
-         * @param text the text to send to the client
-         * @parm [status=200] the http status code to send
-         */
-        const send = (text, status = 200) => {
-            responseSent = true;
-            res.status(status).send(text);
-        };
-        /**
-         * Render an error page
-         * @author Gabe Abrams
-         * @param renderOpts object containing all arguments
-         * @param [renderOpts.title=An Error Occurred] title of the error box
-         * @param [renderOpts.description=An unknown server error occurred. Please contact support.]
-         *   a human-readable description of the error
-         * @param [renderOpts.code=ReactKitErrorCode.NoCode] error code to show
-         * @param [renderOpts.pageTitle=renderOpts.title] title of the page/tab if it differs from
-         *   the title of the error
-         * @param [renderOpts.status=500] http status code
-         */
-        const renderErrorPage = (renderOpts = {}) => {
-            var _a, _b, _c;
-            const html = genErrorPage(renderOpts);
-            send(html, (_a = renderOpts.status) !== null && _a !== void 0 ? _a : 500);
-            // Log server-side error if not a session expired error or 404
-            if (renderOpts.status && renderOpts.status === 404) {
-                return;
-            }
-            if ((_b = renderOpts.title) === null || _b === void 0 ? void 0 : _b.toLowerCase().includes('session expired')) {
-                return;
-            }
-            logServerEvent({
-                context: LogBuiltInMetadata.Context.ServerRenderedErrorPage,
-                error: {
-                    message: `${renderOpts.title}: ${renderOpts.description}`,
-                    code: renderOpts.code,
-                },
-                metadata: {
-                    title: renderOpts.title,
-                    description: renderOpts.description,
-                    code: renderOpts.code,
-                    pageTitle: renderOpts.pageTitle,
-                    status: (_c = renderOpts.status) !== null && _c !== void 0 ? _c : 500,
-                },
-            });
-        };
-        /**
-         * Render an info page
-         * @author Gabe Abrams
-         * @param renderOpts object containing all arguments
-         * @param renderOpts.title title of the info box
-         * @param renderOpts.body a human-readable text body for the info alert
-         */
-        const renderInfoPage = (renderOpts) => {
-            const html = genInfoPage(renderOpts);
-            send(html, 200);
-        };
-        /**
-         * Render custom HTML
-         * @author Gabe Abrams
-         * @param htmlOpts object containing all arguments
-         * @param htmlOpts.html the HTML to send to the client
-         * @param [ejsOpts.status=200] the http status code to send
-         */
-        const renderCustomHTML = (htmlOpts) => {
-            var _a;
-            send(htmlOpts.html, (_a = htmlOpts.status) !== null && _a !== void 0 ? _a : 200);
-        };
-        // Call the handler
-        try {
-            const results = yield opts.handler({
-                params: output,
-                req,
-                send,
-                next: () => {
-                    responseSent = true;
-                    next();
-                },
-                redirect,
-                renderErrorPage,
-                renderInfoPage,
-                renderCustomHTML,
-                logServerEvent,
-            });
-            // Send results to client (only if next wasn't called)
-            if (!responseSent) {
-                return handleSuccess(res, results !== null && results !== void 0 ? results : undefined);
-            }
-        }
-        catch (err) {
-            // Prefix error message if needed
-            if (opts.unhandledErrorMessagePrefix
-                && err instanceof Error
-                && err.message
-                && err.name !== 'ErrorWithCode') {
-                err.message = `${opts.unhandledErrorMessagePrefix.trim()} ${err.message.trim()}`;
-            }
-            // Send error to client (only if next wasn't called)
-            if (!responseSent) {
-                handleError(res, err);
-                // Log server-side error
-                logServerEvent({
-                    context: LogBuiltInMetadata.Context.ServerEndpointError,
-                    error: err,
-                });
-                return;
-            }
-            // Log error that was not responded with
-            // eslint-disable-next-line no-console
-            console.log('Error occurred but could not be sent to client because a response was already sent:', err);
-        }
-    });
-};
-
-/**
- * Stub a server endpoint response
- * @author Gabe Abrams
- * @param opts object containing all arguments
- * @param [opts.method=GET] http method to stub
- * @param opts.path full pathname to stub
- * @param opts.body body of response if stubbing a successful response
- * @param opts.errorMessage message of error if stubbing a failed response
- * @param [opts.errorCode] error code if stubbing a failed response
- */
-const stubServerEndpoint = _setStubResponse;
-
-/**
- * Start a dynamic wait, call the function once the operation has completed and
- *   the dynamic wait will continue waiting for the rest of the minimum time
- * @author Gabe Abrams
- * @param minWaitMs the minimum number of ms to wait
- * @returns async function to call to finish the wait
+ * @param minWaitMs the minimum number of ms to wait
+ * @returns async function to call to finish the wait
  */
 const startMinWait = (minWaitMs) => {
     const startTimestamp = Date.now();
@@ -15545,27 +14189,11 @@ const parallelLimit = (taskFunctions, limit) => __awaiter(void 0, void 0, void 0
 });
 
 /**
- * Initialize a log collection given the dce-mango Collection class
+ * Route for checking the status of the current user's
+ *   access to log review
  * @author Gabe Abrams
- * @param Collection the Collection class from dce-mango
- * @returns initialized logCollection
  */
-const initLogCollection = (Collection) => {
-    return new Collection('Log', {
-        uniqueIndexKey: 'id',
-        indexKeys: [
-            'courseId',
-            'context',
-            'subcontext',
-            'tags',
-            'year',
-            'month',
-            'day',
-            'hour',
-            'type',
-        ],
-    });
-};
+const LOG_REVIEW_STATUS_ROUTE = `${ROUTE_PATH_PREFIX}/logs/access_allowed`;
 
 /*------------------------------------------------------------------------*/
 /* -------------------------------- Cache ------------------------------- */
@@ -15707,66 +14335,6 @@ const getLocalTimeInfo = (dateOrTimestamp) => {
     };
 };
 
-/**
- * Add all routes for the DBEditor
- * @author Yuen Ler Chow
- * @param opts object containing all arguments
- * @param opts.app express app to add routes too
- * @param opts.collectionName the name of the collection
- * @param opts.adminsOnly true if the endpoint is for admins only
- * @param opts.collection dce-mango db collection
- */
-const addDBEditorEndpoints = (opts) => {
-    const { app, collectionName, adminsOnly, collection, } = opts;
-    // Generate the endpoint path
-    const endpointPath = generateEndpointPath(collectionName, adminsOnly);
-    /**
-     * List all items in the collection
-     * @author Yuen Ler Chow
-     * @returns {any[]} the list of items in the collection
-     */
-    app.get(endpointPath, genRouteHandler({
-        paramTypes: {
-            filterQuery: ParamType$1.JSONOptional,
-        },
-        handler: ({ params }) => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            const filterQuery = (_a = params.filterQuery) !== null && _a !== void 0 ? _a : {};
-            const categories = yield collection.find(filterQuery);
-            return categories;
-        }),
-    }));
-    /**
-     * Create a new item in the collection
-     * @author Yuen Ler Chow
-     * @param {any} item the item to create
-     */
-    app.post(endpointPath, genRouteHandler({
-        paramTypes: {
-            item: ParamType$1.JSON,
-        },
-        handler: ({ params, }) => __awaiter(void 0, void 0, void 0, function* () {
-            // Destructure params
-            const { item, } = params;
-            yield collection.insert(item);
-        }),
-    }));
-    /**
-     * Remove an item from the collection by id
-     * @author Yuen Ler Chow
-     */
-    app.delete(`${endpointPath}/:id`, genRouteHandler({
-        paramTypes: {
-            id: ParamType$1.String,
-        },
-        handler: ({ params, }) => __awaiter(void 0, void 0, void 0, function* () {
-            // Destructure params
-            const { id, } = params;
-            yield collection.delete({ id });
-        }),
-    }));
-};
-
 /**
  * Given an array of strings, create a single comma-separated string that includes
  * 'and' as well as an oxford comma.
@@ -16308,203 +14876,6 @@ const shuffleArray = (arr) => {
     return newArr;
 };
 
-/**
- * Sends and retries an http request
- * @author Gabriel Abrams
- * @param opts object containing all arguments
- * @param opts.path path to send request to
- * @param [opts.host] host to send request to
- * @param [opts.method=GET] http method to use
- * @param [opts.params] body/data to include in the request
- * @param [opts.headers] headers to include in the request
- * @param [opts.sendCrossDomainCredentials=true if in development mode] if true,
- *   send cross-domain credentials even if not in dev mode
- * @param [opts.responseType=JSON] expected response type
- * @returns { body, status, headers } on success
- */
-const sendServerToServerRequest = (opts) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    // Process method
-    const method = (opts.method || 'GET');
-    // Encode objects within params
-    let params;
-    if (opts.params) {
-        params = {};
-        Object.entries(opts.params).forEach(([key, val]) => {
-            if (typeof val === 'object' && !Array.isArray(val)) {
-                params[key] = JSON.stringify(val);
-            }
-            else {
-                params[key] = val;
-            }
-        });
-    }
-    // Stringify parameters
-    const stringifiedParams = qs__default["default"].stringify(params || {}, {
-        encodeValuesOnly: true,
-        arrayFormat: 'brackets',
-    });
-    // Create url (include query if GET)
-    const query = (method === 'GET' ? `?${stringifiedParams}` : '');
-    let url;
-    if (!opts.host) {
-        // No host included at all. Just send to a path
-        url = `${opts.path}${query}`;
-    }
-    else {
-        url = `https://${opts.host}${opts.path}${query}`;
-    }
-    // Update headers
-    const headers = opts.headers || {};
-    let data = null;
-    if (!headers['Content-Type']) {
-        // Form encoded
-        headers['Content-Type'] = 'application/x-www-form-urlencoded';
-        // Add data if applicable
-        data = (method !== 'GET' ? stringifiedParams : null);
-    }
-    else {
-        // JSON encode
-        data = params;
-    }
-    // Encode data
-    let encodedData;
-    if (data) {
-        if (headers['Content-Type'] === 'application/x-www-form-urlencoded') {
-            encodedData = new URLSearchParams(params);
-        }
-        else {
-            encodedData = JSON.stringify(data);
-        }
-    }
-    // Send request
-    try {
-        const response = yield fetch(url, {
-            method,
-            mode: 'cors',
-            headers: headers !== null && headers !== void 0 ? headers : {},
-            body: ((method !== 'GET' && encodedData)
-                ? encodedData
-                : undefined),
-            redirect: 'follow',
-        });
-        // Get headers map
-        const responseHeaders = {};
-        response.headers.forEach((value, key) => {
-            responseHeaders[key] = value;
-        });
-        // Process response based on responseType
-        try {
-            // Parse response
-            let responseBody;
-            if (opts.responseType
-                && opts.responseType === 'Text') {
-                // Response type is text
-                responseBody = yield response.text();
-            }
-            else {
-                // Response type is JSON
-                responseBody = yield response.json();
-            }
-            // Return response
-            return {
-                body: responseBody,
-                status: response.status,
-                headers: responseHeaders,
-            };
-        }
-        catch (err) {
-            throw new ErrorWithCode(`Failed to parse response as ${opts.responseType}: ${err === null || err === void 0 ? void 0 : err.message}`, ReactKitErrorCode$1.ResponseParseError);
-        }
-    }
-    catch (err) {
-        // Self-signed certificate error:
-        if ((_a = err === null || err === void 0 ? void 0 : err.message) === null || _a === void 0 ? void 0 : _a.includes('self signed certificate')) {
-            throw new ErrorWithCode('We refused to send a request because the receiver has self-signed certificates.', ReactKitErrorCode$1.SelfSigned);
-        }
-        // No tries left
-        throw new ErrorWithCode(`We encountered an error when trying to send a network request. If this issue persists, contact an admin. Error: ${err === null || err === void 0 ? void 0 : err.message}`, ReactKitErrorCode$1.NotConnected);
-    }
-});
-
-/**
- * Send a server-to-server request from this sever to another server that uses
- *   dce-reactkit [for server only]
- * @author Gabe Abrams
- * @param opts object containing all arguments
- * @param opts.host - the host of the other server
- * @param opts.path - the path of the other server's endpoint
- * @param [opts.method=GET] - the method of the endpoint
- * @param [opts.params] - query/body parameters to include
- * @param [opts.headers] - headers to include
- * @returns response from server
- */
-const visitEndpointOnAnotherServer = (opts) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    // Remove properties with undefined values
-    let params;
-    if (opts.params) {
-        params = Object.fromEntries(Object
-            .entries(opts.params)
-            .filter(([, value]) => {
-            return value !== undefined;
-        }));
-    }
-    // Automatically JSONify arrays and objects
-    if (params) {
-        params = Object.fromEntries(Object
-            .entries(params)
-            .map(([key, value]) => {
-            if (Array.isArray(value) || typeof value === 'object') {
-                return [key, JSON.stringify(value)];
-            }
-            return [key, value];
-        }));
-    }
-    // Send the request
-    const response = yield sendServerToServerRequest({
-        host: opts.host,
-        path: opts.path,
-        method: (_a = opts.method) !== null && _a !== void 0 ? _a : 'GET',
-        params,
-    });
-    // Check for failure
-    if (!response || !response.body) {
-        throw new ErrorWithCode('We didn\'t get a response from the server. Please check your internet connection.', ReactKitErrorCode$1.NoResponse);
-    }
-    if (!response.body.success) {
-        // Other errors
-        throw new ErrorWithCode((response.body.message
-            || 'An unknown error occurred. Please contact an admin.'), (response.body.code
-            || ReactKitErrorCode$1.NoCode));
-    }
-    // Success! Extract the body
-    const { body } = response.body;
-    // Return
-    return body;
-});
-
-const punctuationRegex = /[!@#$%^&*(),.?\/;:'"\-\[\]]/g;
-/**
- * Get number of words in string
- * @author Gardenia Liu
- * @author Allison Zhang
- * @author Gabe Abrams
- * @param text the string to check
- * @returns number of words in the string
- */
-const getWordCount = (text) => {
-    const trimmedTextWithoutPunctuation = (text
-        // Remove leading and trailing whitespace
-        .trim()
-        // Remove punctuation
-        .replace(punctuationRegex, ''));
-    if (trimmedTextWithoutPunctuation.length === 0) {
-        return 0;
-    }
-    return trimmedTextWithoutPunctuation.split(/\s+/g).length;
-};
-
 /**
  * Days of the week
  * @author Gabe Abrams
@@ -16543,6 +14914,7 @@ exports.ItemPicker = ItemPicker;
 exports.LoadingSpinner = LoadingSpinner;
 exports.LogAction = LogAction$1;
 exports.LogBuiltInMetadata = LogBuiltInMetadata;
+exports.LogLevel = LogLevel$1;
 exports.LogReviewer = LogReviewer;
 exports.LogSource = LogSource$1;
 exports.LogType = LogType$1;
@@ -16564,7 +14936,6 @@ exports.ToggleSwitch = ToggleSwitch;
 exports.Tooltip = Tooltip;
 exports.Variant = Variant$1;
 exports.abbreviate = abbreviate;
-exports.addDBEditorEndpoints = addDBEditorEndpoints;
 exports.addFatalErrorHandler = addFatalErrorHandler;
 exports.alert = alert;
 exports.avg = avg;
@@ -16582,20 +14953,14 @@ exports.forEachAsync = forEachAsync;
 exports.forceNumIntoBounds = forceNumIntoBounds;
 exports.genCSV = genCSV;
 exports.genCommaList = genCommaList;
-exports.genRouteHandler = genRouteHandler;
 exports.getHumanReadableDate = getHumanReadableDate;
 exports.getLocalTimeInfo = getLocalTimeInfo;
 exports.getMonthName = getMonthName;
 exports.getOrdinal = getOrdinal;
 exports.getPartOfDay = getPartOfDay;
 exports.getTimeInfoInET = getTimeInfoInET;
-exports.getWordCount = getWordCount;
-exports.handleError = handleError;
-exports.handleSuccess = handleSuccess;
 exports.idify = idify;
 exports.initClient = initClient;
-exports.initLogCollection = initLogCollection;
-exports.initServer = initServer;
 exports.isMobileOrTablet = isMobileOrTablet;
 exports.leaveToURL = leaveToURL;
 exports.logClientEvent = logClientEvent;
@@ -16620,7 +14985,6 @@ exports.useForceRender = useForceRender;
 exports.validateEmail = validateEmail;
 exports.validatePhoneNumber = validatePhoneNumber;
 exports.validateString = validateString;
-exports.visitEndpointOnAnotherServer = visitEndpointOnAnotherServer;
 exports.visitServerEndpoint = visitServerEndpoint;
 exports.waitMs = waitMs;
 //# sourceMappingURL=index.js.map