@capytale/meta-player 0.8.2 → 0.8.3

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"));
+  };
+};

package/src/features/activityJS/internal-hooks.ts

@@ -1,96 +1,96 @@
-import { useEffect, useState, useRef } from "react";
-
-import { autoLoad } from "@capytale/activity.js";
-
-import type { ActivitySession } from "@capytale/activity.js/activity/activitySession/uni";
-
-import type { ActivityBunchOptions as LoadOptions } from "@capytale/activity.js/activity/activityBunch/uni/backend";
-
-export type { LoadOptions };
-
-export type ActivitySessionLoaderReturnValue = {
-  state: "initial";
-} | {
-  state: "loading";
-} | {
-  state: "loaded";
-  activitySession: ActivitySession;
-} | {
-  state: "error";
-  error: any;
-};
-
-/**
- * Un hook pour utiliser activity.js
- * Charge une activité de façon réactive.
- *
- * @param id id de l'activité à charger
- * @param loadOptions les options de chargement
- * @param callback une callback appelée avec l'activité chargée
- * @returns un objet contenant l'état de chargement de l'activité et l'activité dès qu'elle est chargée
- */
-
-export function useActivitySessionLoader(
-  id: number,
-  loadOptions?: LoadOptions,
-  callback?: (activitySession: ActivitySession) => void,
-): ActivitySessionLoaderReturnValue {
-  const callbackW = useHandlerWrapper(callback);
-  const [state, setState] = useState<ActivitySessionLoaderReturnValue>({
-    state: "loading",
-  });
-  useEffect(() => {
-    let cancelled = false;
-    autoLoad(loadOptions)
-      .then((data) => {
-        if (cancelled) return;
-        callbackW(data);
-        setState({
-          state: "loaded",
-          activitySession: data,
-        });
-        (window as any).capy = data;
-      })
-      .catch((error) => {
-        if (cancelled) return;
-        setState({
-          state: "error",
-          error,
-        });
-      });
-    return () => {
-      cancelled = true;
-      setState({
-        state: "loading",
-      });
-    };
-  }, [id, loadOptions?.binaryDataType, loadOptions?.readOnly]);
-  return state;
-}
-
-/**
- * Si un handler est passé en props à un composant, il peut changer. Il n'y a pas trop de raison mais
- * rien ne l'interdit.
- * Si un useEffect invoque ce handler, il faudrait que le handler figure dans les dépendances du useEffect.
- * Du coup, si le handler change, le useEffect est ré-exécuté.
- * Ce hook crée un wrapper immuable autour du handler passé en props. Ce wrapper ne change jamais et n'a donc
- * pas besoin de figurer dans les dépendances du useEffect.
- *
- * @param handler
- */
-export function useHandlerWrapper<H extends () => any>(
-  handler?: H,
-): () => ReturnType<H> | void;
-export function useHandlerWrapper<H extends (...args: any[]) => any>(
-  handler?: H,
-): (...p: Parameters<H>) => ReturnType<H> | void;
-export function useHandlerWrapper<H extends (...args: any[]) => any>(
-  handler?: H,
-): (...p: Parameters<H>) => ReturnType<H> | void {
-  const handlerRef = useRef<H>();
-  handlerRef.current = handler;
-  return useRef((...p: Parameters<H>) => {
-    if (null == handlerRef.current) return;
-    return handlerRef.current(...p);
-  }).current;
-}
+import { useEffect, useState, useRef } from "react";
+
+import { autoLoad } from "@capytale/activity.js";
+
+import type { ActivitySession } from "@capytale/activity.js/activity/activitySession/uni";
+
+import type { ActivityBunchOptions as LoadOptions } from "@capytale/activity.js/activity/activityBunch/uni/backend";
+
+export type { LoadOptions };
+
+export type ActivitySessionLoaderReturnValue = {
+  state: "initial";
+} | {
+  state: "loading";
+} | {
+  state: "loaded";
+  activitySession: ActivitySession;
+} | {
+  state: "error";
+  error: any;
+};
+
+/**
+ * Un hook pour utiliser activity.js
+ * Charge une activité de façon réactive.
+ *
+ * @param id id de l'activité à charger
+ * @param loadOptions les options de chargement
+ * @param callback une callback appelée avec l'activité chargée
+ * @returns un objet contenant l'état de chargement de l'activité et l'activité dès qu'elle est chargée
+ */
+
+export function useActivitySessionLoader(
+  id: number,
+  loadOptions?: LoadOptions,
+  callback?: (activitySession: ActivitySession) => void,
+): ActivitySessionLoaderReturnValue {
+  const callbackW = useHandlerWrapper(callback);
+  const [state, setState] = useState<ActivitySessionLoaderReturnValue>({
+    state: "loading",
+  });
+  useEffect(() => {
+    let cancelled = false;
+    autoLoad(loadOptions)
+      .then((data) => {
+        if (cancelled) return;
+        callbackW(data);
+        setState({
+          state: "loaded",
+          activitySession: data,
+        });
+        (window as any).capy = data;
+      })
+      .catch((error) => {
+        if (cancelled) return;
+        setState({
+          state: "error",
+          error,
+        });
+      });
+    return () => {
+      cancelled = true;
+      setState({
+        state: "loading",
+      });
+    };
+  }, [id, loadOptions?.binaryDataType, loadOptions?.readOnly]);
+  return state;
+}
+
+/**
+ * Si un handler est passé en props à un composant, il peut changer. Il n'y a pas trop de raison mais
+ * rien ne l'interdit.
+ * Si un useEffect invoque ce handler, il faudrait que le handler figure dans les dépendances du useEffect.
+ * Du coup, si le handler change, le useEffect est ré-exécuté.
+ * Ce hook crée un wrapper immuable autour du handler passé en props. Ce wrapper ne change jamais et n'a donc
+ * pas besoin de figurer dans les dépendances du useEffect.
+ *
+ * @param handler
+ */
+export function useHandlerWrapper<H extends () => any>(
+  handler?: H,
+): () => ReturnType<H> | void;
+export function useHandlerWrapper<H extends (...args: any[]) => any>(
+  handler?: H,
+): (...p: Parameters<H>) => ReturnType<H> | void;
+export function useHandlerWrapper<H extends (...args: any[]) => any>(
+  handler?: H,
+): (...p: Parameters<H>) => ReturnType<H> | void {
+  const handlerRef = useRef<H>();
+  handlerRef.current = handler;
+  return useRef((...p: Parameters<H>) => {
+    if (null == handlerRef.current) return;
+    return handlerRef.current(...p);
+  }).current;
+}

