fix dialog entry is not removed from store on remove

apps/mobile/src/provider/stores.ts

@@ -1,10 +1,10 @@
-import { Platform } from 'react-native';
-import { Dimensions } from 'react-native';
+import {Platform} from 'react-native';
+import {Dimensions} from 'react-native';
 import create from 'zustand';
 import PremiumService from '../services/PremiumService';
-import { history, SUBSCRIPTION_STATUS } from '../utils';
-import { db } from '../utils/database';
-import { MMKV } from '../utils/mmkv';
+import {history, SUBSCRIPTION_STATUS} from '../utils';
+import {db} from '../utils/database';
+import {MMKV} from '../utils/mmkv';
 import {
   MenuStore,
   MessageStore,
@@ -18,21 +18,20 @@ import {
   EditorStore,
   FavoriteStore,
   UserStore,
-  Announcement,
+  Announcement
 } from './interfaces';
-import { groupArray } from "notes-core/utils/grouping"
-import { EditorWebView, post } from '../views/Editor/Functions';
+import {groupArray} from 'notes-core/utils/grouping';
+import {EditorWebView, post} from '../views/Editor/Functions';
 import tiny from '../views/Editor/tiny/tiny';
 
 export const useNoteStore = create<NoteStore>((set, get) => ({
   notes: [],
   loading: true,
-  setLoading: loading => set({ loading: loading }),
+  setLoading: loading => set({loading: loading}),
   setNotes: items => {
     if (!items) {
-
       set({
-        notes: groupArray(db.notes.all, db.settings?.getGroupOptions("home")),
+        notes: groupArray(db.notes.all, db.settings?.getGroupOptions('home'))
       });
       return;
     }
@@ -44,9 +43,9 @@ export const useNoteStore = create<NoteStore>((set, get) => ({
         prev[index] = item;
       }
     }
-    set({ notes: prev });
+    set({notes: prev});
   },
-  clearNotes: () => set({ notes: [] }),
+  clearNotes: () => set({notes: []})
 }));
 
 export const useNotebookStore = create<NotebookStore>((set, get) => ({
@@ -54,7 +53,10 @@ export const useNotebookStore = create<NotebookStore>((set, get) => ({
   setNotebooks: items => {
     if (!items) {
       set({
-        notebooks: groupArray(db.notebooks.all, db.settings?.getGroupOptions("notebooks")),
+        notebooks: groupArray(
+          db.notebooks.all,
+          db.settings?.getGroupOptions('notebooks')
+        )
       });
       return;
     }
@@ -66,9 +68,9 @@ export const useNotebookStore = create<NotebookStore>((set, get) => ({
         prev[index] = item;
       }
     }
-    set({ notebooks: prev });
+    set({notebooks: prev});
   },
-  clearNotebooks: () => set({ notebooks: [] }),
+  clearNotebooks: () => set({notebooks: []})
 }));
 
 export const useFavoriteStore = create<FavoriteStore>((set, get) => ({
@@ -76,7 +78,10 @@ export const useFavoriteStore = create<FavoriteStore>((set, get) => ({
   setFavorites: items => {
     if (!items) {
       set({
-        favorites: groupArray(db.notes.favorites, db.settings?.getGroupOptions("favorites")),
+        favorites: groupArray(
+          db.notes.favorites,
+          db.settings?.getGroupOptions('favorites')
+        )
       });
       return;
     }
@@ -88,9 +93,9 @@ export const useFavoriteStore = create<FavoriteStore>((set, get) => ({
         prev[index] = item;
       }
     }
-    set({ favorites: prev });
+    set({favorites: prev});
   },
-  clearFavorites: () => set({ favorites: [] }),
+  clearFavorites: () => set({favorites: []})
 }));
 
 export const useTagStore = create<TagStore>((set, get) => ({
@@ -98,7 +103,7 @@ export const useTagStore = create<TagStore>((set, get) => ({
   setTags: items => {
     if (!items) {
       set({
-        tags: groupArray(db.tags.all, db.settings?.getGroupOptions("tags")),
+        tags: groupArray(db.tags.all, db.settings?.getGroupOptions('tags'))
       });
       return;
     }
@@ -110,9 +115,9 @@ export const useTagStore = create<TagStore>((set, get) => ({
         prev[index] = item;
       }
     }
-    set({ tags: prev });
+    set({tags: prev});
   },
-  clearTags: () => set({ tags: [] }),
+  clearTags: () => set({tags: []})
 }));
 
 export const useTrashStore = create<TrashStore>((set, get) => ({
@@ -120,7 +125,7 @@ export const useTrashStore = create<TrashStore>((set, get) => ({
   setTrash: items => {
     if (!items) {
       set({
-        trash: groupArray(db.trash.all, db.settings?.getGroupOptions("trash")),
+        trash: groupArray(db.trash.all, db.settings?.getGroupOptions('trash'))
       });
       return;
     }
@@ -132,9 +137,9 @@ export const useTrashStore = create<TrashStore>((set, get) => ({
         prev[index] = item;
       }
     }
-    set({ trash: prev });
+    set({trash: prev});
   },
-  clearTrash: () => set({ trash: [] }),
+  clearTrash: () => set({trash: []})
 }));
 
 export const useUserStore = create<UserStore>((set, get) => ({
@@ -143,65 +148,78 @@ export const useUserStore = create<UserStore>((set, get) => ({
   lastSynced: 'Never',
   syncing: false,
   verifyUser: false,
-  setUser: user => set({ user: user }),
-  setPremium: premium => set({ premium: premium }),
-  setSyncing: syncing => set({ syncing: syncing }),
-  setLastSynced: lastSynced => set({ lastSynced: lastSynced }),
-  setVerifyUser: (verified) => set({ verifyUser: verified })
+  setUser: user => set({user: user}),
+  setPremium: premium => set({premium: premium}),
+  setSyncing: syncing => set({syncing: syncing}),
+  setLastSynced: lastSynced => set({lastSynced: lastSynced}),
+  setVerifyUser: verified => set({verifyUser: verified})
 }));
 
 interface AttachmentStore {
   progress?: {
     [name: string]: {
-      sent: number,
-      total: number,
-      hash: string,
-      recieved: number,
-      type: "upload" | "download",
-    }
-  },
-  encryptionProgress: number,
-  setEncryptionProgress: (encryptionProgress) => void
-  remove: (hash: string) => void
-  setProgress: (sent: number, total: number, hash: string, recieved: number, type: "upload" | "download") => void,
-  loading:{total:number,current:number},
-  setLoading:(data:{total:number,current:number}) => void
+      sent: number;
+      total: number;
+      hash: string;
+      recieved: number;
+      type: 'upload' | 'download';
+    };
+  };
+  encryptionProgress: number;
+  setEncryptionProgress: (encryptionProgress) => void;
+  remove: (hash: string) => void;
+  setProgress: (
+    sent: number,
+    total: number,
+    hash: string,
+    recieved: number,
+    type: 'upload' | 'download'
+  ) => void;
+  loading: {total: number; current: number};
+  setLoading: (data: {total: number; current: number}) => void;
 }
 
 export const useAttachmentStore = create<AttachmentStore>((set, get) => ({
   progress: {},
-  remove: (hash) => {
+  remove: hash => {
     let _p = get().progress;
-    _p[hash] = null
-    tiny.call(EditorWebView, `
+    _p[hash] = null;
+    tiny.call(
+      EditorWebView,
+      `
     (function() {
       let progress = ${JSON.stringify({
-      loaded: 1,
-      total: 1,
-      hash
-    })}
+        loaded: 1,
+        total: 1,
+        hash
+      })}
     tinymce.activeEditor._updateAttachmentProgress(progress);
-    })()`);
-    set({ progress: { ..._p } });
+    })()`
+    );
+    set({progress: {..._p}});
   },
   setProgress: (sent, total, hash, recieved, type) => {
     let _p = get().progress;
-    _p[hash] = { sent, total, hash, recieved, type };
-    let progress = { total, hash, loaded: type === "download" ? recieved : sent };
-    tiny.call(EditorWebView, `
+    _p[hash] = {sent, total, hash, recieved, type};
+    let progress = {total, hash, loaded: type === 'download' ? recieved : sent};
+    tiny.call(
+      EditorWebView,
+      `
     (function() {
       let progress = ${JSON.stringify(progress)}
       tinymce.activeEditor._updateAttachmentProgress(progress);
-    })()`);
-    set({ progress: { ..._p } });
+    })()`
+    );
+    set({progress: {..._p}});
   },
   encryptionProgress: null,
-  setEncryptionProgress: (encryptionProgress) => set({ encryptionProgress: encryptionProgress }),
-  loading:{total:0,current:0},
-  setLoading:(data) => set({loading:data})
+  setEncryptionProgress: encryptionProgress =>
+    set({encryptionProgress: encryptionProgress}),
+  loading: {total: 0, current: 0},
+  setLoading: data => set({loading: data})
 }));
 
-let { width, height } = Dimensions.get('window');
+let {width, height} = Dimensions.get('window');
 
 export const useSettingStore = create<SettingStore>((set, get) => ({
   settings: {
@@ -219,23 +237,22 @@ export const useSettingStore = create<SettingStore>((set, get) => ({
     privacyScreen: false,
     appLockMode: 'none',
     telemetry: true,
-    notebooksListMode: "normal",
-    notesListMode: "normal",
+    notebooksListMode: 'normal',
+    notesListMode: 'normal',
     devMode: false,
-    notifNotes:false
+    notifNotes: false
   },
   fullscreen: false,
-  deviceMode: "mobile",
-  dimensions: { width, height },
+  deviceMode: 'mobile',
+  dimensions: {width, height},
   appLoading: true,
   isIntroCompleted: false,
-  setSettings: settings => set({ settings }),
-  setFullscreen: fullscreen => set({ fullscreen }),
-  setDeviceMode: mode => set({ deviceMode: mode }),
-  setDimensions: dimensions => set({ dimensions: dimensions }),
-  setAppLoading: (appLoading) => set({ appLoading }),
-  setIntroCompleted: (isIntroCompleted) => set({ isIntroCompleted })
-
+  setSettings: settings => set({settings}),
+  setFullscreen: fullscreen => set({fullscreen}),
+  setDeviceMode: mode => set({deviceMode: mode}),
+  setDimensions: dimensions => set({dimensions: dimensions}),
+  setAppLoading: appLoading => set({appLoading}),
+  setIntroCompleted: isIntroCompleted => set({isIntroCompleted})
 }));
 
 export const useMenuStore = create<MenuStore>((set, get) => ({
@@ -243,31 +260,30 @@ export const useMenuStore = create<MenuStore>((set, get) => ({
   colorNotes: [],
   setMenuPins: () => {
     try {
-      set({ menuPins: db.settings.pins })
+      set({menuPins: db.settings.pins});
     } catch (e) {
       setTimeout(() => {
         try {
-          set({ menuPins: db.settings.pins })
-        } catch (e) { }
-      }, 1000)
+          set({menuPins: db.settings.pins});
+        } catch (e) {}
+      }, 1000);
     }
   },
-  setColorNotes: () => set({ colorNotes: db.colors.all }),
-  clearAll: () => set({ menuPins: [], colorNotes: [] })
+  setColorNotes: () => set({colorNotes: db.colors.all}),
+  clearAll: () => set({menuPins: [], colorNotes: []})
 }));
 
 export const useEditorStore = create<EditorStore>((set, get) => ({
   currentEditingNote: null,
-  setCurrentlyEditingNote: note => set({ currentEditingNote: note }),
+  setCurrentlyEditingNote: note => set({currentEditingNote: note})
 }));
 
 export const useSearchStore = create<SearchStore>((set, get) => ({
   searchResults: [],
   searching: false,
   searchStatus: null,
-  setSearchResults: results => set({ searchResults: results }),
-  setSearchStatus: (searching, status) =>
-    set({ searching, searchStatus: status }),
+  setSearchResults: results => set({searchResults: results}),
+  setSearchStatus: (searching, status) => set({searching, searchStatus: status})
 }));
 
 export const useSelectionStore = create<SelectionStore>((set, get) => ({
@@ -275,14 +291,17 @@ export const useSelectionStore = create<SelectionStore>((set, get) => ({
   selectionMode: false,
   setAll: all => {
     history.selectedItemsList = all;
-    set({ selectedItemsList: all });
+    set({selectedItemsList: all});
   },
   setSelectionMode: mode => {
     if (!mode) {
       history.selectedItemsList = [];
       history.selectionMode = false;
     }
-    set({ selectionMode: mode, selectedItemsList: mode ? get().selectedItemsList : [] })
+    set({
+      selectionMode: mode,
+      selectedItemsList: mode ? get().selectedItemsList : []
+    });
   },
   setSelectedItem: item => {
     let selectedItems = get().selectedItemsList;
@@ -300,65 +319,72 @@ export const useSelectionStore = create<SelectionStore>((set, get) => ({
 
     set({
       selectedItemsList: selectedItems,
-      selectionMode: history.selectionMode,
+      selectionMode: history.selectionMode
     });
   },
   clearSelection: () => {
     history.selectedItemsList = [];
     history.selectionMode = false;
-    set({ selectionMode: false, selectedItemsList: [] });
-  },
+    set({selectionMode: false, selectedItemsList: []});
+  }
 }));
 
-
 export const useMessageStore = create<MessageStore>((set, get) => ({
   message: {
     visible: false,
     message: null,
     actionText: null,
-    onPress: () => { },
+    onPress: () => {},
     data: {},
-    icon: 'account-outline',
+    icon: 'account-outline'
   },
-  setMessage: message => set({ message: { ...message } }),
+  setMessage: message => set({message: {...message}}),
   announcements: [],
-  remove: async (id) => {
-    MMKV.setStringAsync(id, "removed");
-    let announcements = get().announcements;
-    const copy = announcements.slice();
-    const index = copy.findIndex((announcement) => announcement.id === id);
+  remove: async id => {
+    MMKV.setStringAsync(id, 'removed');
+
+    const inlineCopy = get().announcements.slice();
+    const dialogsCopy = get().dialogs.slice();
+    const index = inlineCopy.findIndex(announcement => announcement.id === id);
+    const dialogIndex = dialogsCopy.findIndex(dialog => dialog.id === id);
+
     if (index >= -1) {
-      copy.splice(index, 1);
+      dialogsCopy.splice(dialogIndex, 1);
+      inlineCopy.splice(index, 1);
     }
-    set({ announcements: copy });
+
+    set({announcements: inlineCopy, dialogs: dialogsCopy});
   },
-  dialogs:[],
+  dialogs: [],
   setAnnouncement: async function () {
     let announcements: Announcement[] = [];
     try {
-      announcements = await db.announcements()
+      announcements = await db.announcements();
       if (!announcements) {
         announcements = [];
       }
     } catch (e) {
-      set({ announcements: [] })
+      set({announcements: []});
     } finally {
       let all = await getFiltered(announcements);
-      set({ announcements: all.filter(a => a.type === "inline"),dialogs:all.filter(a => a.type === "dialog") })
+      set({
+        announcements: all.filter(a => a.type === 'inline'),
+        dialogs: all.filter(a => a.type === 'dialog')
+      });
     }
   }
 }));
 
-const getFiltered = async (announcements:Announcement[]) => {
+const getFiltered = async (announcements: Announcement[]) => {
   if (!announcements) return [];
-  let filtered:Announcement[] = [];
+  let filtered: Announcement[] = [];
   for (var announcement of announcements) {
     if (await shouldShowAnnouncement(announcement)) {
       filtered.push(announcement);
     }
   }
   return filtered;
-}
+};
 
 export function initialize() {
   if (!db) return;
@@ -384,23 +410,22 @@ export const allowedPlatforms = ['all', 'mobile', Platform.OS];
 
 async function shouldShowAnnouncement(announcement) {
   if (!announcement) return false;
-  let removed = await MMKV.getStringAsync(announcement.id) ===
-    "removed"
+  let removed = (await MMKV.getStringAsync(announcement.id)) === 'removed';
   if (removed) return false;
   let show = announcement.platforms.some(
-    (platform) => allowedPlatforms.indexOf(platform) > -1
+    platform => allowedPlatforms.indexOf(platform) > -1
   );
 
   if (!show) return false;
 
   const subStatus = PremiumService.getUser()?.subscription?.type;
-  show = announcement.userTypes.some((userType) => {
+  show = announcement.userTypes.some(userType => {
     switch (userType) {
-      case "pro":
-        return PremiumService.get()
-      case "trial":
+      case 'pro':
+        return PremiumService.get();
+      case 'trial':
         return subStatus === SUBSCRIPTION_STATUS.TRIAL;
-      case "trialExpired":
+      case 'trialExpired':
         return subStatus === SUBSCRIPTION_STATUS.BASIC;
       case 'loggedOut':
         show = !PremiumService.getUser();
@@ -419,7 +444,7 @@ async function shouldShowAnnouncement(announcement) {
           subStatus === SUBSCRIPTION_STATUS.PREMIUM_EXPIRED ||
           subStatus === SUBSCRIPTION_STATUS.PREMIUM_CANCELED;
         break;
-      case "any":
+      case 'any':
       default:
         return true;
     }