Feature/personal views optimization

packages/sdk/src/context/use-instances/reducer.ts

@@ -42,7 +42,7 @@ export function instanceReducer<T, R extends { id: string }>(
         ...state,
         instances: [
           ...state.instances.slice(0, action.index),
-          ...action.docs.map((doc) => factory(doc.data, doc)),
+          ...action.docs.filter((doc) => doc.data).map((doc) => factory(doc.data, doc)),
           ...state.instances.slice(action.index),
         ],
       };

packages/sdk/src/context/view/store/usePersonalViewStore.ts

@@ -4,18 +4,22 @@ import { LocalStorageKeys } from '../../../config';
 
 interface IPersonalViewState {
   personalViewMap: Record<string, Record<string, unknown>>;
+  personalViewMapBackup: Record<string, Record<string, unknown>>;
   isPersonalView: (viewId: string) => boolean;
   setPersonalViewMap: (
     viewId: string,
     updater: (prev: Record<string, unknown>) => Record<string, unknown>
   ) => void;
   removePersonalView: (viewId: string) => void;
+  backupPersonalView: (viewId: string) => void;
+  restorePersonalView: (viewId: string) => boolean;
 }
 
 export const usePersonalViewStore = create<IPersonalViewState>()(
   persist(
     (set, get) => ({
       personalViewMap: {},
+      personalViewMapBackup: {},
       isPersonalView: (viewId) => {
         const state = get();
         return Boolean(state.personalViewMap[viewId]);
@@ -32,6 +36,30 @@ export const usePersonalViewStore = create<IPersonalViewState>()(
           const { [viewId]: _, ...rest } = state.personalViewMap;
           return { personalViewMap: rest };
         }),
+      backupPersonalView: (viewId) =>
+        set((state) => {
+          const currentView = state.personalViewMap[viewId];
+          if (!currentView) return state;
+          return {
+            personalViewMapBackup: {
+              ...state.personalViewMapBackup,
+              [viewId]: { ...currentView },
+            },
+          };
+        }),
+      restorePersonalView: (viewId) => {
+        const state = get();
+        const backup = state.personalViewMapBackup[viewId];
+        if (!backup) return false;
+
+        set((state) => ({
+          personalViewMap: {
+            ...state.personalViewMap,
+            [viewId]: { ...backup },
+          },
+        }));
+        return true;
+      },
     }),
     {
       name: LocalStorageKeys.PersonalViewMap,

packages/sdk/src/hooks/use-personal-view.ts

@@ -8,19 +8,24 @@ import { useView } from './use-view';
 export const usePersonalView = () => {
   const { isPersonalView, personalViewMap, personalViewCommonQuery, personalViewAggregationQuery } =
     useContext(PersonalViewContext);
-  const { removePersonalView, setPersonalViewMap } = usePersonalViewStore();
+  const { removePersonalView, setPersonalViewMap, backupPersonalView, restorePersonalView } =
+    usePersonalViewStore();
 
   const view = useView();
   const viewId = view?.id ?? '';
 
   const closePersonalView = () => {
+    backupPersonalView(viewId);
     removePersonalView(viewId);
   };
 
   const openPersonalView = () => {
-    setPersonalViewMap(viewId, (prev) => {
-      return { ...prev, ...generatePersonalViewProps(view) };
-    });
+    const restored = restorePersonalView(viewId);
+    if (!restored) {
+      setPersonalViewMap(viewId, (prev) => {
+        return { ...prev, ...generatePersonalViewProps(view) };
+      });
+    }
   };
 
   const syncViewProperties = async () => {