Move toju-app into own its folder

toju-app/src/app/app.ts

@@ -0,0 +1,217 @@
+/* eslint-disable @angular-eslint/component-class-suffix */
+import {
+  Component,
+  OnInit,
+  OnDestroy,
+  inject,
+  HostListener
+} from '@angular/core';
+import {
+  Router,
+  RouterOutlet,
+  NavigationEnd
+} from '@angular/router';
+import { CommonModule } from '@angular/common';
+import { Store } from '@ngrx/store';
+
+import { DatabaseService } from './infrastructure/persistence';
+import { DesktopAppUpdateService } from './core/services/desktop-app-update.service';
+import { ServerDirectoryFacade } from './domains/server-directory';
+import { TimeSyncService } from './core/services/time-sync.service';
+import { VoiceSessionFacade } from './domains/voice-session';
+import { ExternalLinkService } from './core/platform';
+import { SettingsModalService } from './core/services/settings-modal.service';
+import { ElectronBridgeService } from './core/platform/electron/electron-bridge.service';
+import { ServersRailComponent } from './features/servers/servers-rail.component';
+import { TitleBarComponent } from './features/shell/title-bar.component';
+import { FloatingVoiceControlsComponent } from './domains/voice-session/feature/floating-voice-controls/floating-voice-controls.component';
+import { SettingsModalComponent } from './features/settings/settings-modal/settings-modal.component';
+import { DebugConsoleComponent } from './shared/components/debug-console/debug-console.component';
+import { ScreenShareSourcePickerComponent } from './shared/components/screen-share-source-picker/screen-share-source-picker.component';
+import { UsersActions } from './store/users/users.actions';
+import { RoomsActions } from './store/rooms/rooms.actions';
+import { selectCurrentRoom } from './store/rooms/rooms.selectors';
+import {
+  ROOM_URL_PATTERN,
+  STORAGE_KEY_CURRENT_USER_ID,
+  STORAGE_KEY_LAST_VISITED_ROUTE
+} from './core/constants';
+
+@Component({
+  selector: 'app-root',
+  imports: [
+    CommonModule,
+    RouterOutlet,
+    ServersRailComponent,
+    TitleBarComponent,
+    FloatingVoiceControlsComponent,
+    SettingsModalComponent,
+    DebugConsoleComponent,
+    ScreenShareSourcePickerComponent
+  ],
+  templateUrl: './app.html',
+  styleUrl: './app.scss'
+})
+export class App implements OnInit, OnDestroy {
+  store = inject(Store);
+  currentRoom = this.store.selectSignal(selectCurrentRoom);
+  desktopUpdates = inject(DesktopAppUpdateService);
+  desktopUpdateState = this.desktopUpdates.state;
+
+  private databaseService = inject(DatabaseService);
+  private router = inject(Router);
+  private servers = inject(ServerDirectoryFacade);
+  private settingsModal = inject(SettingsModalService);
+  private timeSync = inject(TimeSyncService);
+  private voiceSession = inject(VoiceSessionFacade);
+  private externalLinks = inject(ExternalLinkService);
+  private electronBridge = inject(ElectronBridgeService);
+  private deepLinkCleanup: (() => void) | null = null;
+
+  @HostListener('document:click', ['$event'])
+  onGlobalLinkClick(evt: MouseEvent): void {
+    this.externalLinks.handleClick(evt);
+  }
+
+  async ngOnInit(): Promise<void> {
+    void this.desktopUpdates.initialize();
+
+    await this.databaseService.initialize();
+
+    try {
+      const apiBase = this.servers.getApiBaseUrl();
+
+      await this.timeSync.syncWithEndpoint(apiBase);
+    } catch {}
+
+    await this.setupDesktopDeepLinks();
+
+    this.store.dispatch(UsersActions.loadCurrentUser());
+
+    this.store.dispatch(RoomsActions.loadRooms());
+
+    const currentUserId = localStorage.getItem(STORAGE_KEY_CURRENT_USER_ID);
+
+    if (!currentUserId) {
+      if (!this.isPublicRoute(this.router.url)) {
+        this.router.navigate(['/login'], {
+          queryParams: {
+            returnUrl: this.router.url
+          }
+        }).catch(() => {});
+      }
+    } else {
+      const last = localStorage.getItem(STORAGE_KEY_LAST_VISITED_ROUTE);
+
+      if (last && typeof last === 'string') {
+        const current = this.router.url;
+
+        if (current === '/' || current === '/search') {
+          this.router.navigate([last], { replaceUrl: true }).catch(() => {});
+        }
+      }
+    }
+
+    this.router.events.subscribe((evt) => {
+      if (evt instanceof NavigationEnd) {
+        const url = evt.urlAfterRedirects || evt.url;
+
+        localStorage.setItem(STORAGE_KEY_LAST_VISITED_ROUTE, url);
+
+        const roomMatch = url.match(ROOM_URL_PATTERN);
+        const currentRoomId = roomMatch ? roomMatch[1] : null;
+
+        this.voiceSession.checkCurrentRoute(currentRoomId);
+      }
+    });
+  }
+
+  ngOnDestroy(): void {
+    this.deepLinkCleanup?.();
+    this.deepLinkCleanup = null;
+  }
+
+  openNetworkSettings(): void {
+    this.settingsModal.open('network');
+  }
+
+  openUpdatesSettings(): void {
+    this.settingsModal.open('updates');
+  }
+
+  async refreshDesktopUpdateContext(): Promise<void> {
+    await this.desktopUpdates.refreshServerContext();
+  }
+
+  async restartToApplyUpdate(): Promise<void> {
+    await this.desktopUpdates.restartToApplyUpdate();
+  }
+
+  private async setupDesktopDeepLinks(): Promise<void> {
+    const electronApi = this.electronBridge.getApi();
+
+    if (!electronApi) {
+      return;
+    }
+
+    this.deepLinkCleanup = electronApi.onDeepLinkReceived?.((url) => {
+      void this.handleDesktopDeepLink(url);
+    }) || null;
+
+    const pendingDeepLink = await electronApi.consumePendingDeepLink?.();
+
+    if (pendingDeepLink) {
+      await this.handleDesktopDeepLink(pendingDeepLink);
+    }
+  }
+
+  private async handleDesktopDeepLink(url: string): Promise<void> {
+    const invite = this.parseDesktopInviteUrl(url);
+
+    if (!invite) {
+      return;
+    }
+
+    await this.router.navigate(['/invite', invite.inviteId], {
+      queryParams: {
+        server: invite.sourceUrl
+      }
+    });
+  }
+
+  private isPublicRoute(url: string): boolean {
+    return url === '/login' ||
+      url === '/register' ||
+      url.startsWith('/invite/');
+  }
+
+  private parseDesktopInviteUrl(url: string): { inviteId: string; sourceUrl: string } | null {
+    try {
+      const parsedUrl = new URL(url);
+
+      if (parsedUrl.protocol !== 'toju:') {
+        return null;
+      }
+
+      const pathSegments = [parsedUrl.hostname, ...parsedUrl.pathname.split('/').filter(Boolean)]
+        .map((segment) => decodeURIComponent(segment));
+
+      if (pathSegments[0] !== 'invite' || !pathSegments[1]) {
+        return null;
+      }
+
+      const sourceUrl = parsedUrl.searchParams.get('server')?.trim();
+
+      if (!sourceUrl) {
+        return null;
+      }
+
+      return {
+        inviteId: pathSegments[1],
+        sourceUrl
+      };
+    } catch {
+      return null;
+    }
+  }
+}