remove all sync stuff

build-release.sh

···
 #!/bin/bash
 
-VERSION=0.2.5
+VERSION=0.2.6
 
 # Linux builds
 NO_STRIP=true pnpm tauri build

changelog

···
 v0.2.6:
   - Fixed photos not being loaded if they're too low resolution
   - Added close to tray toggle
-  - Fixed "Open in folder" not selecting files on linux
+  - Fixed "Open in folder" not selecting files on linux
+  - Remove all sync stuff

src-tauri/src/frontend_calls/mod.rs

···
 pub mod open_folder;
 pub mod open_url;
 pub mod start_with_win;
-pub mod sync_photos;
 pub mod copy_image;

src-tauri/src/frontend_calls/sync_photos.rs

···
-use crate::photosync;
-use crate::util::get_photo_path::get_photo_path;
-use std::thread;
-
-// On requested sync the photos to the cloud
-#[tauri::command]
-pub fn sync_photos(token: String, window: tauri::Window) {
-  thread::spawn(move || {
-    photosync::sync_photos(token, get_photo_path(), window);
-  });
-}

src-tauri/src/main.rs

···
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
 mod frontend_calls;
-mod photosync;
 mod pngmeta;
 mod util;
 mod worldscraper;
···
 use tauri_plugin_deep_link::DeepLinkExt;
 
 use crate::frontend_calls::config::get_config_value_string;
