@capytale/meta-player 0.3.9 → 0.3.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capytale/meta-player",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "type": "module",
   "scripts": {
     "dev": "vite",

package/src/features/activityJS/AfterResetAction.tsx

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

package/src/features/activityJS/hooks.ts

@@ -5,7 +5,7 @@ import {
   setSaveState,
 } from "../activityData/activityDataSlice";
 import { useActivityJS } from "./ActivityJSProvider";
-import { selectBeforeReset } from "./saverSlice";
+import { selectBeforeReset, selectAfterReset } from "./saverSlice";
 
 type UseResetProps = {
   onError: (errorMessage: string) => void;
@@ -14,13 +14,14 @@ type UseResetProps = {
 export const useReset = (props: UseResetProps) => {
   const dispatch = useAppDispatch();
   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;
   }
-  return async () => {
+  return async (reload: boolean = true) => {
     if (!activityJs.activitySession) {
       throw new Error("No activity session to reset");
     }
@@ -36,26 +37,46 @@ export const useReset = (props: UseResetProps) => {
         return;
       }
     }
+    dispatch(setSaveState("saving"));
     try {
-      dispatch(setSaveState("saving"));
       const ab = activityJs.activitySession.activityBunch;
       // @ts-expect-error
-      ab.assignmentNode.content.value = null;
+      if (ab.assignmentNode!.content.value != null) {
+        // @ts-expect-error
+        ab.assignmentNode.content.value = null;
+      }
       // @ts-expect-error
-      ab.assignmentNode.binaryData.value = null;
+      if (ab.assignmentNode!.binaryData?.value != null) {
+        // @ts-expect-error
+        ab.assignmentNode.binaryData.value = null;
+      }
       try {
         const saveData = await ab.save();
         console.log("Save return data", saveData);
-        location.reload();
+
+        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;
       }
-      dispatch(setSaveState("idle"));
     } catch (e) {
       console.error("Error in reset process", e);
       props.onError((e as any).toString());
     }
+    dispatch(setSaveState("idle"));
   };
 };

package/src/features/activityJS/saverSlice.ts

@@ -12,12 +12,14 @@ export interface SaverState {
   beforeSave: { [key: string]: CallbackType };
   afterSave: { [key: string]: CallbackType };
   beforeReset: { [key: string]: CallbackType };
+  afterReset: { [key: string]: CallbackType };
 }
 
 const initialState: SaverState = {
   beforeSave: {},
   afterSave: {},
   beforeReset: {},
+  afterReset: {},
 };
 
 // If you are not using async thunks you can use the standalone `createSlice`.
@@ -43,6 +45,11 @@ export const saverSlice = createAppSlice({
         state.beforeReset[action.payload.name] = action.payload.callback;
       },
     ),
+    addAfterReset: create.reducer(
+      (state, action: PayloadAction<SaveCallback>) => {
+        state.afterReset[action.payload.name] = action.payload.callback;
+      },
+    ),
     removeBeforeSave: create.reducer((state, action: PayloadAction<string>) => {
       delete state.beforeSave[action.payload];
     }),
@@ -54,6 +61,9 @@ export const saverSlice = createAppSlice({
         delete state.beforeReset[action.payload];
       },
     ),
+    removeAfterReset: create.reducer((state, action: PayloadAction<string>) => {
+      delete state.afterReset[action.payload];
+    }),
   }),
   // You can define your selectors here. These selectors receive the slice
   // state as their first argument.
@@ -61,6 +71,7 @@ export const saverSlice = createAppSlice({
     selectBeforeSave: (saver) => saver.beforeSave,
     selectAfterSave: (saver) => saver.afterSave,
     selectBeforeReset: (saver) => saver.beforeReset,
+    selectAfterReset: (saver) => saver.afterReset,
   },
 });
 
@@ -72,8 +83,14 @@ export const {
   removeAfterSave,
   addBeforeReset,
   removeBeforeReset,
+  addAfterReset,
+  removeAfterReset,
 } = saverSlice.actions;
 
 // Selectors returned by `slice.selectors` take the root state as their first argument.
-export const { selectBeforeSave, selectAfterSave, selectBeforeReset } =
-  saverSlice.selectors;
+export const {
+  selectBeforeSave,
+  selectAfterSave,
+  selectBeforeReset,
+  selectAfterReset,
+} = saverSlice.selectors;

package/src/index.tsx

@@ -6,6 +6,7 @@ import MetaPlayerOptionsSetter from "./features/activityData/MetaPlayerOptionsSe
 import BeforeSaveAction from "./features/activityJS/BeforeSaveAction";
 import BeforeResetAction from "./features/activityJS/BeforeResetAction";
 import AfterSaveAction from "./features/activityJS/AfterSaveAction";
+import AfterResetAction from "./features/activityJS/AfterResetAction";
 import { useMode, useWorkflow } from "./hooks";
 import {
   useActivityJS,
@@ -26,6 +27,7 @@ export {
   BeforeSaveAction,
   BeforeResetAction,
   AfterSaveAction,
+  AfterResetAction,
   useMode,
   useWorkflow,
   useActivityJS,