@capytale/meta-player 0.7.0 → 0.7.2

package/src/features/activityJS/AfterSaveAction.tsx

@@ -1,23 +1,23 @@
-import { FC, useEffect } from "react";
-import {
-  SaveCallback,
-  addAfterSave,
-  removeAfterSave,
-} from "./saverSlice";
-import { useAppDispatch } from "../../app/hooks";
-
-type AfterSaveActionProps = SaveCallback;
-
-const AfterSaveAction: FC<AfterSaveActionProps> = (props) => {
-  const dispatch = useAppDispatch();
-  useEffect(() => {
-    dispatch(addAfterSave(props));
-    return () => {
-      // Remove the callback when the component is unmounted
-      dispatch(removeAfterSave(props.name));
-    };
-  }, [props]);
-  return null;
-};
-
-export default AfterSaveAction;
+import { FC, useEffect } from "react";
+import {
+  SaveCallback,
+  addAfterSave,
+  removeAfterSave,
+} from "./saverSlice";
+import { useAppDispatch } from "../../app/hooks";
+
+type AfterSaveActionProps = SaveCallback;
+
+const AfterSaveAction: FC<AfterSaveActionProps> = (props) => {
+  const dispatch = useAppDispatch();
+  useEffect(() => {
+    dispatch(addAfterSave(props));
+    return () => {
+      // Remove the callback when the component is unmounted
+      dispatch(removeAfterSave(props.name));
+    };
+  }, [props]);
+  return null;
+};
+
+export default AfterSaveAction;

package/src/features/activityJS/BeforeResetAction.tsx

@@ -1,23 +1,23 @@
-import { FC, useEffect } from "react";
-import {
-  SaveCallback,
-  addBeforeReset,
-  removeBeforeReset,
-} from "./saverSlice";
-import { useAppDispatch } from "../../app/hooks";
-
-type BeforeResetActionProps = SaveCallback;
-
-const BeforeResetAction: FC<BeforeResetActionProps> = (props) => {
-  const dispatch = useAppDispatch();
-  useEffect(() => {
-    dispatch(addBeforeReset(props));
-    return () => {
-      // Remove the callback when the component is unmounted
-      dispatch(removeBeforeReset(props.name));
-    };
-  }, [props]);
-  return null;
-};
-
-export default BeforeResetAction;
+import { FC, useEffect } from "react";
+import {
+  SaveCallback,
+  addBeforeReset,
+  removeBeforeReset,
+} from "./saverSlice";
+import { useAppDispatch } from "../../app/hooks";
+
+type BeforeResetActionProps = SaveCallback;
+
+const BeforeResetAction: FC<BeforeResetActionProps> = (props) => {
+  const dispatch = useAppDispatch();
+  useEffect(() => {
+    dispatch(addBeforeReset(props));
+    return () => {
+      // Remove the callback when the component is unmounted
+      dispatch(removeBeforeReset(props.name));
+    };
+  }, [props]);
+  return null;
+};
+
+export default BeforeResetAction;

package/src/features/activityJS/BeforeSaveAction.tsx

@@ -1,23 +1,23 @@
-import { FC, useEffect } from "react";
-import {
-  SaveCallback,
-  addBeforeSave,
-  removeBeforeSave,
-} from "./saverSlice";
-import { useAppDispatch } from "../../app/hooks";
-
-type BeforeSaveActionProps = SaveCallback;
-
-const BeforeSaveAction: FC<BeforeSaveActionProps> = (props) => {
-  const dispatch = useAppDispatch();
-  useEffect(() => {
-    dispatch(addBeforeSave(props));
-    return () => {
-      // Remove the callback when the component is unmounted
-      dispatch(removeBeforeSave(props.name));
-    };
-  }, [props]);
-  return null;
-};
-
-export default BeforeSaveAction;
+import { FC, useEffect } from "react";
+import {
+  SaveCallback,
+  addBeforeSave,
+  removeBeforeSave,
+} from "./saverSlice";
+import { useAppDispatch } from "../../app/hooks";
+
+type BeforeSaveActionProps = SaveCallback;
+
+const BeforeSaveAction: FC<BeforeSaveActionProps> = (props) => {
+  const dispatch = useAppDispatch();
+  useEffect(() => {
+    dispatch(addBeforeSave(props));
+    return () => {
+      // Remove the callback when the component is unmounted
+      dispatch(removeBeforeSave(props.name));
+    };
+  }, [props]);
+  return null;
+};
+
+export default BeforeSaveAction;