-
-// TODO: Linux support
 
 fn main() {
   #[cfg(target_os = "linux")]
···
       start_with_win::start_with_win,
       get_user_photos_path::get_user_photos_path,
       change_final_path::change_final_path,
-      sync_photos::sync_photos,
       util::get_version::get_version,
       config::set_config_value_string,
       config::get_config_value_string,

src-tauri/src/photosync.rs

···
-use regex::Regex;
-use reqwest;
-use serde::Serialize;
-use serde_json::{Error, Value};
-use std::{fs, io::Write, path, time::Duration};
-use tauri::Emitter;
-
-#[derive(Clone, Serialize)]
-struct PhotoUploadMeta {
-  photos_uploading: usize,
-  photos_total: usize,
-}
-
-pub fn sync_photos(token: String, path: path::PathBuf, window: tauri::Window) {
-  let sync_lock_path = dirs::config_dir()
-    .unwrap()
-    .join("PhazeDev/VRChatPhotoManager/.sync_lock");
-
-  match fs::metadata(&sync_lock_path) {
-    Ok(_) => {
-      return;
-    }
-    Err(_) => {}
-  }
-
-  fs::write(&sync_lock_path, "Currently Syncing").unwrap();
-
-  match fs::metadata(&path) {
-    Ok(_) => {}
-    Err(_) => {
-      fs::create_dir(&path).unwrap();
-    }
-  };
-
-  let mut photos: Vec<String> = Vec::new();
-
-  for folder in fs::read_dir(&path).unwrap() {
-    let f = folder.unwrap();
-
-    if f.metadata().unwrap().is_dir() {
-      match fs::read_dir(f.path()) {
-        Ok(dir) => {
-          for photo in dir {
-            let p = photo.unwrap();
-
-            let re1 = Regex::new(r"(?m)VRChat_[0-9]{4}-[0-9]{2}-[0-9]{2}_[0-9]{2}-[0-9]{2}-[0-9]{2}.[0-9]{3}_[0-9]{4}x[0-9]{4}.png").unwrap();
-            let re2 = Regex::new(
-  r"(?m)VRChat_[0-9]{4}-[0-9]{2}-[0-9]{2}_[0-9]{2}-[0-9]{2}-[0-9]{2}.[0-9]{3}_[0-9]{4}x[0-9]{4}_wrld_[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}.png").unwrap();
-
-            if re1.is_match(p.file_name().to_str().unwrap())
-              || re2.is_match(p.file_name().to_str().unwrap())
-            {
-              photos.push(p.file_name().into_string().unwrap());
-            }
-          }
-        }
-        Err(_) => {}
-      }
-    }
-  }
-
-  let body = reqwest::blocking::get(format!(
-    "https://photos-cdn.phazed.xyz/api/v1/photos/exists?token={}",
-    &token
-  ))
-  .unwrap()
-  .text()
-  .unwrap();
-
-  let body: Value = serde_json::from_str(&body).unwrap();
-
-  let mut photos_to_upload: Vec<String> = Vec::new();
-  let uploaded_photos = body["files"].as_array().unwrap();
-
-  let photos_len = photos.len();
-
-  for photo in &photos {
-    let mut found_photo = false;
-
-    for uploaded_photo in uploaded_photos {
-      if photo == uploaded_photo.as_str().unwrap() {
-        found_photo = true;
-        break;
-      }
-    }
-
-    if !found_photo {
-      photos_to_upload.push(photo.clone());
-    }
-  }
-
-  window
-    .emit(
-      "photos-upload-meta",
-      PhotoUploadMeta {
-        photos_uploading: photos_to_upload.len(),
-        photos_total: photos_len,
-      },
-    )
-    .unwrap();
-
-  let mut photos_left = photos_to_upload.len();
-
-  let client = reqwest::blocking::Client::new();
-
-  loop {
-    match photos_to_upload.pop() {
-      Some(photo) => {
-        let folder_name = photo.clone().replace("VRChat_", "");
-        let mut folder_name = folder_name.split("-");
-        let folder_name = format!(
-          "{}-{}",
-          folder_name.nth(0).unwrap(),
-          folder_name.nth(0).unwrap()
-        );
-
-        let full_path = format!("{}\\{}\\{}", path.to_str().unwrap(), folder_name, photo);
-        let file = fs::File::open(full_path);
-
-        match file {
-          Ok(file) => {
-            let res = client
-              .put(format!(
-                "https://photos-cdn.phazed.xyz/api/v1/photos?token={}",
-                &token
-              ))
-              .header("Content-Type", "image/png")
-              .header("filename", photo)
-              .body(file)
-              .timeout(Duration::from_secs(120))
-              .send()
-              .unwrap()
-              .text()
-              .unwrap();
-
-            let res: Result<Value, Error> = serde_json::from_str(&res);
-
-            match res {
-              Ok(res) => {
-                if !res["ok"].as_bool().unwrap() {
-                  println!("Failed to upload: {}", res["error"].as_str().unwrap());
-
-                  window
-                    .emit("sync-failed", res["error"].as_str().unwrap())
-                    .unwrap();
-
-                  break;
-                }
-              }
-              Err(err) => {
-                dbg!(err);
-              }
-            }
-          }
-          Err(_) => {}
-        }
-
-        photos_left -= 1;
-        window
-          .emit(
-            "photos-upload-meta",
-            PhotoUploadMeta {
-              photos_uploading: photos_left,
-              photos_total: photos_len,
-            },
-          )
-          .unwrap();
-      }
-      None => {
-        break;
-      }
-    }
-  }
-
-  println!("Finished Uploading.");
-  let mut photos_to_download: Vec<String> = Vec::new();
-
-  for photo in uploaded_photos {
-    let mut found_photo = false;
-    let photo = photo.as_str().unwrap().to_string();
-
-    for uploaded_photo in &photos {
-      if &photo == uploaded_photo {
-        found_photo = true;
-        break;
-      }
-    }
-
-    if !found_photo {
-      photos_to_download.push(photo);
-    }
-  }
-
-  photos_to_download.reverse();
-
-  let photos_len = photos_to_download.len();
-  let mut photos_left = photos_to_download.len();
-
-  loop {
-    match photos_to_download.pop() {
-      Some(photo) => {
-        let folder_name = photo.clone().replace("VRChat_", "");
-        let mut folder_name = folder_name.split("-");
-        let folder_name = format!(
-          "{}-{}",
-          folder_name.nth(0).unwrap(),
-          folder_name.nth(0).unwrap()
-        );
-
-        let full_path = format!("{}/{}/{}", path.to_str().unwrap(), folder_name, photo);
-
-        let res = client
-          .get(format!(
-            "https://photos-cdn.phazed.xyz/api/v1/photos?token={}&photo={}",
-            &token, &photo
-          ))
-          .timeout(Duration::from_secs(120))
-          .send()
-          .unwrap()
-          .bytes();
-
-        match res {
-          Ok(res) => {
-            let folder_path = format!("{}/{}", path.to_str().unwrap(), folder_name);
-            match fs::metadata(&folder_path) {
-              Ok(_) => {}
-              Err(_) => {
-                fs::create_dir(folder_path).unwrap();
-              }
-            }
-
-            let mut file = fs::File::create(full_path).unwrap();
-            file.write_all(&res).unwrap();
-          }
-          Err(err) => {
-            dbg!(err);
-          }
-        }
-
-        photos_left -= 1;
-        window
-          .emit(
-            "photos-download-meta",
-            PhotoUploadMeta {
-              photos_uploading: photos_left,
-              photos_total: photos_len,
-            },
-          )
-          .unwrap();
-      }
-      None => {
-        break;
-      }
-    }
-  }
-
-  println!("Finished Downloading.");
-
-  fs::remove_file(&sync_lock_path).unwrap();
-  window.emit("sync-finished", "h").unwrap();
-}

src-tauri/src/util/handle_uri_proto.rs

···
       return;
     }
 
