refactor: rename states to view controllers (#1060)

app/assets/javascripts/Application/Application.ts

@@ -0,0 +1,166 @@
+import { WebCrypto } from '@/Crypto'
+import { WebAlertService } from '@/Services/AlertService'
+import { ArchiveManager } from '@/Services/ArchiveManager'
+import { AutolockService } from '@/Services/AutolockService'
+import { DesktopManager } from '@/Services/DesktopManager'
+import { IOService } from '@/Services/IOService'
+import { ThemeManager } from '@/Services/ThemeManager'
+import { ViewControllerManager } from '@/Services/ViewControllerManager'
+import { WebOrDesktopDevice } from '@/Device/WebOrDesktopDevice'
+import {
+  DeinitSource,
+  Platform,
+  SNApplication,
+  NoteGroupController,
+  removeFromArray,
+  IconsController,
+  DesktopDeviceInterface,
+  isDesktopDevice,
+  DeinitMode,
+} from '@standardnotes/snjs'
+import { makeObservable, observable } from 'mobx'
+
+type WebServices = {
+  viewControllerManager: ViewControllerManager
+  desktopService?: DesktopManager
+  autolockService: AutolockService
+  archiveService: ArchiveManager
+  themeService: ThemeManager
+  io: IOService
+}
+
+export enum WebAppEvent {
+  NewUpdateAvailable = 'NewUpdateAvailable',
+  DesktopWindowGainedFocus = 'DesktopWindowGainedFocus',
+  DesktopWindowLostFocus = 'DesktopWindowLostFocus',
+}
+
+export type WebEventObserver = (event: WebAppEvent) => void
+
+export class WebApplication extends SNApplication {
+  private webServices!: WebServices
+  private webEventObservers: WebEventObserver[] = []
+  public noteControllerGroup: NoteGroupController
+  public iconsController: IconsController
+
+  constructor(
+    deviceInterface: WebOrDesktopDevice,
+    platform: Platform,
+    identifier: string,
+    defaultSyncServerHost: string,
+    webSocketUrl: string,
+  ) {
+    super({
+      environment: deviceInterface.environment,
+      platform: platform,
+      deviceInterface: deviceInterface,
+      crypto: WebCrypto,
+      alertService: new WebAlertService(),
+      identifier,
+      defaultHost: defaultSyncServerHost,
+      appVersion: deviceInterface.appVersion,
+      webSocketUrl: webSocketUrl,
+      supportsFileNavigation: window.enabledUnfinishedFeatures || false,
+    })
+
+    makeObservable(this, {
+      dealloced: observable,
+    })
+
+    deviceInterface.setApplication(this)
+    this.noteControllerGroup = new NoteGroupController(this)
+    this.iconsController = new IconsController()
+  }
+
+  override deinit(mode: DeinitMode, source: DeinitSource): void {
+    super.deinit(mode, source)
+
+    try {
+      for (const service of Object.values(this.webServices)) {
+        if (!service) {
+          continue
+        }
+
+        if ('deinit' in service) {
+          service.deinit?.(source)
+        }
+
+        ;(service as { application?: WebApplication }).application = undefined
+      }
+
+      this.webServices = {} as WebServices
+
+      this.noteControllerGroup.deinit()
+      ;(this.noteControllerGroup as unknown) = undefined
+
+      this.webEventObservers.length = 0
+    } catch (error) {
+      console.error('Error while deiniting application', error)
+    }
+  }
+
+  setWebServices(services: WebServices): void {
+    this.webServices = services
+  }
+
+  public addWebEventObserver(observer: WebEventObserver): () => void {
+    this.webEventObservers.push(observer)
+    return () => {
+      removeFromArray(this.webEventObservers, observer)
+    }
+  }
+
+  public notifyWebEvent(event: WebAppEvent): void {
+    for (const observer of this.webEventObservers) {
+      observer(event)
+    }
+  }
+
+  public getViewControllerManager(): ViewControllerManager {
+    return this.webServices.viewControllerManager
+  }
+
+  public getDesktopService(): DesktopManager | undefined {
+    return this.webServices.desktopService
+  }
+
+  public getAutolockService() {
+    return this.webServices.autolockService
+  }
+
+  public getArchiveService() {
+    return this.webServices.archiveService
+  }
+
+  public get desktopDevice(): DesktopDeviceInterface | undefined {
+    if (isDesktopDevice(this.deviceInterface)) {
+      return this.deviceInterface
+    }
+
+    return undefined
+  }
+
+  public getThemeService() {
+    return this.webServices.themeService
+  }
+
+  public get io() {
+    return this.webServices.io
+  }
+
+  async checkForSecurityUpdate() {
+    return this.protocolUpgradeAvailable()
+  }
+
+  downloadBackup(): void | Promise<void> {
+    if (isDesktopDevice(this.deviceInterface)) {
+      return this.deviceInterface.downloadBackup()
+    }
+  }
+
+  async signOutAndDeleteLocalBackups(): Promise<void> {
+    isDesktopDevice(this.deviceInterface) && (await this.deviceInterface.deleteLocalBackups())
+
+    return this.user.signOut()
+  }
+}

app/assets/javascripts/Application/ApplicationGroup.ts

@@ -0,0 +1,80 @@
+import { WebApplication } from './Application'
+import {
+  ApplicationDescriptor,
+  SNApplicationGroup,
+  Platform,
+  InternalEventBus,
+  isDesktopDevice,
+} from '@standardnotes/snjs'
+import { ViewControllerManager } from '@/Services/ViewControllerManager'
+import { getPlatform, isDesktopApplication } from '@/Utils'
+import { ArchiveManager } from '@/Services/ArchiveManager'
+import { DesktopManager } from '@/Services/DesktopManager'
+import { IOService } from '@/Services/IOService'
+import { AutolockService } from '@/Services/AutolockService'
+import { ThemeManager } from '@/Services/ThemeManager'
+import { WebOrDesktopDevice } from '@/Device/WebOrDesktopDevice'
+
+const createApplication = (
+  descriptor: ApplicationDescriptor,
+  deviceInterface: WebOrDesktopDevice,
+  defaultSyncServerHost: string,
+  device: WebOrDesktopDevice,
+  webSocketUrl: string,
+) => {
+  const platform = getPlatform()
+
+  const application = new WebApplication(
+    deviceInterface,
+    platform,
+    descriptor.identifier,
+    defaultSyncServerHost,
+    webSocketUrl,
+  )
+
+  const viewControllerManager = new ViewControllerManager(application, device)
+  const archiveService = new ArchiveManager(application)
+  const io = new IOService(platform === Platform.MacWeb || platform === Platform.MacDesktop)
+  const autolockService = new AutolockService(application, new InternalEventBus())
+  const themeService = new ThemeManager(application)
+
+  application.setWebServices({
+    viewControllerManager,
+    archiveService,
+    desktopService: isDesktopDevice(device) ? new DesktopManager(application, device) : undefined,
+    io,
+    autolockService,
+    themeService,
+  })
+
+  return application
+}
+
+export class ApplicationGroup extends SNApplicationGroup<WebOrDesktopDevice> {
+  constructor(private defaultSyncServerHost: string, device: WebOrDesktopDevice, private webSocketUrl: string) {
+    super(device)
+  }
+
+  override async initialize(): Promise<void> {
+    const defaultSyncServerHost = this.defaultSyncServerHost
+    const webSocketUrl = this.webSocketUrl
+
+    await super.initialize({
+      applicationCreator: async (descriptor, device) => {
+        return createApplication(descriptor, device, defaultSyncServerHost, device, webSocketUrl)
+      },
+    })
+
+    if (isDesktopApplication()) {
+      window.webClient = (this.primaryApplication as WebApplication).getDesktopService()
+    }
+  }
+
+  override deinit() {
+    super.deinit()
+
+    if (isDesktopApplication()) {
+      delete window.webClient
+    }
+  }
+}