package/src/features/activityJS/Saver.tsx

@@ -1,154 +1,154 @@
-import { FC, useEffect } from "react";
-import { useAppDispatch, useAppSelector } from "../../app/hooks";
-import {
-  selectSharedNotesContent,
-  selectComments,
-  selectGrading,
-  selectInstructions,
-  selectSaveState,
-  setIsMPDirty,
-  setIsPlayerDirty,
-  setSaveState,
-  setWorkflow,
-  selectSharedNotesType,
-  selectInstructionsType,
-} from "../activityData/activityDataSlice";
-import { useActivityJS } from "./ActivityJSProvider";
-import { selectBeforeSave, selectAfterSave } from "./saverSlice";
-import { useToast } from "../toast";
-
-const Saver: FC<{}> = () => {
-  const dispatch = useAppDispatch();
-  const activityJs = useActivityJS();
-  const instructions = useAppSelector(selectInstructions);
-  const instructionsType = useAppSelector(selectInstructionsType);
-  const sharedNotesContent = useAppSelector(selectSharedNotesContent);
-  const sharedNotesType = useAppSelector(selectSharedNotesType);
-  const comments = useAppSelector(selectComments);
-  const grading = useAppSelector(selectGrading);
-  const beforeSave = useAppSelector(selectBeforeSave);
-  const afterSave = useAppSelector(selectAfterSave);
-
-  const toast = useToast();
-
-  const executePrepareSave = () => {};
-  const save = async () => {
-    if (!activityJs.activitySession) {
-      throw new Error("No activity session to save");
-    }
-    for (const callback of Object.values(beforeSave)) {
-      try {
-        const v = callback();
-        if (v instanceof Promise) {
-          await v;
-        }
-      } catch (e) {
-        console.error("Error in beforeSave callback", e);
-        dispatch(setSaveState("idle"));
-        toast.show({
-          summary: "Erreur : enregistrement annulé",
-          detail: (e as any).toString(),
-          severity: "error",
-          life: 10000,
-        });
-        return;
-      }
-    }
-    const ab = activityJs.activitySession.activityBunch;
-    if (activityJs.activitySession.mode === "create") {
-      if (instructionsType === "rich") {
-        ab.instructions.value = {
-          lexical:
-            instructions?.format === "lexical"
-              ? typeof instructions.value === "string"
-                ? instructions.value
-                : JSON.stringify(instructions.value)
-              : null,
-          html:
-            instructions?.format === "lexical"
-              ? instructions.htmlValue
-              : (instructions?.value as string),
-        };
-      } else {
-        ab.instructions.value = {
-          lexical: null,
-          html: null,
-        };
-      }
-    }
-    if (activityJs.activitySession.mode === "review") {
-      ab.assignmentNode!.comments.value = comments || "";
-      ab.assignmentNode!.grading.value = grading || "";
-    }
-    if (
-      activityJs.activitySession.mode === "create" ||
-      activityJs.activitySession.mode === "review" ||
-      activityJs.activitySession.mode === "assignment"
-    ) {
-      if (sharedNotesContent && sharedNotesType === "rich") {
-        ab.shared_notes.value =
-          typeof sharedNotesContent === "string"
-            ? sharedNotesContent
-            : JSON.stringify(sharedNotesContent);
-      } else {
-        ab.shared_notes.value = null;
-      }
-    }
-    try {
-      await ab.save();
-      dispatch(setSaveState("idle"));
-      if (
-        activityJs.activitySession.mode === "assignment" ||
-        activityJs.activitySession.mode === "review"
-      ) {
-        dispatch(setWorkflow(ab.assignmentNode!.workflow));
-      }
-      dispatch(setIsPlayerDirty(false));
-      dispatch(setIsMPDirty(false));
-      toast.show({
-        summary: "Sauvegarde réussie",
-        detail: "L'activité a bien été enregistrée.",
-        severity: "success",
-        life: 2000,
-      });
-      for (const callback of Object.values(afterSave)) {
-        try {
-          const v = callback();
-          if (v instanceof Promise) {
-            await v;
-          }
-        } catch (e) {
-          console.error("Error in afterSave callback", e);
-          dispatch(setSaveState("idle"));
-          toast.show({
-            summary: "Erreur après sauvegarde",
-            detail: (e as any).toString(),
-            severity: "error",
-            life: 10000,
-          });
-        }
-      }
-    } catch (error: any) {
-      console.error("Error saving", error);
-      dispatch(setSaveState("idle"));
-      toast.show({
-        summary: "Erreur lors de l'enregistrement",
-        detail: error.toString(),
-        severity: "error",
-        life: 10000,
-      });
-    }
-  };
-
-  const saveState = useAppSelector(selectSaveState);
-  useEffect(() => {
-    if (saveState === "should-save") {
-      dispatch(setSaveState("saving"));
-      executePrepareSave();
-      save();
-    }
-  }, [saveState]);
-  return null;
-};
-
-export default Saver;
+import { FC, useEffect } from "react";
+import { useAppDispatch, useAppSelector } from "../../app/hooks";
+import {
+  selectSharedNotesContent,
+  selectComments,
+  selectGrading,
+  selectInstructions,
+  selectSaveState,
+  setIsMPDirty,
+  setIsPlayerDirty,
+  setSaveState,
+  setWorkflow,
+  selectSharedNotesType,
+  selectInstructionsType,
+} from "../activityData/activityDataSlice";
+import { useActivityJS } from "./ActivityJSProvider";
+import { selectBeforeSave, selectAfterSave } from "./saverSlice";
+import { useToast } from "../toast";
+
+const Saver: FC<{}> = () => {
+  const dispatch = useAppDispatch();
+  const activityJs = useActivityJS();
+  const instructions = useAppSelector(selectInstructions);
+  const instructionsType = useAppSelector(selectInstructionsType);
+  const sharedNotesContent = useAppSelector(selectSharedNotesContent);
+  const sharedNotesType = useAppSelector(selectSharedNotesType);
+  const comments = useAppSelector(selectComments);
+  const grading = useAppSelector(selectGrading);
+  const beforeSave = useAppSelector(selectBeforeSave);
+  const afterSave = useAppSelector(selectAfterSave);
+
+  const toast = useToast();
+
+  const executePrepareSave = () => {};
+  const save = async () => {
+    if (!activityJs.activitySession) {
+      throw new Error("No activity session to save");
+    }
+    for (const callback of Object.values(beforeSave)) {
+      try {
+        const v = callback();
+        if (v instanceof Promise) {
+          await v;
+        }
+      } catch (e) {
+        console.error("Error in beforeSave callback", e);
+        dispatch(setSaveState("idle"));
+        toast.show({
+          summary: "Erreur : enregistrement annulé",
+          detail: (e as any).toString(),
+          severity: "error",
+          life: 10000,
+        });
+        return;
+      }
+    }
+    const ab = activityJs.activitySession.activityBunch;
+    if (activityJs.activitySession.mode === "create") {
+      if (instructionsType === "rich") {
+        ab.instructions.value = {
+          lexical:
+            instructions?.format === "lexical"
+              ? typeof instructions.value === "string"
+                ? instructions.value
+                : JSON.stringify(instructions.value)
+              : null,
+          html:
+            instructions?.format === "lexical"
+              ? instructions.htmlValue
+              : (instructions?.value as string),
+        };
+      } else {
+        ab.instructions.value = {
+          lexical: null,
+          html: null,
+        };
+      }
+    }
+    if (activityJs.activitySession.mode === "review") {
+      ab.assignmentNode!.comments.value = comments || "";
+      ab.assignmentNode!.grading.value = grading || "";
+    }
+    if (
+      activityJs.activitySession.mode === "create" ||
+      activityJs.activitySession.mode === "review" ||
+      activityJs.activitySession.mode === "assignment"
+    ) {
+      if (sharedNotesContent && sharedNotesType === "rich") {
+        ab.shared_notes.value =
+          typeof sharedNotesContent === "string"
+            ? sharedNotesContent
+            : JSON.stringify(sharedNotesContent);
+      } else {
+        ab.shared_notes.value = null;
+      }
+    }
+    try {
+      await ab.save();
+      dispatch(setSaveState("idle"));
+      if (
+        activityJs.activitySession.mode === "assignment" ||
+        activityJs.activitySession.mode === "review"
+      ) {
+        dispatch(setWorkflow(ab.assignmentNode!.workflow));
+      }
+      dispatch(setIsPlayerDirty(false));
+      dispatch(setIsMPDirty(false));
+      toast.show({
+        summary: "Sauvegarde réussie",
+        detail: "L'activité a bien été enregistrée.",
+        severity: "success",
+        life: 2000,
+      });
+      for (const callback of Object.values(afterSave)) {
+        try {
+          const v = callback();
+          if (v instanceof Promise) {
+            await v;
+          }
+        } catch (e) {
+          console.error("Error in afterSave callback", e);
+          dispatch(setSaveState("idle"));
+          toast.show({
+            summary: "Erreur après sauvegarde",
+            detail: (e as any).toString(),
+            severity: "error",
+            life: 10000,
+          });
+        }
+      }
+    } catch (error: any) {
+      console.error("Error saving", error);
+      dispatch(setSaveState("idle"));
+      toast.show({
+        summary: "Erreur lors de l'enregistrement",
+        detail: error.toString(),
+        severity: "error",
+        life: 10000,
+      });
+    }
+  };
+
+  const saveState = useAppSelector(selectSaveState);
+  useEffect(() => {
+    if (saveState === "should-save") {
+      dispatch(setSaveState("saving"));
+      executePrepareSave();
+      save();
+    }
+  }, [saveState]);
+  return null;
+};
+
+export default Saver;