-    // TODO: Only accept files that are in the vrchat photos folder
-    // Slightly more complex than originally thought, need to find a way to cache the VRC photos path
-    // since i need to be able to load lots of photos very quickly. This shouldn't be a security issue
-    // because tauri should only let the frontend of VRCPhotoManager read files throught this. Only
-    // becomes a potential issue if the frontend gets modified or there's an issue with tauri.
-
     #[cfg(windows)]
     let path = uri.path().split_at(1).1;
 

src/Components/Managers/SyncManager.tsx

···
-import { invoke } from "@tauri-apps/api/core";
-import { listen } from "@tauri-apps/api/event";
-import { Accessor, createSignal, Setter } from "solid-js";
-
-export class SyncManager{
-  private _setIsSyncing: Setter<boolean>;
-  private _setSyncPhotoTotal: Setter<number>;
-  private _setSyncPhotoTransfers: Setter<number>;
-  private _setSyncType: Setter<string>;
-  private _setSyncError: Setter<string>;
-
-  public IsSyncing: Accessor<boolean>;
-  public SyncPhotoTotal: Accessor<number>;
-  public SyncPhotoTransfers: Accessor<number>
-  public SyncType: Accessor<string>;
-  public SyncError: Accessor<string>;
-
-  constructor(){
-    [ this.IsSyncing, this._setIsSyncing ] = createSignal(false);
-    [ this.SyncPhotoTotal, this._setSyncPhotoTotal ] = createSignal(-1);
-    [ this.SyncPhotoTransfers, this._setSyncPhotoTransfers ] = createSignal(-1);
-    [ this.SyncType, this._setSyncType ] = createSignal("");
-    [ this.SyncError, this._setSyncError ] = createSignal("");
-
-    listen('photos-upload-meta', ( e: any ) => {
-      this._setIsSyncing(true);
-      this._setSyncPhotoTotal(e.payload.photos_total);
-      this._setSyncPhotoTransfers(e.payload.photos_total - e.payload.photos_uploading);
-      this._setSyncType('Upload');
-  
-      console.log(e.payload)
-    })
-  
-    listen('photos-download-meta', ( e: any ) => {
-      this._setIsSyncing(true);
-      this._setSyncPhotoTotal(e.payload.photos_total);
-      this._setSyncPhotoTransfers(e.payload.photos_total - e.payload.photos_uploading);
-      this._setSyncType('Download');
-  
-      console.log(e.payload)
-    })
-  
-    listen('sync-finished', () => {
-      this._setIsSyncing(false);
-    })
-
-    listen('sync-failed', ( e: any ) => {
-      this._setSyncError(e.payload);
-    })
-  }
-
-  public async TriggerSync(){
-    this._setIsSyncing(true);
-    invoke('sync_photos', { token: (await invoke('get_config_value_string', { key: 'token' })) });
-  }
-}

src/Components/SettingsMenu.tsx

···
 import { animate, utils } from "animejs";
 
 let SettingsMenu = () => {
-  let sliderBar: HTMLElement;
+  // let sliderBar: HTMLElement;
   let settingsContainer: HTMLElement;
-  let currentButton = 0;
-  let lastClickedButton = -1;
+  // let currentButton = 0;
+  // let lastClickedButton = -1;
   let finalPathConfirm: HTMLElement;
   let finalPathInput: HTMLElement;
   let finalPathData: string;
···
       animate('.settings', { background: 'rgba(0, 0, 0, 0)', easing: 'linear', duration: 100 });
     }
 
-    let sliderMouseDown = false;
-    let mouseStartX = 0;
+    // let sliderMouseDown = false;
+    // let mouseStartX = 0;
 
-    let width = window.innerWidth;
-    let buttons = [ 370, 680 ];
+    // let width = window.innerWidth;
+    // let buttons = [ 370, 680 ];
 