package/src/features/activityJS/saverSlice.ts

@@ -1,96 +1,96 @@
-import type { PayloadAction } from "@reduxjs/toolkit";
-import { createAppSlice } from "../../app/createAppSlice";
-
-type CallbackType = () => void | Promise<void>;
-
-export type SaveCallback = {
-  name: string;
-  callback: CallbackType;
-};
-
-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`.
-export const saverSlice = createAppSlice({
-  name: "saver",
-  // `createSlice` will infer the state type from the `initialState` argument
-  initialState,
-  // The `reducers` field lets us define reducers and generate associated actions
-  reducers: (create) => ({
-    // Use the `PayloadAction` type to declare the contents of `action.payload`
-    addBeforeSave: create.reducer(
-      (state, action: PayloadAction<SaveCallback>) => {
-        state.beforeSave[action.payload.name] = action.payload.callback;
-      },
-    ),
-    addAfterSave: create.reducer(
-      (state, action: PayloadAction<SaveCallback>) => {
-        state.afterSave[action.payload.name] = action.payload.callback;
-      },
-    ),
-    addBeforeReset: create.reducer(
-      (state, action: PayloadAction<SaveCallback>) => {
-        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];
-    }),
-    removeAfterSave: create.reducer((state, action: PayloadAction<string>) => {
-      delete state.afterSave[action.payload];
-    }),
-    removeBeforeReset: create.reducer(
-      (state, action: PayloadAction<string>) => {
-        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.
-  selectors: {
-    selectBeforeSave: (saver) => saver.beforeSave,
-    selectAfterSave: (saver) => saver.afterSave,
-    selectBeforeReset: (saver) => saver.beforeReset,
-    selectAfterReset: (saver) => saver.afterReset,
-  },
-});
-
-// Action creators are generated for each case reducer function.
-export const {
-  addBeforeSave,
-  removeBeforeSave,
-  addAfterSave,
-  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,
-  selectAfterReset,
-} = saverSlice.selectors;
+import type { PayloadAction } from "@reduxjs/toolkit";
+import { createAppSlice } from "../../app/createAppSlice";
+
+type CallbackType = () => void | Promise<void>;
+
+export type SaveCallback = {
+  name: string;
+  callback: CallbackType;
+};
+
+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`.
+export const saverSlice = createAppSlice({
+  name: "saver",
+  // `createSlice` will infer the state type from the `initialState` argument
+  initialState,
+  // The `reducers` field lets us define reducers and generate associated actions
+  reducers: (create) => ({
+    // Use the `PayloadAction` type to declare the contents of `action.payload`
+    addBeforeSave: create.reducer(
+      (state, action: PayloadAction<SaveCallback>) => {
+        state.beforeSave[action.payload.name] = action.payload.callback;
+      },
+    ),
+    addAfterSave: create.reducer(
+      (state, action: PayloadAction<SaveCallback>) => {
+        state.afterSave[action.payload.name] = action.payload.callback;
+      },
+    ),
+    addBeforeReset: create.reducer(
+      (state, action: PayloadAction<SaveCallback>) => {
+        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];
+    }),
+    removeAfterSave: create.reducer((state, action: PayloadAction<string>) => {
+      delete state.afterSave[action.payload];
+    }),
+    removeBeforeReset: create.reducer(
+      (state, action: PayloadAction<string>) => {
+        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.
+  selectors: {
+    selectBeforeSave: (saver) => saver.beforeSave,
+    selectAfterSave: (saver) => saver.afterSave,
+    selectBeforeReset: (saver) => saver.beforeReset,
+    selectAfterReset: (saver) => saver.afterReset,
+  },
+});
+
+// Action creators are generated for each case reducer function.
+export const {
+  addBeforeSave,
+  removeBeforeSave,
+  addAfterSave,
+  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,
+  selectAfterReset,
+} = saverSlice.selectors;

package/src/features/activitySettings/ActivitySettingsSetter.tsx

@@ -1,21 +1,21 @@
-import { FC, useEffect } from "react";
-import { ActivitySettings } from "./types";
-import { useRegisterActivitySettings } from "./hooks";
-
-type ActivitySettingsSetterProps = {
-  settings: ActivitySettings;
-  callback?: (name: string, value: any) => void;
-};
-
-const ActivitySettingsSetter: FC<ActivitySettingsSetterProps> = ({
-  settings,
-  callback,
-}) => {
-  const registerActivitySettings = useRegisterActivitySettings();
-  useEffect(() => {
-    registerActivitySettings(settings, callback);
-  }, [settings, callback, registerActivitySettings]);
-  return null;
-};
-
-export default ActivitySettingsSetter;
+import { FC, useEffect } from "react";
+import { ActivitySettings } from "./types";
+import { useRegisterActivitySettings } from "./hooks";
+
+type ActivitySettingsSetterProps = {
+  settings: ActivitySettings;
+  callback?: (name: string, value: any) => void;
+};
+
+const ActivitySettingsSetter: FC<ActivitySettingsSetterProps> = ({
+  settings,
+  callback,
+}) => {
+  const registerActivitySettings = useRegisterActivitySettings();
+  useEffect(() => {
+    registerActivitySettings(settings, callback);
+  }, [settings, callback, registerActivitySettings]);
+  return null;
+};
+
+export default ActivitySettingsSetter;

package/src/features/activitySettings/hooks.ts

@@ -1,12 +1,12 @@
-import { useActivitySettingsStore } from "./store";
-import type { ActivitySettings } from "./types";
-
-export const useRegisterActivitySettings = () => {
-  const setSettings = useActivitySettingsStore((state) => state.setSettings);
-  return (
-    settings: ActivitySettings,
-    onChange?: (name: string, value: any) => void,
-  ) => {
-    setSettings(settings, onChange || null);
-  };
-};
+import { useActivitySettingsStore } from "./store";
+import type { ActivitySettings } from "./types";
+
+export const useRegisterActivitySettings = () => {
+  const setSettings = useActivitySettingsStore((state) => state.setSettings);
+  return (
+    settings: ActivitySettings,
+    onChange?: (name: string, value: any) => void,
+  ) => {
+    setSettings(settings, onChange || null);
+  };
+};