package/src/features/activityJS/hooks.ts

@@ -1,85 +1,85 @@
-import { useAppDispatch, useAppSelector } from "../../app/hooks";
-import {
-  selectCanReset,
-  selectMode,
-  selectWorkflow,
-  setSaveState,
-} from "../activityData/activityDataSlice";
-import { useActivityJS } from "./ActivityJSProvider";
-import { selectBeforeReset, selectAfterReset } from "./saverSlice";
-
-type UseResetProps = {
-  onError: (errorMessage: string) => void;
-};
-
-export const useReset = (props: UseResetProps) => {
-  const dispatch = useAppDispatch();
-  const canReset = useAppSelector(selectCanReset);
-  const beforeReset = useAppSelector(selectBeforeReset);
-  const afterReset = useAppSelector(selectAfterReset);
-  const activityJs = useActivityJS();
-  const mode = useAppSelector(selectMode);
-  const workflow = useAppSelector(selectWorkflow);
-  if (mode !== "assignment" || workflow !== "current") {
-    return null;
-  }
-  if (!canReset) {
-    return null;
-  }
-  return async (reload: boolean = true) => {
-    if (activityJs.state !== "loaded") {
-      throw new Error("No activity session to reset");
-    }
-    for (const callback of Object.values(beforeReset)) {
-      try {
-        const v = callback();
-        if (v instanceof Promise) {
-          await v;
-        }
-      } catch (e) {
-        console.error("Error in beforeReset callback", e);
-        props.onError((e as any).toString());
-        return;
-      }
-    }
-    dispatch(setSaveState("saving"));
-    try {
-      const ab = activityJs.activitySession.activityBunch;
-      if (!ab.assignmentNode) {
-        throw new Error("No assignment node");
-      }
-      if (ab.assignmentNode.content.value != null) {
-        ab.assignmentNode.content.value = null;
-      }
-      if (ab.assignmentNode.binaryData?.value != null) {
-        ab.assignmentNode.binaryData.value = null;
-      }
-      try {
-        await ab.save();
-
-        for (const callback of Object.values(afterReset)) {
-          try {
-            const v = callback();
-            if (v instanceof Promise) {
-              await v;
-            }
-          } catch (e) {
-            console.error("Error in afterReset callback", e);
-            props.onError((e as any).toString());
-          }
-        }
-        if (reload) {
-          location.reload();
-        }
-      } catch (e) {
-        console.error("Error in reset", e);
-        props.onError((e as any).toString());
-        return;
-      }
-    } catch (e) {
-      console.error("Error in reset process", e);
-      props.onError((e as any).toString());
-    }
-    dispatch(setSaveState("idle"));
-  };
-};
+import { useAppDispatch, useAppSelector } from "../../app/hooks";
+import {
+  selectCanReset,
+  selectMode,
+  selectWorkflow,
+  setSaveState,
+} from "../activityData/activityDataSlice";
+import { useActivityJS } from "./ActivityJSProvider";
+import { selectBeforeReset, selectAfterReset } from "./saverSlice";
+
+type UseResetProps = {
+  onError: (errorMessage: string) => void;
+};
+
+export const useReset = (props: UseResetProps) => {
+  const dispatch = useAppDispatch();
+  const canReset = useAppSelector(selectCanReset);
+  const beforeReset = useAppSelector(selectBeforeReset);
+  const afterReset = useAppSelector(selectAfterReset);
+  const activityJs = useActivityJS();
+  const mode = useAppSelector(selectMode);
+  const workflow = useAppSelector(selectWorkflow);
+  if (mode !== "assignment" || workflow !== "current") {
+    return null;
+  }
+  if (!canReset) {
+    return null;
+  }
+  return async (reload: boolean = true) => {
+    if (activityJs.state !== "loaded") {
+      throw new Error("No activity session to reset");
+    }
+    for (const callback of Object.values(beforeReset)) {
+      try {
+        const v = callback();
+        if (v instanceof Promise) {
+          await v;
+        }
+      } catch (e) {
+        console.error("Error in beforeReset callback", e);
+        props.onError((e as any).toString());
+        return;
+      }
+    }
+    dispatch(setSaveState("saving"));
+    try {
+      const ab = activityJs.activitySession.activityBunch;
+      if (!ab.assignmentNode) {
+        throw new Error("No assignment node");
+      }
+      if (ab.assignmentNode.content.value != null) {
+        ab.assignmentNode.content.value = null;
+      }
+      if (ab.assignmentNode.binaryData?.value != null) {
+        ab.assignmentNode.binaryData.value = null;
+      }
+      try {
+        await ab.save();
+
+        for (const callback of Object.values(afterReset)) {
+          try {
+            const v = callback();
+            if (v instanceof Promise) {
+              await v;
+            }
+          } catch (e) {
+            console.error("Error in afterReset callback", e);
+            props.onError((e as any).toString());
+          }
+        }
+        if (reload) {
+          location.reload();
+        }
+      } catch (e) {
+        console.error("Error in reset", e);
+        props.onError((e as any).toString());
+        return;
+      }
+    } catch (e) {
+      console.error("Error in reset process", e);
+      props.onError((e as any).toString());
+    }
+    dispatch(setSaveState("idle"));
+  };
+};