-    let sliderPos = width / 2 - buttons[currentButton];
-    let sliderScale = width / (buttons[1] - buttons[0]);
+    // let sliderPos = width / 2 - buttons[currentButton];
+    // let sliderScale = width / (buttons[1] - buttons[0]);
 
-    let render = () => {
-      requestAnimationFrame(render);
+    // let render = () => {
+    //   requestAnimationFrame(render);
 
-      if(!sliderMouseDown){
-        sliderPos = sliderPos + (width / 2 - buttons[currentButton] - sliderPos) * 0.25;
-        utils.set(sliderBar, { translateX: sliderPos });
+    //   if(!sliderMouseDown){
+    //     sliderPos = sliderPos + (width / 2 - buttons[currentButton] - sliderPos) * 0.25;
+    //     utils.set(sliderBar, { translateX: sliderPos });
 
-        settingsContainer.style.left = (sliderPos - (width / 2 - buttons[0])) * sliderScale + 'px';
-      }
-    }
+    //     settingsContainer.style.left = (sliderPos - (width / 2 - buttons[0])) * sliderScale + 'px';
+    //   }
+    // }
 
-    render();
-    utils.set(sliderBar, { translateX: sliderPos });
+    // render();
+    // utils.set(sliderBar, { translateX: sliderPos });
 
-    sliderBar.addEventListener('touchstart', ( e: TouchEvent ) => {
-      sliderMouseDown = true;
-      mouseStartX = e.touches[0].clientX;
-    })
+    // sliderBar.addEventListener('touchstart', ( e: TouchEvent ) => {
+    //   sliderMouseDown = true;
+    //   mouseStartX = e.touches[0].clientX;
+    // })
 
-    window.addEventListener('touchmove', ( e: TouchEvent ) => {
-      if(sliderMouseDown){
-        utils.set(sliderBar, { translateX: sliderPos - (mouseStartX - e.touches[0].clientX) });
-        settingsContainer.style.left = (sliderPos - (mouseStartX - e.touches[0].clientX) - (width / 2 - buttons[0])) * sliderScale + 'px';
-      }
-    })
+    // window.addEventListener('touchmove', ( e: TouchEvent ) => {
+    //   if(sliderMouseDown){
+    //     utils.set(sliderBar, { translateX: sliderPos - (mouseStartX - e.touches[0].clientX) });
+    //     settingsContainer.style.left = (sliderPos - (mouseStartX - e.touches[0].clientX) - (width / 2 - buttons[0])) * sliderScale + 'px';
+    //   }
+    // })
 
-    window.addEventListener('keyup', closeWithKey);
+    // window.addEventListener('keyup', closeWithKey);
 
-    window.addEventListener('touchend', ( e: TouchEvent ) => {
-      if(sliderMouseDown){
-        sliderPos = sliderPos - (mouseStartX - e.touches[0].clientX);
+    // window.addEventListener('touchend', ( e: TouchEvent ) => {
+    //   if(sliderMouseDown){
+    //     sliderPos = sliderPos - (mouseStartX - e.touches[0].clientX);
 
-        utils.set(sliderBar, { translateX: sliderPos - (mouseStartX - e.touches[0].clientX) });
-        sliderMouseDown = false;
+    //     utils.set(sliderBar, { translateX: sliderPos - (mouseStartX - e.touches[0].clientX) });
+    //     sliderMouseDown = false;
 
-        if(Math.abs(mouseStartX - e.touches[0].clientX) > 50){
-          let shortestDistance = 0;
-          let selectedButton = -1;
+    //     if(Math.abs(mouseStartX - e.touches[0].clientX) > 50){
+    //       let shortestDistance = 0;
+    //       let selectedButton = -1;
 
-          buttons.forEach(( pos, indx ) => {
-            let dis = Math.abs(sliderPos - (width / 2 - pos));
+    //       buttons.forEach(( pos, indx ) => {
+    //         let dis = Math.abs(sliderPos - (width / 2 - pos));
 
-            if(selectedButton === -1){
-              shortestDistance = dis;
-              selectedButton = indx;
-            } else if(shortestDistance > dis){
-              shortestDistance = dis;
-              selectedButton = indx;
-            }
-          })
+    //         if(selectedButton === -1){
+    //           shortestDistance = dis;
+    //           selectedButton = indx;
+    //         } else if(shortestDistance > dis){
+    //           shortestDistance = dis;
+    //           selectedButton = indx;
+    //         }
+    //       })
 
-          currentButton = selectedButton;
-        } else if(lastClickedButton != -1){
-          currentButton = lastClickedButton;
-          lastClickedButton = -1
-        }
-      }
-    })
+    //       currentButton = selectedButton;
+    //     } else if(lastClickedButton != -1){
+    //       currentButton = lastClickedButton;
+    //       lastClickedButton = -1
+    //     }
+    //   }
+    // })
 
