@nualang/nualang-ui-components 0.1.1435 → 0.1.1437

package/dist/Assignments/CreateAssignmentDialog/CreateAssignmentDialog.js

@@ -83,7 +83,9 @@ export default function CreateAssignmentDialog({
     return response;
   }, {
     filters: {
-      courseIds: selectedClassroomCourses?.toString()
+      courseIds: selectedClassroomCourses?.toString(),
+      // Sections/topics are only returned when verbose; needed for the title autofill
+      verbose: true
     }
   }, {
     enabled: !!assignment.classroomId

package/dist/Cards/Course/Course.js

@@ -862,7 +862,7 @@ function CourseCard({
       handleViewCourse(parentId);
     }
   };
-  const courseSections = sectionsQuery.isSuccess ? sectionsQuery.data.Items : [];
+  const courseSections = sectionsQuery.isSuccess && sectionsQuery.data?.Items || [];
   const topicDifficulties = sectionsQuery.isSuccess ? [...new Set(courseSections.flatMap(section => section.topics || []).map(topic => topic.difficulty).filter(Boolean))] : [];
   const deleteCourse = async () => {
     const confirmed = await confirm(t("delete_course"), t("delete_course_confirmation"), "", true, t("course_deletion_note", {
@@ -1263,7 +1263,7 @@ function CourseCard({
       dialogTitle: courseName,
       open: isOutlineOpen,
       handleClose: handleCloseOutline,
-      sections: sectionsQuery.isSuccess ? sectionsQuery.data.Items : [],
+      sections: courseSections,
       isLoading: sectionsQuery.isLoading,
       isMember: isMember,
       completions: completions,

package/dist/Cards/FeedbackCard/FeedbackCard.js

@@ -55,6 +55,10 @@ export default function FeedbackCard({
   userData = [],
   hasSubmission = false,
   aiGrade = {},
+  // Discuss AI feedback, already combined with the all-AI switch. It stops new
+  // AI feedback being generated; assessments already saved stay visible, since
+  // a teacher may have set them.
+  isDiscussAIFeedbackEnabled = true,
   onGenerateFeedback = () => {},
   onSubmitFeedback = () => {},
   setSelectedRecording = () => {},
@@ -201,6 +205,7 @@ export default function FeedbackCard({
     }
   }, [submitTrigger]);
   const handleGenerateAI = async () => {
+    if (!isDiscussAIFeedbackEnabled) return;
     setAiJustGenerated(true);
     setIsGeneratingFeedback(true);
     setIsGeneratingIndividual(true);
@@ -566,7 +571,7 @@ export default function FeedbackCard({
                   disabled: !hasSubmission || isGeneratingFeedback,
                   onClick: handleOpenRecordingDialog,
                   children: t("view_recording")
-                }), /*#__PURE__*/_jsx(Button, {
+                }), isDiscussAIFeedbackEnabled && /*#__PURE__*/_jsx(Button, {
                   variant: "contained",
                   color: "secondary",
                   disabled: !hasSubmission || isGeneratingFeedback,

package/dist/Chat/Messages/Messages.js

@@ -14,7 +14,7 @@ const useStyles = makeStyles()(theme => ({
     overflow: "auto",
     padding: theme.spacing(2),
     "@media print": {
-      position: "right"
+      overflow: "visible"
     }
   }
 }));

package/dist/Chat/Messages/Question/Question.js

@@ -100,11 +100,11 @@ function Answers({
     if (!isLiveGame) {
       if (value.correct) {
         setAnsweredCorrectly(true);
-        handleCorrectQuestionAnswer(question, value);
+        handleCorrectQuestionAnswer(question, value, answers);
       }
       if (!value.correct) {
         setAnsweredCorrectly(false);
-        handleIncorrectQuestionAnswer(question, value);
+        handleIncorrectQuestionAnswer(question, value, answers);
       }
     }
   };

package/dist/Dialogs/DynamicAIWarning/DynamicAIWarning.js

@@ -23,7 +23,7 @@ function DynamicAIWarning({
   return /*#__PURE__*/_jsxs(ResponsiveDialog, {
     open: open,
     handleClose: handleClose,
-    submitText: t("classroom_settings"),
+    submitText: t("ai_settings"),
     dialogTitle: dialogTitle,
     children: [/*#__PURE__*/_jsxs(Box, {
       sx: {
@@ -168,7 +168,7 @@ function DynamicAIWarning({
             fontWeight: "bold"
           },
           onClick: submit,
-          children: t("classroom_settings")
+          children: t("ai_settings")
         }), " ", "for this class."]
       })]
     }), /*#__PURE__*/_jsx(Divider, {

package/dist/Dialogs/GroupedFeedbackDialog/GroupedFeedbackDialog.js

@@ -28,6 +28,9 @@ export default function GroupFeedbackDialog({
   t = x => x,
   handleBatchGradeConversations = () => {},
   aiGrade = {},
+  // Discuss AI feedback, already combined with the all-AI switch, so the
+  // generate controls disappear when either is off.
+  isDiscussAIFeedbackEnabled = true,
   selectedGroup = {},
   setSelectedRecording = () => {},
   selectedRecording = {},
@@ -200,7 +203,7 @@ export default function GroupFeedbackDialog({
     }).filter(member => member.name !== "Unknown");
   };
   const handleGenerateFeedback = async discussionData => {
-    if (!handleBatchGradeConversations) return;
+    if (!isDiscussAIFeedbackEnabled || !handleBatchGradeConversations) return;
     setIsGeneratingIndividual(true);
     try {
       const joinedMembersWithNames = getJoinedMembersNames(discussionData.joinedMembers || [], userData);
@@ -243,7 +246,7 @@ export default function GroupFeedbackDialog({
         customFeedback: customFeedbackText
       };
     });
-    if (conversationsToGrade.length > 0 && handleBatchGradeConversations) {
+    if (isDiscussAIFeedbackEnabled && conversationsToGrade.length > 0 && handleBatchGradeConversations) {
       setIsGeneratingAll(true);
       setGenerateAllUsed(true);
       try {
@@ -546,7 +549,7 @@ export default function GroupFeedbackDialog({
               sx: {
                 flex: 1
               }
-            }), /*#__PURE__*/_jsx(Button, {
+            }), isDiscussAIFeedbackEnabled && /*#__PURE__*/_jsx(Button, {
               variant: "contained",
               color: "secondary",
               endIcon: /*#__PURE__*/_jsx(AutoFixHighIcon, {}),
@@ -603,6 +606,7 @@ export default function GroupFeedbackDialog({
               existingFeedback: feedbackByMeetingId[feedbackMeetingId] || {},
               onGenerateFeedback: () => openCustomPromptForSingle(discussionData),
               onSubmitFeedback: handleSubmitFeedback,
+              isDiscussAIFeedbackEnabled: isDiscussAIFeedbackEnabled,
               setSelectedRecording: setSelectedRecording,
               selectedRecording: selectedRecording,
               s3Url: s3Url,

package/dist/Dialogs/GroupedFeedbackDialog/GroupedFeedbackDialog.test.js

@@ -0,0 +1,39 @@
+import { render } from "@testing-library/react";
+import { describe, it, expect } from "vitest";
+import { createTheme, ThemeProvider } from "@mui/material/styles";
+import GroupedFeedbackDialog from "./GroupedFeedbackDialog";
+import { WithData } from "./GroupedFeedbackDialog.stories";
+
+// This repo has no jest-dom matchers and no auto-cleanup, so assertions are
+// plain and each test unmounts - matching AISettings.test.jsx.
+import { jsx as _jsx } from "react/jsx-runtime";
+const setup = (props = {}) => render(/*#__PURE__*/_jsx(ThemeProvider, {
+  theme: createTheme(),
+  children: /*#__PURE__*/_jsx(GroupedFeedbackDialog, {
+    ...WithData.args,
+    ...props
+  })
+}));
+describe("GroupedFeedbackDialog AI controls", () => {
+  it("offers feedback generation when the classroom allows AI", () => {
+    const {
+      queryAllByText,
+      unmount
+    } = setup();
+    expect(queryAllByText("generate_feedback").length).toBeGreaterThan(0);
+    unmount();
+  });
+  it("removes every generate control when the classroom limits AI", () => {
+    // Teachers can still write and submit their own feedback - only the AI
+    // route away from the page is closed.
+    const {
+      queryAllByText,
+      unmount
+    } = setup({
+      isDiscussAIFeedbackEnabled: false
+    });
+    expect(queryAllByText("generate_feedback").length).toBe(0);
+    expect(queryAllByText("submit_feedback").length).toBeGreaterThan(0);
+    unmount();
+  });
+});

package/dist/Dialogs/QuickCreateClassroomDialog/QuickCreateClassroomDialog.js

@@ -145,7 +145,6 @@ export default function QuickCreateClassroomDialog({
         visibility: "private",
         vchatEnabled: true,
         vchatEnabledInSettings: true,
-        isDynamicResponsesEnabled: "enabled",
         enrolmentKey: generateRandomEnrolmentKey(),
         allowedDomains: [],
         collaborators: [],

package/dist/Exercises/Bot/Bot.js

@@ -29,8 +29,8 @@ import ReportProblem from "../../Misc/ReportProblem/ReportProblem";
 import NualaSignInImage from "../../img/nuala_sign_in.svg";
 import { startJoyrideWhenReady } from "../../utils/joyride";
 import { collectCorrections } from "../../utils/correction";
-import { getDynamicResponsesSetting } from "../../utils/dynamicResponses";
 import { getBotContentTemplateType } from "../../utils";
+import { AI_ENABLED, courseAIValue, isCourseAIEnabled } from "../../utils/aiControls";
 import { useTheme } from "@mui/material/styles";
 import config from "../../config";
 import { useNavigate } from "react-router";
@@ -288,11 +288,17 @@ function Bot({
     } = getRecognitionParams();
     toggleListen(learnLang, speechContexts, model, undefined, autoStopOptions);
   };
-  const isDynamicResponsesClassroomEnabled = getDynamicResponsesSetting({
-    botSetting: isDynamicResponsesEnabled,
-    parentClassroom,
-    courseSettings
-  });
+
+  // The classroom's all-AI and chatbot switches, and the course's, can each
+  // silence dynamic responses whatever the bot's own setting. Only when they
+  // allow AI does the bot's setting decide - except for courses saved as
+  // "enabled", which older classroom records can still carry.
+  let isDynamicResponsesClassroomEnabled = isDynamicResponsesEnabled;
+  if (!isCourseAIEnabled(parentClassroom, courseSettings)) {
+    isDynamicResponsesClassroomEnabled = "disable";
+  } else if (courseAIValue(courseSettings) === AI_ENABLED) {
+    isDynamicResponsesClassroomEnabled = "enable";
+  }
   const exerciseState = useExerciseState({
     t,
     open,

package/dist/Forms/CreateClassroom/Steps/AISettings/AISettings.js

@@ -0,0 +1,235 @@
+import { useEffect, useRef } from "react";
+import * as Yup from "yup";
+import { Alert, Box, FormControl, FormControlLabel, FormLabel, Grid, IconButton, Radio, RadioGroup, Tooltip, Typography } from "@mui/material";
+import HelpIcon from "@mui/icons-material/Help";
+import SearchIcon from "@mui/icons-material/Search";
+import EastIcon from "@mui/icons-material/East";
+import { AI_DISABLED, AI_ENABLED, AI_FIELDS, aiLockedBy, classroomAIValue, courseAIValue } from "../../../../utils/aiControls";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export const AI_INFO_URL = "https://www.waysidepublishing.com/digital-solutions/ai-safety-and-trust";
+
+// One Allowed / Limited choice for one of AI_FIELDS.
+function AISwitch({
+  t,
+  name,
+  label,
+  description,
+  info,
+  value,
+  disabled,
+  dataCy,
+  handleChange,
+  handleBlur
+}) {
+  return /*#__PURE__*/_jsxs(FormControl, {
+    component: "fieldset",
+    children: [/*#__PURE__*/_jsxs(FormLabel, {
+      component: "legend",
+      children: [t(label), info && /*#__PURE__*/_jsx(Tooltip, {
+        title: t(info),
+        placement: "right",
+        children: /*#__PURE__*/_jsx(IconButton, {
+          sx: {
+            padding: 0,
+            marginLeft: 1
+          },
+          children: /*#__PURE__*/_jsx(HelpIcon, {
+            fontSize: "small"
+          })
+        })
+      })]
+    }), /*#__PURE__*/_jsx(Typography, {
+      color: "textSecondary",
+      children: t(description)
+    }), /*#__PURE__*/_jsxs(RadioGroup, {
+      row: true,
+      "aria-label": name,
+      name: name,
+      value: value,
+      onChange: handleChange,
+      onBlur: handleBlur,
+      children: [/*#__PURE__*/_jsx(FormControlLabel, {
+        value: AI_ENABLED,
+        control: /*#__PURE__*/_jsx(Radio, {}),
+        label: t("ai_allowed"),
+        disabled: disabled,
+        "data-cy": `allow-${dataCy}-in-settings`
+      }), /*#__PURE__*/_jsx(FormControlLabel, {
+        value: AI_DISABLED,
+        control: /*#__PURE__*/_jsx(Radio, {}),
+        label: t("ai_limited"),
+        disabled: disabled,
+        "data-cy": `limit-${dataCy}-in-settings`
+      })]
+    })]
+  });
+}
+
+// The classroom's AI section: a switch for all AI, and one each for chatbot
+// dynamic responses and Discuss AI feedback. Per-course chatbot overrides stay
+// in Course Settings, so this section only reports them.
+function AISettings({
+  t = text => text,
+  values,
+  handleChange,
+  handleBlur,
+  courses = [],
+  courseSettings = {},
+  scrollToDynamicResponses = false,
+  setScrollToDynamicResponses,
+  // The saved classroom record, which the API stamps with `aiLockedBy` when
+  // the classroom's customer has limited AI. `values` is only the form state.
+  classroom
+}) {
+  const aiControlRef = useRef(null);
+  useEffect(() => {
+    // Guarded: the notice can fire before this section has mounted.
+    if (scrollToDynamicResponses && aiControlRef.current) {
+      aiControlRef.current.scrollIntoView({
+        behavior: "smooth",
+        block: "center"
+      });
+      setScrollToDynamicResponses && setScrollToDynamicResponses(false);
+    }
+  }, [scrollToDynamicResponses]);
+  const isAllLimited = classroomAIValue(values) === AI_DISABLED;
+  const isAllLocked = Boolean(aiLockedBy(classroom));
+
+  // While all AI is off, a feature shows as limited - which is what students
+  // get - but keeps its own value for when all AI is turned back on.
+  const featureValue = field => isAllLimited ? AI_DISABLED : classroomAIValue(values, field);
+  const isChatbotLimited = featureValue(AI_FIELDS.chatbot) === AI_DISABLED;
+
+  // Courses that have turned the chatbot off for themselves. Read from the
+  // saved classroom, so this is what students currently get.
+  const overriddenCourses = courses.filter(course => courseAIValue(courseSettings?.[course.courseId]) === AI_DISABLED);
+  const switchProps = {
+    t,
+    handleChange,
+    handleBlur
+  };
+  return /*#__PURE__*/_jsxs(Grid, {
+    container: true,
+    spacing: 2,
+    ref: aiControlRef,
+    children: [/*#__PURE__*/_jsxs(Grid, {
+      size: 12,
+      children: [/*#__PURE__*/_jsx(Typography, {
+        color: "textSecondary",
+        gutterBottom: true,
+        children: t("ai_settings_desc")
+      }), /*#__PURE__*/_jsxs(Box, {
+        component: "a",
+        href: AI_INFO_URL,
+        target: "_blank",
+        rel: "noopener noreferrer",
+        sx: {
+          display: "inline-flex",
+          alignItems: "center",
+          textDecoration: "none",
+          color: "primary.main"
+        },
+        children: [/*#__PURE__*/_jsx(SearchIcon, {
+          sx: {
+            mr: 0.5
+          },
+          fontSize: "small"
+        }), /*#__PURE__*/_jsx(Typography, {
+          variant: "body2",
+          children: t("ai_learn_more")
+        }), /*#__PURE__*/_jsx(EastIcon, {
+          sx: {
+            ml: 0.5
+          },
+          fontSize: "small"
+        })]
+      })]
+    }), /*#__PURE__*/_jsxs(Grid, {
+      size: 12,
+      children: [/*#__PURE__*/_jsx(AISwitch, {
+        ...switchProps,
+        name: AI_FIELDS.all,
+        label: "limit_ai",
+        description: "limit_ai_desc",
+        info: "limit_ai_info",
+        value: classroomAIValue(values),
+        disabled: isAllLocked,
+        dataCy: "ai"
+      }), isAllLocked && /*#__PURE__*/_jsx(Alert, {
+        severity: "info",
+        "data-cy": "ai-locked-notice",
+        sx: {
+          mt: 1
+        },
+        children: t("ai_locked_notice")
+      }), !isAllLocked && isAllLimited && /*#__PURE__*/_jsx(Alert, {
+        severity: "info",
+        "data-cy": "ai-limited-notice",
+        sx: {
+          mt: 1
+        },
+        children: t("ai_limited_classroom_notice")
+      })]
+    }), /*#__PURE__*/_jsx(Grid, {
+      size: 12,
+      children: /*#__PURE__*/_jsxs(Box, {
+        sx: {
+          pl: 4,
+          display: "grid",
+          gap: 2
+        },
+        children: [/*#__PURE__*/_jsxs(Box, {
+          children: [/*#__PURE__*/_jsx(AISwitch, {
+            ...switchProps,
+            name: AI_FIELDS.chatbot,
+            label: "chatbot_ai",
+            description: "chatbot_ai_desc",
+            info: "dynamic_responses_info",
+            value: featureValue(AI_FIELDS.chatbot),
+            disabled: isAllLimited || Boolean(aiLockedBy(classroom, AI_FIELDS.chatbot)),
+            dataCy: "chatbot-ai"
+          }), !isAllLocked && Boolean(aiLockedBy(classroom, AI_FIELDS.chatbot)) && /*#__PURE__*/_jsx(Alert, {
+            severity: "info",
+            "data-cy": "ai-partly-locked-notice",
+            sx: {
+              mt: 1
+            },
+            children: t("ai_partly_locked_notice")
+          }), !isChatbotLimited && overriddenCourses.length > 0 && /*#__PURE__*/_jsxs(Alert, {
+            severity: "info",
+            "data-cy": "ai-course-overrides-notice",
+            sx: {
+              mt: 1
+            },
+            children: [t("ai_course_overrides_notice"), ": ", overriddenCourses.map(course => course.courseName).join(", ")]
+          })]
+        }), /*#__PURE__*/_jsxs(Box, {
+          children: [/*#__PURE__*/_jsx(AISwitch, {
+            ...switchProps,
+            name: AI_FIELDS.discuss,
+            label: "discuss_ai",
+            description: "discuss_ai_desc",
+            value: featureValue(AI_FIELDS.discuss),
+            disabled: isAllLimited || Boolean(aiLockedBy(classroom, AI_FIELDS.discuss)),
+            dataCy: "discuss-ai"
+          }), !isAllLocked && Boolean(aiLockedBy(classroom, AI_FIELDS.discuss)) && /*#__PURE__*/_jsx(Alert, {
+            severity: "info",
+            "data-cy": "ai-partly-locked-notice",
+            sx: {
+              mt: 1
+            },
+            children: t("ai_partly_locked_notice")
+          })]
+        })]
+      })
+    })]
+  });
+}
+AISettings.propTypes = {};
+AISettings.label = "ai_settings";
+AISettings.validationSchema = Yup.object().shape({
+  isAIEnabled: Yup.string(),
+  isDynamicResponsesEnabled: Yup.string(),
+  isDiscussAIFeedbackEnabled: Yup.string()
+});
+export default AISettings;