diff --git a/src/pages/gallery/index.tsx b/src/pages/gallery/index.tsx
index ecd0846db..6d4d6c063 100644
--- a/src/pages/gallery/index.tsx
+++ b/src/pages/gallery/index.tsx
@@ -334,10 +334,8 @@ export default function Gallery() {
             !silent && startLoading();
             const collections = await syncCollections();
             setCollections(collections);
-            let files = await syncFiles(collections, setFiles);
-            const trash = await syncTrash(collections, setFiles, files);
-            files = [...files, ...getTrashedFiles(trash)];
-            setFiles(sortFiles(files));
+            await syncFiles(collections, setFiles);
+            await syncTrash(collections, setFiles);
         } catch (e) {
             logError(e, 'syncWithRemote failed');
             switch (e.message) {
diff --git a/src/services/fileService.ts b/src/services/fileService.ts
index 724de75d0..6e2b02fbf 100644
--- a/src/services/fileService.ts
+++ b/src/services/fileService.ts
@@ -7,8 +7,8 @@ import HTTPService from './HTTPService';
 import { logError } from 'utils/sentry';
 import {
     decryptFile,
+    getLatestVersionFiles,
     mergeMetadata,
-    preservePhotoswipeProps,
     sortFiles,
 } from 'utils/file';
 import { EnteFile, EncryptedEnteFile, TrashRequest } from 'types/file';
@@ -54,12 +54,12 @@ const setLocalFiles = async (files: EnteFile[]) => {
 export const syncFiles = async (
     collections: Collection[],
     setFiles: SetFiles
-) => {
+): Promise<void> => {
     const localFiles = await getLocalFiles();
     let files = await removeDeletedCollectionFiles(collections, localFiles);
     if (files.length !== localFiles.length) {
         await setLocalFiles(files);
-        setFiles(preservePhotoswipeProps([...sortFiles(mergeMetadata(files))]));
+        setFiles(files);
     }
     for (const collection of collections) {
         if (!getToken()) {
@@ -72,38 +72,16 @@ export const syncFiles = async (
         if (collection.updationTime === lastSyncTime) {
             continue;
         }
-        const fetchedFiles =
-            (await getFiles(collection, lastSyncTime, files, setFiles)) ?? [];
-        files = [...files, ...fetchedFiles];
-        const latestVersionFiles = new Map<string, EnteFile>();
-        files.forEach((file) => {
-            const uid = `${file.collectionID}-${file.id}`;
-            if (
-                !latestVersionFiles.has(uid) ||
-                latestVersionFiles.get(uid).updationTime < file.updationTime
-            ) {
-                latestVersionFiles.set(uid, file);
-            }
-        });
-        files = [];
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        for (const [_, file] of latestVersionFiles) {
-            if (file.isDeleted) {
-                continue;
-            }
-            files.push(file);
-        }
+        const newFiles = await getFiles(collection, lastSyncTime, setFiles);
+        files = [...files, ...newFiles];
         await setLocalFiles(files);
         setCollectionLastSyncTime(collection, collection.updationTime);
-        setFiles(preservePhotoswipeProps([...sortFiles(mergeMetadata(files))]));
     }
-    return sortFiles(mergeMetadata(files));
 };
 
 export const getFiles = async (
     collection: Collection,
     sinceTime: number,
-    files: EnteFile[],
     setFiles: SetFiles
 ): Promise<EnteFile[]> => {
     try {
@@ -142,14 +120,13 @@ export const getFiles = async (
             if (resp.data.diff.length) {
                 time = resp.data.diff.slice(-1)[0].updationTime;
             }
-            setFiles(
-                preservePhotoswipeProps(
-                    sortFiles(
-                        mergeMetadata(
-                            [...(files || []), ...decryptedFiles].filter(
-                                (item) => !item.isDeleted
-                            )
-                        )
+            setFiles((files) =>
+                sortFiles(
+                    mergeMetadata(
+                        getLatestVersionFiles([
+                            ...(files || []),
+                            ...decryptedFiles,
+                        ]).filter((item) => !item.isDeleted)
                     )
                 )
             );
diff --git a/src/services/trashService.ts b/src/services/trashService.ts
index f33eb9e9a..eac997de1 100644
--- a/src/services/trashService.ts
+++ b/src/services/trashService.ts
@@ -2,16 +2,10 @@ import { SetFiles } from 'types/gallery';
 import { Collection } from 'types/collection';
 import { getEndpoint } from 'utils/common/apiUtil';
 import { getToken } from 'utils/common/key';
-import {
-    decryptFile,
-    mergeMetadata,
-    preservePhotoswipeProps,
-    sortFiles,
-} from 'utils/file';
+import { decryptFile, mergeMetadata, sortFiles } from 'utils/file';
 import { logError } from 'utils/sentry';
 import localForage from 'utils/storage/localForage';
 import { getCollection } from './collectionService';
-import { EnteFile } from 'types/file';
 
 import HTTPService from './HTTPService';
 import { EncryptedTrashItem, Trash } from 'types/trash';
@@ -55,16 +49,15 @@ async function getLastSyncTime() {
 }
 export async function syncTrash(
     collections: Collection[],
-    setFiles: SetFiles,
-    files: EnteFile[]
-): Promise<Trash> {
+    setFiles: SetFiles
+): Promise<void> {
     const trash = await getLocalTrash();
     collections = [...collections, ...(await getLocalDeletedCollections())];
     const collectionMap = new Map<number, Collection>(
         collections.map((collection) => [collection.id, collection])
     );
     if (!getToken()) {
-        return trash;
+        return;
     }
     const lastSyncTime = await getLastSyncTime();
 
@@ -72,18 +65,15 @@ export async function syncTrash(
         collectionMap,
         lastSyncTime,
         setFiles,
-        files,
         trash
     );
     cleanTrashCollections(updatedTrash);
-    return updatedTrash;
 }
 
 export const updateTrash = async (
     collections: Map<number, Collection>,
     sinceTime: number,
     setFiles: SetFiles,
-    files: EnteFile[],
     currentTrash: Trash
 ): Promise<Trash> => {
     try {
@@ -133,16 +123,8 @@ export const updateTrash = async (
                 time = resp.data.diff.slice(-1)[0].updatedAt;
             }
 
-            setFiles(
-                preservePhotoswipeProps(
-                    sortFiles([
-                        ...(files ?? []).map((file) => ({
-                            ...file,
-                            isTrashed: false,
-                        })),
-                        ...getTrashedFiles(updatedTrash),
-                    ])
-                )
+            setFiles((files) =>
+                sortFiles([...(files ?? []), ...getTrashedFiles(updatedTrash)])
             );
             await localForage.setItem(TRASH, updatedTrash);
             await localForage.setItem(TRASH_TIME, time);
diff --git a/src/utils/file/index.ts b/src/utils/file/index.ts
index 405a4b15c..5a94c5089 100644
--- a/src/utils/file/index.ts
+++ b/src/utils/file/index.ts
@@ -234,19 +234,6 @@ export async function decryptFile(
     }
 }
 
-export const preservePhotoswipeProps =
-    (newFiles: EnteFile[]) =>
-    (currentFiles: EnteFile[]): EnteFile[] => {
-        const currentFilesMap = Object.fromEntries(
-            currentFiles.map((file) => [file.id, file])
-        );
-        const fileWithPreservedProperty = newFiles.map((file) => {
-            const currentFile = currentFilesMap[file.id];
-            return { ...currentFile, ...file };
-        });
-        return fileWithPreservedProperty;
-    };
-
 export function fileNameWithoutExtension(filename: string) {
     const lastDotPosition = filename.lastIndexOf('.');
     if (lastDotPosition === -1) return filename;
@@ -567,3 +554,17 @@ export const copyFileToClipboard = async (fileUrl: string) => {
         .write([new ClipboardItem({ 'image/png': blobPromise })])
         .catch((e) => logError(e, 'failed to copy to clipboard'));
 };
+
+export function getLatestVersionFiles(files: EnteFile[]) {
+    const latestVersionFiles = new Map<string, EnteFile>();
+    files.forEach((file) => {
+        const uid = `${file.collectionID}-${file.id}`;
+        if (
+            !latestVersionFiles.has(uid) ||
+            latestVersionFiles.get(uid).updationTime < file.updationTime
+        ) {
+            latestVersionFiles.set(uid, file);
+        }
+    });
+    return Array.from(latestVersionFiles.values());
+}