-    sliderBar.addEventListener('mousedown', ( e: MouseEvent ) => {
-      sliderMouseDown = true;
-      mouseStartX = e.clientX;
-    });
+    // sliderBar.addEventListener('mousedown', ( e: MouseEvent ) => {
+    //   sliderMouseDown = true;
+    //   mouseStartX = e.clientX;
+    // });
 
-    window.addEventListener('mousemove', ( e: MouseEvent ) => {
-      if(sliderMouseDown){
-        utils.set(sliderBar, { translateX: sliderPos - (mouseStartX - e.clientX) });
-        settingsContainer.style.left = sliderPos - (mouseStartX - e.clientX) + 'px';
-        settingsContainer.style.left = (sliderPos - (mouseStartX - e.clientX) - (width / 2 - buttons[0])) * sliderScale + 'px';
-      }
-    })
+    // window.addEventListener('mousemove', ( e: MouseEvent ) => {
+    //   if(sliderMouseDown){
+    //     utils.set(sliderBar, { translateX: sliderPos - (mouseStartX - e.clientX) });
+    //     settingsContainer.style.left = sliderPos - (mouseStartX - e.clientX) + 'px';
+    //     settingsContainer.style.left = (sliderPos - (mouseStartX - e.clientX) - (width / 2 - buttons[0])) * sliderScale + 'px';
+    //   }
+    // })
 
-    window.addEventListener('mouseup', ( e: MouseEvent ) => {
-      if(sliderMouseDown){
-        sliderPos = sliderPos - (mouseStartX - e.clientX);
+    // window.addEventListener('mouseup', ( e: MouseEvent ) => {
+    //   if(sliderMouseDown){
+    //     sliderPos = sliderPos - (mouseStartX - e.clientX);
 
-        utils.set(sliderBar, { translateX: sliderPos - (mouseStartX - e.clientX) });
-        sliderMouseDown = false;
+    //     utils.set(sliderBar, { translateX: sliderPos - (mouseStartX - e.clientX) });
+    //     sliderMouseDown = false;
 
-        if(Math.abs(mouseStartX - e.clientX) > 50){
-          let shortestDistance = 0;
-          let selectedButton = -1;
+    //     if(Math.abs(mouseStartX - e.clientX) > 50){
+    //       let shortestDistance = 0;
+    //       let selectedButton = -1;
 
-          buttons.forEach(( pos, indx ) => {
-            let dis = Math.abs(sliderPos - (width / 2 - pos));
+    //       buttons.forEach(( pos, indx ) => {
+    //         let dis = Math.abs(sliderPos - (width / 2 - pos));
 
-            if(selectedButton === -1){
-              shortestDistance = dis;
-              selectedButton = indx;
-            } else if(shortestDistance > dis){
-              shortestDistance = dis;
-              selectedButton = indx;
-            }
-          })
+    //         if(selectedButton === -1){
+    //           shortestDistance = dis;
+    //           selectedButton = indx;
+    //         } else if(shortestDistance > dis){
+    //           shortestDistance = dis;
+    //           selectedButton = indx;
+    //         }
+    //       })
 
-          currentButton = selectedButton;
-        } else if(lastClickedButton != -1){
-          currentButton = lastClickedButton;
-          lastClickedButton = -1
-        }
-      }
-    })
+    //       currentButton = selectedButton;
+    //     } else if(lastClickedButton != -1){
+    //       currentButton = lastClickedButton;
+    //       lastClickedButton = -1
+    //     }
+    //   }
+    // })
 
-    window.addEventListener('resize', () => {
-      width = window.innerWidth;
-      sliderPos = width / 2 - buttons[currentButton];
-      sliderScale = width / (buttons[1] - buttons[0]);
+    // window.addEventListener('resize', () => {
+    //   width = window.innerWidth;
+    //   sliderPos = width / 2 - buttons[currentButton];
+    //   sliderScale = width / (buttons[1] - buttons[0]);
 
-      utils.set(sliderBar, { translateX: sliderPos  });
-    })
+    //   utils.set(sliderBar, { translateX: sliderPos  });
+    // })
 
-    sliderBar.addEventListener('wheel', ( e: WheelEvent ) => {
-      if(e.deltaY > 0){
-        if(buttons[currentButton + 1])
-          currentButton++;
-      } else{
-        if(buttons[currentButton - 1])
-          currentButton--;
-      }
-    })
+    // sliderBar.addEventListener('wheel', ( e: WheelEvent ) => {
+    //   if(e.deltaY > 0){
+    //     if(buttons[currentButton + 1])
+    //       currentButton++;
+    //   } else{
+    //     if(buttons[currentButton - 1])
+    //       currentButton--;
+    //   }
+    // })
   })
 
   onCleanup(() => {
···
             </label>
           </div>
 
+          <div class="selector">
+            <input type="checkbox" id="minimise-on-close-check" ref={async ( el ) => {
+              el.checked = await invoke('get_config_value_string', { key: 'minimise-on-close' }) === "false" ? false : true;
+            }} onChange={( el ) => {
+              if(el.target.checked){
+                invoke('set_config_value_string', { key: 'minimise-on-close', value: 'true' });
+              } else{
+                invoke('set_config_value_string', { key: 'minimise-on-close', value: 'false' });
+              }
+            }} />
+            Close to tray
+
+            <label for="minimise-on-close-check">
+              <div class="selection-box">
+                <div class="icon-small" style={{ margin: '0', display: 'inline-flex' }}>
+                  <img draggable="false" width="10" height="10" src="/icon/check-solid.svg"></img>
+                </div>
+              </div>
+            </label>
+          </div>
+
           <Show when={window.OS === 'windows'}>
             <div class="selector">
               <input type="checkbox" id="start-with-win-check" ref={async ( el ) => {
···
             </label>
           </div>
 
-          <div class="selector">
-            <input type="checkbox" id="minimise-on-close-check" ref={async ( el ) => {
-              el.checked = await invoke('get_config_value_string', { key: 'minimise-on-close' }) === "false" ? false : true;
-            }} onChange={( el ) => {
-              if(el.target.checked){
-                invoke('set_config_value_string', { key: 'minimise-on-close', value: 'true' });
-              } else{
-                invoke('set_config_value_string', { key: 'minimise-on-close', value: 'false' });
-              }
-            }} />
-            Close to tray
-
-            <label for="minimise-on-close-check">
-              <div class="selection-box">
-                <div class="icon-small" style={{ margin: '0', display: 'inline-flex' }}>
-                  <img draggable="false" width="10" height="10" src="/icon/check-solid.svg"></img>
-                </div>
-              </div>
-            </label>
-          </div>
-
           <br />
           <p>
             VRChat Photo Path:
···
           <br />
           <p>VRChat Photo Manager supports photos with extra metadata provided by VRCX.</p>
         </div>
-        <div class="settings-block">
-          <p>WIP</p>
-        </div>
       </div>
 
-      <div class="slide-bar-tri"></div>
+      {/* <div class="slide-bar-tri"></div>
       <div class="slide-bar">
         <div class="inner-slide-bar" ref={( el ) => sliderBar = el}>
           <div class="slider-dot"></div>
···
           <div class="slider-dot"></div>
           <div class="slider-dot"></div>
         </div>
-      </div>
+      </div> */}
     </div>
   )
 }

src/index.tsx

···
     PhotoViewerManager: PhotoViewerManager;
     WorldCacheManager: WorldCacheManager;
     PhotoListRenderingManager: PhotoListRenderingManager;
-    SyncManager: SyncManager;
     ViewManager: ViewManager;
 
     CloseAllPopups: (() => void)[];
···
 import { PhotoViewerManager } from "./Components/Managers/PhotoViewerManager";
 import { WorldCacheManager } from "./Components/Managers/WorldCacheManager";
 import { PhotoListRenderingManager } from "./Components/Managers/PhotoListRenderingManager";
-import { SyncManager } from "./Components/Managers/SyncManager";
 import { ViewManager } from "./Components/Managers/ViewManager";
 
 window.LoadingManager = new LoadingManager();
···
 window.PhotoViewerManager = new PhotoViewerManager();
 window.WorldCacheManager = new WorldCacheManager();
 window.PhotoListRenderingManager = new PhotoListRenderingManager();
-window.SyncManager = new SyncManager();
 window.ViewManager = new ViewManager();
 
 (async () => {