chore: update devcontainers for trixie, devenv changes

* Fix log formatting for logger.error(..., error)

Rewrite it to avoid printing error msg in [context]

* Fix log formatting for logger.warn(..., error?.stack)

Rewrite it to avoid printing stack in [context]

* Fix log formatting for logger.debug(..., error.message);

Rewrite it to avoid printing error msg in [context]

* Print error msg instead of literal "Error"

.devcontainer/devcontainer.json

@@ -5,8 +5,7 @@
     "immich-server",
     "redis",
     "database",
-    "immich-machine-learning",
-    "init"
+    "immich-machine-learning"
   ],
   "dockerComposeFile": [
     "../docker/docker-compose.dev.yml",

.devcontainer/mobile/container-compose-overrides.yml

@@ -6,28 +6,35 @@ services:
       - IMMICH_SERVER_URL=http://127.0.0.1:2283/
     volumes: !override # bind mount host to /workspaces/immich
       - ..:/workspaces/immich
-      - cli_node_modules:/workspaces/immich/cli/node_modules
-      - e2e_node_modules:/workspaces/immich/e2e/node_modules
-      - open_api_node_modules:/workspaces/immich/open-api/typescript-sdk/node_modules
-      - server_node_modules:/workspaces/immich/server/node_modules
-      - web_node_modules:/workspaces/immich/web/node_modules
-      - ${UPLOAD_LOCATION}/photos:/data
+      - ${UPLOAD_LOCATION:-upload-devcontainer-volume}${UPLOAD_LOCATION:+/photos}:/data
+      - pnpm-store:/usr/src/app/.pnpm-store
+      - server-node_modules:/usr/src/app/server/node_modules
+      - web-node_modules:/usr/src/app/web/node_modules
+      - github-node_modules:/usr/src/app/.github/node_modules
+      - cli-node_modules:/usr/src/app/cli/node_modules
+      - docs-node_modules:/usr/src/app/docs/node_modules
+      - e2e-node_modules:/usr/src/app/e2e/node_modules
+      - sdk-node_modules:/usr/src/app/open-api/typescript-sdk/node_modules
+      - app-node_modules:/usr/src/app/node_modules
+      - sveltekit:/usr/src/app/web/.svelte-kit
+      - coverage:/usr/src/app/web/coverage
       - /etc/localtime:/etc/localtime:ro
-
+  immich-web:
+    env_file: !reset []
+  immich-machine-learning:
+    env_file: !reset []
   database:
+    env_file: !reset []
+    environment: !override
+      POSTGRES_PASSWORD: ${DB_PASSWORD-postgres}
+      POSTGRES_USER: ${DB_USERNAME-postgres}
+      POSTGRES_DB: ${DB_DATABASE_NAME-immich}
+      POSTGRES_INITDB_ARGS: '--data-checksums'
+      POSTGRES_HOST_AUTH_METHOD: md5
     volumes:
-      - ${UPLOAD_LOCATION}/postgres:/var/lib/postgresql/data
-
+      - ${UPLOAD_LOCATION:-postgres-devcontainer-volume}${UPLOAD_LOCATION:+/postgres}:/var/lib/postgresql/data
+  redis:
+    env_file: !reset []
 volumes:
-  # Node modules for each service to avoid conflicts and ensure consistent dependencies
-  cli_node_modules:
-  e2e_node_modules:
-  open_api_node_modules:
-  server_node_modules:
-  web_node_modules:
-
-  # UPLOAD_LOCATION must be set to a absolute path or vol-upload
-  vol-upload:
-
-  # DB_DATA_LOCATION must be set to a absolute path or vol-database
-  vol-database:
+  upload-devcontainer-volume:
+  postgres-devcontainer-volume:

.devcontainer/mobile/devcontainer.json

@@ -40,7 +40,7 @@
   "userEnvProbe": "loginInteractiveShell",
   "remoteEnv": {
     // The location where your uploaded files are stored
-    "UPLOAD_LOCATION": "${localEnv:UPLOAD_LOCATION:./Library}",
+    "UPLOAD_LOCATION": "${localEnv:UPLOAD_LOCATION:./library}",
     //  Connection secret for postgres. You should change it to a random password
     //  Please use only the characters `A-Za-z0-9`, without special characters or spaces
     "DB_PASSWORD": "${localEnv:DB_PASSWORD:postgres}",

mise.lock

@@ -1,34 +0,0 @@
-[tools.dart]
-version = "3.8.2"
-backend = "asdf:dart"
-
-[tools.flutter]
-version = "3.35.3-stable"
-backend = "asdf:flutter"
-
-[tools."github:CQLabs/homebrew-dcm"]
-version = "1.31.4"
-backend = "github:CQLabs/homebrew-dcm"
-
-[tools."github:CQLabs/homebrew-dcm".platforms.linux-x64]
-checksum = "blake3:e9df5b765df327e1248fccf2c6165a89d632a065667f99c01765bf3047b94955"
-size = 8821083
-url = "https://github.com/CQLabs/homebrew-dcm/releases/download/1.31.4/dcm-linux-x64-release.zip"
-
-[tools.node]
-version = "22.18.0"
-backend = "core:node"
-
-[tools.node.platforms.linux-x64]
-checksum = "sha256:a2e703725d8683be86bb5da967bf8272f4518bdaf10f21389e2b2c9eaeae8c8a"
-size = 54824343
-url = "https://nodejs.org/dist/v22.18.0/node-v22.18.0-linux-x64.tar.gz"
-
-[tools.pnpm]
-version = "10.14.0"
-backend = "aqua:pnpm/pnpm"
-
-[tools.pnpm.platforms.linux-x64]
-checksum = "blake3:13dfa46b7173d3cad3bad60a756a492ecf0bce48b23eb9f793e7ccec5a09b46d"
-size = 66231525
-url = "https://github.com/pnpm/pnpm/releases/download/v10.14.0/pnpm-linux-x64"

mise.toml

@@ -11,7 +11,6 @@ postinstall = "chmod +x $MISE_TOOL_INSTALL_PATH/dcm"
 
 [settings]
 experimental = true
-lockfile = true
 pin = true
 
 # .github

mobile/ios/Runner.xcodeproj/project.pbxproj

@@ -3,7 +3,7 @@
 	archiveVersion = 1;
 	classes = {
 	};
-	objectVersion = 77;
+	objectVersion = 54;
 	objects = {
 
 /* Begin PBXBuildFile section */
@@ -133,6 +133,8 @@
 /* Begin PBXFileSystemSynchronizedRootGroup section */
 		B2CF7F8C2DDE4EBB00744BF6 /* Sync */ = {
 			isa = PBXFileSystemSynchronizedRootGroup;
+			exceptions = (
+			);
 			path = Sync;
 			sourceTree = "<group>";
 		};
@@ -519,14 +521,10 @@
 			inputFileListPaths = (
 				"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-resources-${CONFIGURATION}-input-files.xcfilelist",
 			);
-			inputPaths = (
-			);
 			name = "[CP] Copy Pods Resources";
 			outputFileListPaths = (
 				"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-resources-${CONFIGURATION}-output-files.xcfilelist",
 			);
-			outputPaths = (
-			);
 			runOnlyForDeploymentPostprocessing = 0;
 			shellPath = /bin/sh;
 			shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-resources.sh\"\n";
@@ -555,14 +553,10 @@
 			inputFileListPaths = (
 				"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-input-files.xcfilelist",
 			);
-			inputPaths = (
-			);
 			name = "[CP] Embed Pods Frameworks";
 			outputFileListPaths = (
 				"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-output-files.xcfilelist",
 			);
-			outputPaths = (
-			);
 			runOnlyForDeploymentPostprocessing = 0;
 			shellPath = /bin/sh;
 			shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks.sh\"\n";

mobile/lib/pages/backup/drift_backup.page.dart

@@ -12,6 +12,7 @@ import 'package:immich_mobile/presentation/widgets/backup/backup_toggle_button.w
 import 'package:immich_mobile/providers/background_sync.provider.dart';
 import 'package:immich_mobile/providers/backup/backup_album.provider.dart';
 import 'package:immich_mobile/providers/backup/drift_backup.provider.dart';
+import 'package:immich_mobile/providers/sync_status.provider.dart';
 import 'package:immich_mobile/providers/user.provider.dart';
 import 'package:immich_mobile/routing/router.dart';
 import 'package:immich_mobile/widgets/backup/backup_info_card.dart';
@@ -33,7 +34,14 @@ class _DriftBackupPageState extends ConsumerState<DriftBackupPage> {
       return;
     }
 
-    ref.read(driftBackupProvider.notifier).getBackupStatus(currentUser.id);
+    WidgetsBinding.instance.addPostFrameCallback((_) async {
+      await ref.read(driftBackupProvider.notifier).getBackupStatus(currentUser.id);
+      await ref.read(backgroundSyncProvider).syncRemote();
+
+      if (mounted) {
+        await ref.read(driftBackupProvider.notifier).getBackupStatus(currentUser.id);
+      }
+    });
   }
 
   @override
@@ -44,7 +52,6 @@ class _DriftBackupPageState extends ConsumerState<DriftBackupPage> {
         .toList();
 
     final backupNotifier = ref.read(driftBackupProvider.notifier);
-    final backgroundManager = ref.read(backgroundSyncProvider);
 
     Future<void> startBackup() async {
       final currentUser = Store.tryGet(StoreKey.currentUser);
@@ -52,7 +59,6 @@ class _DriftBackupPageState extends ConsumerState<DriftBackupPage> {
         return;
       }
 
-      await backgroundManager.syncRemote();
       await backupNotifier.getBackupStatus(currentUser.id);
       await backupNotifier.startBackup(currentUser.id);
     }
@@ -235,11 +241,13 @@ class _BackupCard extends ConsumerWidget {
   @override
   Widget build(BuildContext context, WidgetRef ref) {
     final backupCount = ref.watch(driftBackupProvider.select((p) => p.backupCount));
+    final syncStatus = ref.watch(syncStatusProvider);
 
     return BackupInfoCard(
       title: "backup_controller_page_backup".tr(),
       subtitle: "backup_controller_page_backup_sub".tr(),
       info: backupCount.toString(),
+      isLoading: syncStatus.isRemoteSyncing,
     );
   }
 }
@@ -250,10 +258,13 @@ class _RemainderCard extends ConsumerWidget {
   @override
   Widget build(BuildContext context, WidgetRef ref) {
     final remainderCount = ref.watch(driftBackupProvider.select((p) => p.remainderCount));
+    final syncStatus = ref.watch(syncStatusProvider);
+
     return BackupInfoCard(
       title: "backup_controller_page_remainder".tr(),
       subtitle: "backup_controller_page_remainder_sub".tr(),
       info: remainderCount.toString(),
+      isLoading: syncStatus.isRemoteSyncing,
       onTap: () => context.pushRoute(const DriftBackupAssetDetailRoute()),
     );
   }

mobile/lib/presentation/widgets/timeline/fixed/segment.model.dart

@@ -101,7 +101,6 @@ class _FixedSegmentRow extends ConsumerWidget {
     if (isScrubbing) {
       return _buildPlaceholder(context);
     }
-
     if (timelineService.hasRange(assetIndex, assetCount)) {
       return _buildAssetRow(context, timelineService.getAssets(assetIndex, assetCount), timelineService);
     }

mobile/lib/presentation/widgets/timeline/scrubber.widget.dart

@@ -11,6 +11,7 @@ import 'package:immich_mobile/presentation/widgets/timeline/constants.dart';
 import 'package:immich_mobile/presentation/widgets/timeline/segment.model.dart';
 import 'package:immich_mobile/presentation/widgets/timeline/timeline.state.dart';
 import 'package:immich_mobile/providers/haptic_feedback.provider.dart';
+import 'package:immich_mobile/utils/debounce.dart';
 import 'package:intl/intl.dart' hide TextDirection;
 
 /// A widget that will display a BoxScrollView with a ScrollThumb that can be dragged
@@ -81,6 +82,8 @@ class ScrubberState extends ConsumerState<Scrubber> with TickerProviderStateMixi
   bool _isDragging = false;
   List<_Segment> _segments = [];
   int _monthCount = 0;
+  DateTime? _currentScrubberDate;
+  Debouncer? _scrubberDebouncer;
 
   late AnimationController _thumbAnimationController;
   Timer? _fadeOutTimer;
@@ -133,6 +136,7 @@ class ScrubberState extends ConsumerState<Scrubber> with TickerProviderStateMixi
     _thumbAnimationController.dispose();
     _labelAnimationController.dispose();
     _fadeOutTimer?.cancel();
+    _scrubberDebouncer?.dispose();
     super.dispose();
   }
 
@@ -176,11 +180,25 @@ class ScrubberState extends ConsumerState<Scrubber> with TickerProviderStateMixi
     return false;
   }
 
-  void _onDragStart(DragStartDetails _) {
-    if (_monthCount >= kMinMonthsToEnableScrubberSnap) {
+  void _onScrubberDateChanged(DateTime date) {
+    if (_currentScrubberDate != date) {
+      // Date changed, immediately set scrubbing to true
+      _currentScrubberDate = date;
       ref.read(timelineStateProvider.notifier).setScrubbing(true);
-    }
 
+      // Initialize debouncer if needed
+      _scrubberDebouncer ??= Debouncer(interval: const Duration(milliseconds: 50));
+
+      // Debounce setting scrubbing to false
+      _scrubberDebouncer!.run(() {
+        if (_currentScrubberDate == date) {
+          ref.read(timelineStateProvider.notifier).setScrubbing(false);
+        }
+      });
+    }
+  }
+
+  void _onDragStart(DragStartDetails _) {
     setState(() {
       _isDragging = true;
       _labelAnimationController.forward();
@@ -206,6 +224,11 @@ class ScrubberState extends ConsumerState<Scrubber> with TickerProviderStateMixi
       if (_lastLabel != label) {
         ref.read(hapticFeedbackProvider.notifier).selectionClick();
         _lastLabel = label;
+
+        // Notify timeline state of the new scrubber date position
+        if (_monthCount >= kMinMonthsToEnableScrubberSnap) {
+          _onScrubberDateChanged(nearestMonthSegment.date);
+        }
       }
     }
 
@@ -294,12 +317,18 @@ class ScrubberState extends ConsumerState<Scrubber> with TickerProviderStateMixi
   }
 
   void _onDragEnd(DragEndDetails _) {
-    ref.read(timelineStateProvider.notifier).setScrubbing(false);
     _labelAnimationController.reverse();
     setState(() {
       _isDragging = false;
     });
 
+    ref.read(timelineStateProvider.notifier).setScrubbing(false);
+
+    // Reset scrubber tracking when drag ends
+    _currentScrubberDate = null;
+    _scrubberDebouncer?.dispose();
+    _scrubberDebouncer = null;
+
     _resetThumbTimer();
   }
 

mobile/lib/presentation/widgets/timeline/timeline.state.dart

@@ -72,8 +72,6 @@ class TimelineState {
 }
 
 class TimelineStateNotifier extends Notifier<TimelineState> {
-  TimelineStateNotifier();
-
   void setScrubbing(bool isScrubbing) {
     state = state.copyWith(isScrubbing: isScrubbing);
   }

mobile/lib/providers/backup/drift_backup.provider.dart

@@ -235,7 +235,9 @@ class DriftBackupNotifier extends StateNotifier<DriftBackupState> {
     switch (update.status) {
       case TaskStatus.complete:
         if (update.task.group == kBackupGroup) {
-          state = state.copyWith(backupCount: state.backupCount + 1, remainderCount: state.remainderCount - 1);
+          if (update.responseStatusCode == 201) {
+            state = state.copyWith(backupCount: state.backupCount + 1, remainderCount: state.remainderCount - 1);
+          }
         }
 
         // Remove the completed task from the upload items

mobile/lib/widgets/backup/backup_info_card.dart

@@ -8,8 +8,17 @@ class BackupInfoCard extends StatelessWidget {
   final String title;
   final String subtitle;
   final String info;
+
   final VoidCallback? onTap;
-  const BackupInfoCard({super.key, required this.title, required this.subtitle, required this.info, this.onTap});
+  final bool isLoading;
+  const BackupInfoCard({
+    super.key,
+    required this.title,
+    required this.subtitle,
+    required this.info,
+    this.onTap,
+    this.isLoading = false,
+  });
 
   @override
   Widget build(BuildContext context) {
@@ -38,8 +47,36 @@ class BackupInfoCard extends StatelessWidget {
             trailing: Column(
               mainAxisAlignment: MainAxisAlignment.center,
               children: [
-                Text(info, style: context.textTheme.titleLarge),
-                Text("backup_info_card_assets", style: context.textTheme.labelLarge).tr(),
+                Stack(
+                  children: [
+                    Text(
+                      info,
+                      style: context.textTheme.titleLarge?.copyWith(
+                        color: context.colorScheme.onSurface.withAlpha(isLoading ? 50 : 255),
+                      ),
+                    ),
+                    if (isLoading)
+                      Positioned.fill(
+                        child: Align(
+                          alignment: Alignment.center,
+                          child: SizedBox(
+                            width: 16,
+                            height: 16,
+                            child: CircularProgressIndicator(
+                              strokeWidth: 2,
+                              color: context.colorScheme.onSurface.withAlpha(150),
+                            ),
+                          ),
+                        ),
+                      ),
+                  ],
+                ),
+                Text(
+                  "backup_info_card_assets",
+                  style: context.textTheme.labelLarge?.copyWith(
+                    color: context.colorScheme.onSurface.withAlpha(isLoading ? 50 : 255),
+                  ),
+                ).tr(),
               ],
             ),
           ),

server/Dockerfile.dev

@@ -27,8 +27,8 @@ ENTRYPOINT ["tini", "--", "/bin/bash", "-c"]
 FROM dev AS dev-container-server
 
 RUN apt-get update --allow-releaseinfo-change && \
-  apt-get install sudo inetutils-ping openjdk-11-jre-headless \
-  vim nano \
+  apt-get install sudo inetutils-ping openjdk-21-jre-headless \
+  vim nano curl \
   -y --no-install-recommends --fix-missing
 
 RUN usermod -aG sudo node && \
@@ -44,13 +44,18 @@ FROM dev-container-server AS dev-container-mobile
 USER root
 # Enable multiarch for arm64 if necessary
 RUN if [ "$(dpkg --print-architecture)" = "arm64" ]; then \
-  dpkg --add-architecture amd64 && \
-  apt-get update && \
-  apt-get install -y --no-install-recommends \
-  qemu-user-static \
-  libc6:amd64 \
-  libstdc++6:amd64 \
-  libgcc1:amd64; \
+    dpkg --add-architecture amd64 && \
+    apt-get update && \
+    apt-get install -y --no-install-recommends \
+    gnupg \
+    qemu-user-static \
+    libc6:amd64 \
+    libstdc++6:amd64 \
+    libgcc1:amd64; \
+  else \
+    apt-get update && \
+    apt-get install -y --no-install-recommends \
+    gnupg; \
   fi
 
 # Flutter SDK
@@ -65,11 +70,11 @@ RUN mkdir -p ${FLUTTER_HOME} \
   && curl -C - --output flutter.tar.xz https://storage.googleapis.com/flutter_infra_release/releases/${FLUTTER_CHANNEL}/linux/flutter_linux_${FLUTTER_VERSION}-${FLUTTER_CHANNEL}.tar.xz \
   && tar -xf flutter.tar.xz --strip-components=1 -C ${FLUTTER_HOME} \
   && rm flutter.tar.xz \
-  && chown -R node ${FLUTTER_HOME}
+  && chown -R node ${FLUTTER_HOME} \
+  && git config --global --add safe.directory ${FLUTTER_HOME}
 
 
-RUN apt-get update \
-  && wget -qO- https://dcm.dev/pgp-key.public | gpg --dearmor -o /usr/share/keyrings/dcm.gpg \
+RUN wget -qO- https://dcm.dev/pgp-key.public | gpg --dearmor -o /usr/share/keyrings/dcm.gpg \
   && echo 'deb [signed-by=/usr/share/keyrings/dcm.gpg arch=amd64] https://dcm.dev/debian stable main' | tee /etc/apt/sources.list.d/dart_stable.list \
   && apt-get update \
   && apt-get install dcm -y

server/src/repositories/media.repository.ts

@@ -57,28 +57,28 @@ export class MediaRepository {
       const buffer = await exiftool.extractBinaryTagToBuffer('JpgFromRaw2', input);
       return { buffer, format: RawExtractedFormat.Jpeg };
     } catch (error: any) {
-      this.logger.debug('Could not extract JpgFromRaw2 buffer from image, trying JPEG from RAW next', error.message);
+      this.logger.debug(`Could not extract JpgFromRaw2 buffer from image, trying JPEG from RAW next: ${error}`);
     }
 
     try {
       const buffer = await exiftool.extractBinaryTagToBuffer('JpgFromRaw', input);
       return { buffer, format: RawExtractedFormat.Jpeg };
     } catch (error: any) {
-      this.logger.debug('Could not extract JPEG buffer from image, trying PreviewJXL next', error.message);
+      this.logger.debug(`Could not extract JPEG buffer from image, trying PreviewJXL next: ${error}`);
     }
 
     try {
       const buffer = await exiftool.extractBinaryTagToBuffer('PreviewJXL', input);
       return { buffer, format: RawExtractedFormat.Jxl };
     } catch (error: any) {
-      this.logger.debug('Could not extract PreviewJXL buffer from image, trying PreviewImage next', error.message);
+      this.logger.debug(`Could not extract PreviewJXL buffer from image, trying PreviewImage next: ${error}`);
     }
 
     try {
       const buffer = await exiftool.extractBinaryTagToBuffer('PreviewImage', input);
       return { buffer, format: RawExtractedFormat.Jpeg };
     } catch (error: any) {
-      this.logger.debug('Could not extract preview buffer from image', error.message);
+      this.logger.debug(`Could not extract preview buffer from image: ${error}`);
       return null;
     }
   }

server/src/repositories/metadata.repository.ts

@@ -103,7 +103,7 @@ export class MetadataRepository {
 
   readTags(path: string): Promise<ImmichTags> {
     return this.exiftool.read(path).catch((error) => {
-      this.logger.warn(`Error reading exif data (${path}): ${error}`, error?.stack);
+      this.logger.warn(`Error reading exif data (${path}): ${error}\n${error?.stack}`);
       return {};
     }) as Promise<ImmichTags>;
   }

server/src/services/auth.service.ts

@@ -344,7 +344,7 @@ export class AuthService extends BaseService {
         await this.jobRepository.queue({ name: JobName.FileDelete, data: { files: [oldPath] } });
       }
     } catch (error: Error | any) {
-      this.logger.warn(`Unable to sync oauth profile picture: ${error}`, error?.stack);
+      this.logger.warn(`Unable to sync oauth profile picture: ${error}\n${error?.stack}`);
     }
   }
 

server/src/services/backup.service.ts

@@ -132,12 +132,12 @@ export class BackupService extends BaseService {
         gzip.stdout.pipe(fileStream);
 
         pgdump.on('error', (err) => {
-          this.logger.error('Backup failed with error', err);
+          this.logger.error(`Backup failed with error: ${err}`);
           reject(err);
         });
 
         gzip.on('error', (err) => {
-          this.logger.error('Gzip failed with error', err);
+          this.logger.error(`Gzip failed with error: ${err}`);
           reject(err);
         });
 
@@ -175,10 +175,10 @@ export class BackupService extends BaseService {
       });
       await this.storageRepository.rename(backupFilePath, backupFilePath.replace('.tmp', ''));
     } catch (error) {
-      this.logger.error('Database Backup Failure', error);
+      this.logger.error(`Database Backup Failure: ${error}`);
       await this.storageRepository
         .unlink(backupFilePath)
-        .catch((error) => this.logger.error('Failed to delete failed backup file', error));
+        .catch((error) => this.logger.error(`Failed to delete failed backup file: ${error}`));
       throw error;
     }
 

server/src/services/library.service.ts

@@ -245,7 +245,7 @@ export class LibraryService extends BaseService {
       job.paths.map((path) =>
         this.processEntity(path, library.ownerId, job.libraryId)
           .then((asset) => assetImports.push(asset))
-          .catch((error: any) => this.logger.error(`Error processing ${path} for library ${job.libraryId}`, error)),
+          .catch((error: any) => this.logger.error(`Error processing ${path} for library ${job.libraryId}: ${error}`)),
       ),
     );
 

server/src/services/memory.service.ts

@@ -40,7 +40,7 @@ export class MemoryService extends BaseService {
         try {
           await Promise.all(users.map((owner, i) => this.createOnThisDayMemories(owner.id, usersIds[i], target)));
         } catch (error) {
-          this.logger.error(`Failed to create memories for ${target.toISO()}`, error);
+          this.logger.error(`Failed to create memories for ${target.toISO()}: ${error}`);
         }
         // update system metadata even when there is an error to minimize the chance of duplicates
         await this.systemMetadataRepository.set(SystemMetadataKey.MemoriesState, {

server/src/services/storage-template.service.ts

@@ -338,7 +338,7 @@ export class StorageTemplateService extends BaseService {
 
       return destination;
     } catch (error: any) {
-      this.logger.error(`Unable to get template path for ${filename}`, error);
+      this.logger.error(`Unable to get template path for ${filename}: ${error}`);
       return asset.originalPath;
     }
   }

server/src/services/version.service.ts

@@ -95,7 +95,7 @@ export class VersionService extends BaseService {
         this.eventRepository.clientBroadcast('on_new_release', asNotification(metadata));
       }
     } catch (error: Error | any) {
-      this.logger.warn(`Unable to run version check: ${error}`, error?.stack);
+      this.logger.warn(`Unable to run version check: ${error}\n${error?.stack}`);
       return JobStatus.Failed;
     }
 

server/src/utils/file.ts

@@ -73,7 +73,7 @@ export const sendFile = async (
 
     // log non-http errors
     if (error instanceof HttpException === false) {
-      logger.error(`Unable to send file: ${error.name}`, error.stack);
+      logger.error(`Unable to send file: ${error}`, error.stack);
     }
 
     res.header('Cache-Control', 'none');

web/src/lib/components/timeline/Timeline.svelte

@@ -33,7 +33,7 @@
   import { deleteAssets, updateStackedAssetInTimeline, updateUnstackedAssetInTimeline } from '$lib/utils/actions';
   import { archiveAssets, cancelMultiselect, selectAllAssets, stackAssets } from '$lib/utils/asset-utils';
   import { navigate } from '$lib/utils/navigation';
-  import { getSegmentIdentifier, getTimes, toTimelineAsset, type ScrubberListener, type TimelineYearMonth } from '$lib/utils/timeline-util';
+  import { getTimes, toTimelineAsset, type ScrubberListener, type TimelineYearMonth } from '$lib/utils/timeline-util';
   import { AssetVisibility, getAssetInfo, type AlbumResponseDto, type PersonResponseDto } from '@immich/sdk';
   import { modalManager } from '@immich/ui';
   import { DateTime } from 'luxon';
@@ -670,7 +670,7 @@
           break;
         }
         if (started) {
-          await timelineManager.loadSegment(monthGroup.identifier);
+          await timelineManager.loadMonthGroup(monthGroup.yearMonth);
           for (const asset of monthGroup.assetsIterator()) {
             if (deselect) {
               assetInteraction.removeAssetFromMultiselectGroup(asset.id);
@@ -811,7 +811,7 @@
   $effect(() => {
     if ($showAssetViewer) {
       const { localDateTime } = getTimes($viewingAsset.fileCreatedAt, DateTime.local().offset / 60);
-      void timelineManager.loadSegment(getSegmentIdentifier({ year: localDateTime.year, month: localDateTime.month }));
+      void timelineManager.loadMonthGroup({ year: localDateTime.year, month: localDateTime.month });
     }
   });
 </script>

web/src/lib/managers/timeline-manager/PhotostreamManager.svelte.ts

@@ -1,293 +0,0 @@
-import { updateIntersectionMonthGroup } from '$lib/managers/timeline-manager/internal/intersection-support.svelte';
-import { updateGeometry } from '$lib/managers/timeline-manager/internal/layout-support.svelte';
-import { CancellableTask } from '$lib/utils/cancellable-task';
-import { clamp, debounce } from 'lodash-es';
-
-import type { PhotostreamSegment, SegmentIdentifier } from '$lib/managers/timeline-manager/PhotostreamSegment.svelte';
-import type { MonthGroup } from '$lib/managers/timeline-manager/month-group.svelte';
-import type { TimelineManagerLayoutOptions, TimelineManagerOptions, Viewport } from './types';
-
-export abstract class PhotostreamManager {
-  isInitialized = $state(false);
-  topSectionHeight = $state(0);
-  bottomSectionHeight = $state(60);
-  abstract get months(): PhotostreamSegment[];
-  timelineHeight = $derived.by(
-    () => this.months.reduce((accumulator, b) => accumulator + b.height, 0) + this.topSectionHeight,
-  );
-  assetCount = $derived.by(() => this.months.reduce((accumulator, b) => accumulator + b.assetsCount, 0));
-
-  topIntersectingMonthGroup: PhotostreamSegment | undefined = $state();
-
-  visibleWindow = $derived.by(() => ({
-    top: this.#scrollTop,
-    bottom: this.#scrollTop + this.viewportHeight,
-  }));
-
-  protected initTask = new CancellableTask(
-    () => (this.isInitialized = true),
-    () => (this.isInitialized = false),
-    () => void 0,
-  );
-
-  protected options: TimelineManagerOptions = {};
-
-  #viewportHeight = $state(0);
-  #viewportWidth = $state(0);
-  #scrollTop = $state(0);
-
-  #rowHeight = $state(235);
-  #headerHeight = $state(48);
-  #gap = $state(12);
-
-  #scrolling = $state(false);
-  #suspendTransitions = $state(false);
-  #resetScrolling = debounce(() => (this.#scrolling = false), 1000);
-  #resetSuspendTransitions = debounce(() => (this.suspendTransitions = false), 1000);
-  scrollCompensation: {
-    heightDelta: number | undefined;
-    scrollTop: number | undefined;
-    monthGroup: PhotostreamSegment | undefined;
-  } = $state({
-    heightDelta: 0,
-    scrollTop: 0,
-    monthGroup: undefined,
-  });
-
-  constructor() {}
-
-  setLayoutOptions({ headerHeight = 48, rowHeight = 235, gap = 12 }: TimelineManagerLayoutOptions) {
-    let changed = false;
-    changed ||= this.#setHeaderHeight(headerHeight);
-    changed ||= this.#setGap(gap);
-    changed ||= this.#setRowHeight(rowHeight);
-    if (changed) {
-      this.refreshLayout();
-    }
-  }
-
-  #setHeaderHeight(value: number) {
-    if (this.#headerHeight == value) {
-      return false;
-    }
-    this.#headerHeight = value;
-    return true;
-  }
-
-  get headerHeight() {
-    return this.#headerHeight;
-  }
-
-  #setGap(value: number) {
-    if (this.#gap == value) {
-      return false;
-    }
-    this.#gap = value;
-    return true;
-  }
-
-  get gap() {
-    return this.#gap;
-  }
-
-  #setRowHeight(value: number) {
-    if (this.#rowHeight == value) {
-      return false;
-    }
-    this.#rowHeight = value;
-    return true;
-  }
-
-  get rowHeight() {
-    return this.#rowHeight;
-  }
-
-  set scrolling(value: boolean) {
-    this.#scrolling = value;
-    if (value) {
-      this.suspendTransitions = true;
-      this.#resetScrolling();
-    }
-  }
-
-  get scrolling() {
-    return this.#scrolling;
-  }
-
-  set suspendTransitions(value: boolean) {
-    this.#suspendTransitions = value;
-    if (value) {
-      this.#resetSuspendTransitions();
-    }
-  }
-
-  get suspendTransitions() {
-    return this.#suspendTransitions;
-  }
-
-  set viewportWidth(value: number) {
-    const changed = value !== this.#viewportWidth;
-    this.#viewportWidth = value;
-    this.suspendTransitions = true;
-    void this.updateViewportGeometry(changed);
-  }
-
-  get viewportWidth() {
-    return this.#viewportWidth;
-  }
-
-  set viewportHeight(value: number) {
-    this.#viewportHeight = value;
-    this.#suspendTransitions = true;
-    void this.updateViewportGeometry(false);
-  }
-
-  get viewportHeight() {
-    return this.#viewportHeight;
-  }
-
-  updateSlidingWindow(scrollTop: number) {
-    if (this.#scrollTop !== scrollTop) {
-      this.#scrollTop = scrollTop;
-      this.updateIntersections();
-    }
-  }
-
-  clearScrollCompensation() {
-    this.scrollCompensation = {
-      heightDelta: undefined,
-      scrollTop: undefined,
-      monthGroup: undefined,
-    };
-  }
-
-  updateIntersections() {
-    if (!this.isInitialized || this.visibleWindow.bottom === this.visibleWindow.top) {
-      return;
-    }
-    let topIntersectingMonthGroup = undefined;
-    for (const month of this.months) {
-      updateIntersectionMonthGroup(this, month);
-      if (!topIntersectingMonthGroup && month.actuallyIntersecting) {
-        topIntersectingMonthGroup = month;
-      }
-    }
-    if (topIntersectingMonthGroup !== undefined && this.topIntersectingMonthGroup !== topIntersectingMonthGroup) {
-      this.topIntersectingMonthGroup = topIntersectingMonthGroup;
-    }
-    for (const month of this.months) {
-      if (month === this.topIntersectingMonthGroup) {
-        this.topIntersectingMonthGroup.percent = clamp(
-          (this.visibleWindow.top - this.topIntersectingMonthGroup.top) / this.topIntersectingMonthGroup.height,
-          0,
-          1,
-        );
-      } else {
-        month.percent = 0;
-      }
-    }
-  }
-
-  protected async init(options: TimelineManagerOptions) {
-    this.isInitialized = true;
-    // this.months = [];
-
-    await this.initTask.execute(async () => undefined, true);
-  }
-
-  public destroy() {
-    this.isInitialized = false;
-  }
-
-  async updateViewport(viewport: Viewport) {
-    if (viewport.height === 0 && viewport.width === 0) {
-      return;
-    }
-
-    if (this.viewportHeight === viewport.height && this.viewportWidth === viewport.width) {
-      return;
-    }
-
-    if (!this.initTask.executed) {
-      await (this.initTask.loading ? this.initTask.waitUntilCompletion() : this.init(this.options));
-    }
-
-    const changedWidth = viewport.width !== this.viewportWidth;
-    this.viewportHeight = viewport.height;
-    this.viewportWidth = viewport.width;
-    this.updateViewportGeometry(changedWidth);
-  }
-
-  protected updateViewportGeometry(changedWidth: boolean) {
-    if (!this.isInitialized) {
-      return;
-    }
-    if (this.viewportWidth === 0 || this.viewportHeight === 0) {
-      return;
-    }
-    for (const month of this.months) {
-      updateGeometry(this, month, { invalidateHeight: changedWidth });
-    }
-    this.updateIntersections();
-  }
-
-  createLayoutOptions() {
-    const viewportWidth = this.viewportWidth;
-
-    return {
-      spacing: 2,
-      heightTolerance: 0.15,
-      rowHeight: this.#rowHeight,
-      rowWidth: Math.floor(viewportWidth),
-    };
-  }
-
-  async loadSegment(identifier: SegmentIdentifier, options?: { cancelable: boolean }): Promise<void> {
-    let cancelable = true;
-    if (options) {
-      cancelable = options.cancelable;
-    }
-    const segment = this.getSegmentByIdentifier(identifier);
-    if (!segment) {
-      return;
-    }
-
-    if (segment.loader?.executed) {
-      return;
-    }
-
-    const result = await segment.loader?.execute(async (signal: AbortSignal) => {
-      await this.fetchSegment(segment, signal);
-    }, cancelable);
-    if (result === 'LOADED') {
-      updateIntersectionMonthGroup(this, segment);
-    }
-  }
-
-  getSegmentMatcher(identifier: SegmentIdentifier) {
-    return (segment: MonthGroup) => {
-      return identifier;
-    };
-  }
-  getSegmentByIdentifier(identifier: SegmentIdentifier) {
-    return this.months.find((segment) => identifier.matches(segment));
-  }
-
-  protected abstract fetchSegment(segment: PhotostreamSegment, signal: AbortSignal): Promise<void>;
-
-  refreshLayout() {
-    for (const month of this.months) {
-      updateGeometry(this, month, { invalidateHeight: true });
-    }
-    this.updateIntersections();
-  }
-
-  getMaxScrollPercent() {
-    const totalHeight = this.timelineHeight + this.bottomSectionHeight + this.topSectionHeight;
-    return (totalHeight - this.viewportHeight) / totalHeight;
-  }
-
-  getMaxScroll() {
-    return this.topSectionHeight + this.bottomSectionHeight + (this.timelineHeight - this.viewportHeight);
-  }
-}

web/src/lib/managers/timeline-manager/PhotostreamSegment.svelte.ts

@@ -1,133 +0,0 @@
-import { CancellableTask } from '$lib/utils/cancellable-task';
-import { handleError } from '$lib/utils/handle-error';
-import { t } from 'svelte-i18n';
-import { get } from 'svelte/store';
-
-import type { PhotostreamManager } from '$lib/managers/timeline-manager/PhotostreamManager.svelte';
-import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
-
-export type SegmentIdentifier = {
-  matches(segment: PhotostreamSegment): boolean;
-};
-export abstract class PhotostreamSegment {
-  #intersecting = $state(false);
-  actuallyIntersecting = $state(false);
-  #isLoaded = $state(false);
-
-  #height = $state(0);
-  #top = $state(0);
-
-  initialCount = $state(0);
-  percent = $state(0);
-  assetsCount = $derived(this.isLoaded ? this.getAssets().length : this.initialCount);
-  loader = new CancellableTask(
-    () => this.markLoaded(),
-    () => this.markCanceled,
-    () => this.handleLoadError,
-  );
-  isHeightActual = $state(false);
-
-  abstract get timelineManager(): PhotostreamManager;
-
-  abstract get identifier(): SegmentIdentifier;
-
-  get isLoaded() {
-    return this.#isLoaded;
-  }
-
-  protected markLoaded() {
-    this.#isLoaded = true;
-  }
-
-  protected markCanceled() {
-    this.#isLoaded = false;
-  }
-
-  set intersecting(newValue: boolean) {
-    const old = this.#intersecting;
-    if (old === newValue) {
-      return;
-    }
-    this.#intersecting = newValue;
-    if (newValue) {
-      this.load();
-    } else {
-      this.cancel();
-    }
-  }
-
-  get intersecting() {
-    return this.#intersecting;
-  }
-
-  abstract load(): Promise<void>;
-
-  abstract getAssets(): TimelineAsset[];
-
-  set height(height: number) {
-    if (this.#height === height) {
-      return;
-    }
-    const { timelineManager: store, percent } = this;
-    const index = store.months.indexOf(this);
-    const heightDelta = height - this.#height;
-    this.#height = height;
-    const prevMonthGroup = store.months[index - 1];
-    if (prevMonthGroup) {
-      const newTop = prevMonthGroup.#top + prevMonthGroup.#height;
-      if (this.#top !== newTop) {
-        this.#top = newTop;
-      }
-    }
-    for (let cursor = index + 1; cursor < store.months.length; cursor++) {
-      const monthGroup = this.timelineManager.months[cursor];
-      const newTop = monthGroup.#top + heightDelta;
-      if (monthGroup.#top !== newTop) {
-        monthGroup.#top = newTop;
-      }
-    }
-    if (store.topIntersectingMonthGroup) {
-      const currentIndex = store.months.indexOf(store.topIntersectingMonthGroup);
-      if (currentIndex > 0) {
-        if (index < currentIndex) {
-          store.scrollCompensation = {
-            heightDelta,
-            scrollTop: undefined,
-            monthGroup: this,
-          };
-        } else if (percent > 0) {
-          const top = this.top + height * percent;
-          store.scrollCompensation = {
-            heightDelta: undefined,
-            scrollTop: top,
-            monthGroup: this,
-          };
-        }
-      }
-    }
-  }
-
-  get height() {
-    return this.#height;
-  }
-
-  get top(): number {
-    return this.#top + this.timelineManager.topSectionHeight;
-  }
-
-  protected handleLoadError(error: unknown) {
-    const _$t = get(t);
-    handleError(error, _$t('errors.failed_to_load_assets'));
-  }
-
-  cancel() {
-    this.loader?.cancel();
-  }
-
-  layout(_noDefer: boolean) {}
-
-  updateIntersection({ intersecting, actuallyIntersecting }: { intersecting: boolean; actuallyIntersecting: boolean }) {
-    this.intersecting = intersecting;
-    this.actuallyIntersecting = actuallyIntersecting;
-  }
-}

web/src/lib/managers/timeline-manager/internal/intersection-support.svelte.ts

@@ -1,24 +1,27 @@
-import type { PhotostreamManager } from '$lib/managers/timeline-manager/PhotostreamManager.svelte';
-import type { PhotostreamSegment } from '$lib/managers/timeline-manager/PhotostreamSegment.svelte';
 import { TUNABLES } from '$lib/utils/tunables';
+import type { MonthGroup } from '../month-group.svelte';
 import type { TimelineManager } from '../timeline-manager.svelte';
 
 const {
   TIMELINE: { INTERSECTION_EXPAND_TOP, INTERSECTION_EXPAND_BOTTOM },
 } = TUNABLES;
 
-export function updateIntersectionMonthGroup(timelineManager: PhotostreamManager, month: PhotostreamSegment) {
-  const actuallyIntersecting = calculateSegmentIntersecting(timelineManager, month, 0, 0);
+export function updateIntersectionMonthGroup(timelineManager: TimelineManager, month: MonthGroup) {
+  const actuallyIntersecting = calculateMonthGroupIntersecting(timelineManager, month, 0, 0);
   let preIntersecting = false;
   if (!actuallyIntersecting) {
-    preIntersecting = calculateSegmentIntersecting(
+    preIntersecting = calculateMonthGroupIntersecting(
       timelineManager,
       month,
       INTERSECTION_EXPAND_TOP,
       INTERSECTION_EXPAND_BOTTOM,
     );
   }
-  month.updateIntersection({ intersecting: actuallyIntersecting || preIntersecting, actuallyIntersecting });
+  month.intersecting = actuallyIntersecting || preIntersecting;
+  month.actuallyIntersecting = actuallyIntersecting;
+  if (preIntersecting || actuallyIntersecting) {
+    timelineManager.clearDeferredLayout(month);
+  }
 }
 
 /**
@@ -37,9 +40,9 @@ export function isIntersecting(regionTop: number, regionBottom: number, windowTo
   );
 }
 
-export function calculateSegmentIntersecting(
-  timelineManager: PhotostreamManager,
-  monthGroup: PhotostreamSegment,
+export function calculateMonthGroupIntersecting(
+  timelineManager: TimelineManager,
+  monthGroup: MonthGroup,
   expandTop: number,
   expandBottom: number,
 ) {

web/src/lib/managers/timeline-manager/internal/layout-support.svelte.ts

@@ -1,13 +1,8 @@
-import type { PhotostreamManager } from '$lib/managers/timeline-manager/PhotostreamManager.svelte';
-import type { PhotostreamSegment } from '$lib/managers/timeline-manager/PhotostreamSegment.svelte';
 import type { MonthGroup } from '../month-group.svelte';
+import type { TimelineManager } from '../timeline-manager.svelte';
 import type { UpdateGeometryOptions } from '../types';
 
-export function updateGeometry(
-  timelineManager: PhotostreamManager,
-  month: PhotostreamSegment,
-  options: UpdateGeometryOptions,
-) {
+export function updateGeometry(timelineManager: TimelineManager, month: MonthGroup, options: UpdateGeometryOptions) {
   const { invalidateHeight, noDefer = false } = options;
   if (invalidateHeight) {
     month.isHeightActual = false;
@@ -22,10 +17,10 @@ export function updateGeometry(
     }
     return;
   }
-  month.layout(noDefer);
+  layoutMonthGroup(timelineManager, month, noDefer);
 }
 
-export function layoutMonthGroup(timelineManager: PhotostreamManager, month: MonthGroup, noDefer: boolean = false) {
+export function layoutMonthGroup(timelineManager: TimelineManager, month: MonthGroup, noDefer: boolean = false) {
   let cumulativeHeight = 0;
   let cumulativeWidth = 0;
   let currentRowHeight = 0;

web/src/lib/managers/timeline-manager/internal/operations-support.svelte.ts

@@ -25,7 +25,8 @@ export function addAssetsToMonthGroups(
     let month = getMonthGroupByDate(timelineManager, asset.localDateTime);
 
     if (!month) {
-      month = new MonthGroup(timelineManager, asset.localDateTime, 1, true, options.order);
+      month = new MonthGroup(timelineManager, asset.localDateTime, 1, options.order);
+      month.isLoaded = true;
       timelineManager.months.push(month);
     }
 

web/src/lib/managers/timeline-manager/month-group.svelte.ts

@@ -1,20 +1,22 @@
 import { AssetOrder, type TimeBucketAssetResponseDto } from '@immich/sdk';
 
+import { CancellableTask } from '$lib/utils/cancellable-task';
+import { handleError } from '$lib/utils/handle-error';
 import {
   formatGroupTitle,
   formatMonthGroupTitle,
   fromTimelinePlainDate,
   fromTimelinePlainDateTime,
   fromTimelinePlainYearMonth,
-  getSegmentIdentifier,
   getTimes,
   setDifference,
   type TimelineDateTime,
   type TimelineYearMonth,
 } from '$lib/utils/timeline-util';
 
-import { layoutMonthGroup, updateGeometry } from '$lib/managers/timeline-manager/internal/layout-support.svelte';
-import { PhotostreamSegment, type SegmentIdentifier } from '$lib/managers/timeline-manager/PhotostreamSegment.svelte';
+import { t } from 'svelte-i18n';
+import { get } from 'svelte/store';
+
 import { SvelteSet } from 'svelte/reactivity';
 import { DayGroup } from './day-group.svelte';
 import { GroupInsertionCache } from './group-insertion-cache.svelte';
@@ -22,52 +24,73 @@ import type { TimelineManager } from './timeline-manager.svelte';
 import type { AssetDescriptor, AssetOperation, Direction, MoveAsset, TimelineAsset } from './types';
 import { ViewerAsset } from './viewer-asset.svelte';
 
-export class MonthGroup extends PhotostreamSegment {
+export class MonthGroup {
+  #intersecting: boolean = $state(false);
+  actuallyIntersecting: boolean = $state(false);
+  isLoaded: boolean = $state(false);
   dayGroups: DayGroup[] = $state([]);
+  readonly timelineManager: TimelineManager;
 
+  #height: number = $state(0);
+  #top: number = $state(0);
+
+  #initialCount: number = 0;
   #sortOrder: AssetOrder = AssetOrder.Desc;
-  #yearMonth: TimelineYearMonth;
-  #identifier: SegmentIdentifier;
-  #timelineManager: TimelineManager;
+  percent: number = $state(0);
+
+  assetsCount: number = $derived(
+    this.isLoaded
+      ? this.dayGroups.reduce((accumulator, g) => accumulator + g.viewerAssets.length, 0)
+      : this.#initialCount,
+  );
+  loader: CancellableTask | undefined;
+  isHeightActual: boolean = $state(false);
 
   readonly monthGroupTitle: string;
+  readonly yearMonth: TimelineYearMonth;
 
   constructor(
-    timelineManager: TimelineManager,
+    store: TimelineManager,
     yearMonth: TimelineYearMonth,
     initialCount: number,
-    loaded: boolean,
     order: AssetOrder = AssetOrder.Desc,
   ) {
-    super();
-    this.initialCount = initialCount;
-    this.#yearMonth = yearMonth;
-    this.#identifier = getSegmentIdentifier(yearMonth);
-    this.#timelineManager = timelineManager;
+    this.timelineManager = store;
+    this.#initialCount = initialCount;
     this.#sortOrder = order;
+
+    this.yearMonth = yearMonth;
     this.monthGroupTitle = formatMonthGroupTitle(fromTimelinePlainYearMonth(yearMonth));
-    if (loaded) {
-      this.markLoaded();
+
+    this.loader = new CancellableTask(
+      () => {
+        this.isLoaded = true;
+      },
+      () => {
+        this.dayGroups = [];
+        this.isLoaded = false;
+      },
+      this.#handleLoadError,
+    );
+  }
+
+  set intersecting(newValue: boolean) {
+    const old = this.#intersecting;
+    if (old === newValue) {
+      return;
+    }
+    this.#intersecting = newValue;
+    if (newValue) {
+      void this.timelineManager.loadMonthGroup(this.yearMonth);
+    } else {
+      this.cancel();
     }
   }
 
-  get identifier() {
-    return this.#identifier;
+  get intersecting() {
+    return this.#intersecting;
   }
 
-  get timelineManager() {
-    return this.#timelineManager;
-  }
-
-  get yearMonth() {
-    return this.#yearMonth;
-  }
-
-  load(): Promise<void> {
-    return this.timelineManager.loadSegment(this.#identifier);
-  }
-
-
   get lastDayGroup() {
     return this.dayGroups.at(-1);
   }
@@ -224,6 +247,61 @@ export class MonthGroup extends PhotostreamSegment {
     return year + '-' + month;
   }
 
+  set height(height: number) {
+    if (this.#height === height) {
+      return;
+    }
+    const { timelineManager: store, percent } = this;
+    const index = store.months.indexOf(this);
+    const heightDelta = height - this.#height;
+    this.#height = height;
+    const prevMonthGroup = store.months[index - 1];
+    if (prevMonthGroup) {
+      const newTop = prevMonthGroup.#top + prevMonthGroup.#height;
+      if (this.#top !== newTop) {
+        this.#top = newTop;
+      }
+    }
+    for (let cursor = index + 1; cursor < store.months.length; cursor++) {
+      const monthGroup = this.timelineManager.months[cursor];
+      const newTop = monthGroup.#top + heightDelta;
+      if (monthGroup.#top !== newTop) {
+        monthGroup.#top = newTop;
+      }
+    }
+    if (store.topIntersectingMonthGroup) {
+      const currentIndex = store.months.indexOf(store.topIntersectingMonthGroup);
+      if (currentIndex > 0) {
+        if (index < currentIndex) {
+          store.scrollCompensation = {
+            heightDelta,
+            scrollTop: undefined,
+            monthGroup: this,
+          };
+        } else if (percent > 0) {
+          const top = this.top + height * percent;
+          store.scrollCompensation = {
+            heightDelta: undefined,
+            scrollTop: top,
+            monthGroup: this,
+          };
+        }
+      }
+    }
+  }
+
+  get height() {
+    return this.#height;
+  }
+
+  get top(): number {
+    return this.#top + this.timelineManager.topSectionHeight;
+  }
+
+  #handleLoadError(error: unknown) {
+    const _$t = get(t);
+    handleError(error, _$t('errors.failed_to_load_assets'));
+  }
 
   findDayGroupForAsset(asset: TimelineAsset) {
     for (const group of this.dayGroups) {
@@ -238,7 +316,7 @@ export class MonthGroup extends PhotostreamSegment {
   }
 
   findAssetAbsolutePosition(assetId: string) {
-    this.#clearDeferredLayout();
+    this.timelineManager.clearDeferredLayout(this);
     for (const group of this.dayGroups) {
       const viewerAsset = group.viewerAssets.find((viewAsset) => viewAsset.id === assetId);
       if (viewerAsset) {
@@ -296,26 +374,4 @@ export class MonthGroup extends PhotostreamSegment {
   cancel() {
     this.loader?.cancel();
   }
-
-  layout(noDefer: boolean) {
-    layoutMonthGroup(this.timelineManager, this, noDefer);
-  }
-
-  #clearDeferredLayout() {
-    const hasDeferred = this.dayGroups.some((group) => group.deferredLayout);
-    if (hasDeferred) {
-      updateGeometry(this.timelineManager, this, { invalidateHeight: true, noDefer: true });
-      for (const group of this.dayGroups) {
-        group.deferredLayout = false;
-      }
-    }
-  }
-
-  updateIntersection({ intersecting, actuallyIntersecting }: { intersecting: boolean; actuallyIntersecting: boolean }) {
-    this.intersecting = intersecting;
-    this.actuallyIntersecting = actuallyIntersecting;
-    if (intersecting) {
-      this.#clearDeferredLayout();
-    }
-  }
 }

web/src/lib/managers/timeline-manager/timeline-manager.svelte.spec.ts

@@ -1,7 +1,7 @@
 import { sdkMock } from '$lib/__mocks__/sdk.mock';
 import { getMonthGroupByDate } from '$lib/managers/timeline-manager/internal/search-support.svelte';
 import { AbortError } from '$lib/utils';
-import { fromISODateTimeUTCToObject, getSegmentIdentifier } from '$lib/utils/timeline-util';
+import { fromISODateTimeUTCToObject } from '$lib/utils/timeline-util';
 import { type AssetResponseDto, type TimeBucketAssetResponseDto } from '@immich/sdk';
 import { timelineAssetFactory, toResponseDto } from '@test-data/factories/asset-factory';
 import { TimelineManager } from './timeline-manager.svelte';
@@ -92,7 +92,7 @@ describe('TimelineManager', () => {
     });
   });
 
-  describe('loadSegment', () => {
+  describe('loadMonthGroup', () => {
     let timelineManager: TimelineManager;
     const bucketAssets: Record<string, TimelineAsset[]> = {
       '2024-01-03T00:00:00.000Z': timelineAssetFactory.buildList(1).map((asset) =>
@@ -129,46 +129,46 @@ describe('TimelineManager', () => {
 
     it('loads a month', async () => {
       expect(getMonthGroupByDate(timelineManager, { year: 2024, month: 1 })?.getAssets().length).toEqual(0);
-      await timelineManager.loadSegment(getSegmentIdentifier({ year: 2024, month: 1 }));
+      await timelineManager.loadMonthGroup({ year: 2024, month: 1 });
       expect(sdkMock.getTimeBucket).toBeCalledTimes(1);
       expect(getMonthGroupByDate(timelineManager, { year: 2024, month: 1 })?.getAssets().length).toEqual(3);
     });
 
     it('ignores invalid months', async () => {
-      await timelineManager.loadSegment(getSegmentIdentifier({ year: 2023, month: 1 }));
+      await timelineManager.loadMonthGroup({ year: 2023, month: 1 });
       expect(sdkMock.getTimeBucket).toBeCalledTimes(0);
     });
 
     it('cancels month loading', async () => {
       const month = getMonthGroupByDate(timelineManager, { year: 2024, month: 1 })!;
-      void timelineManager.loadSegment(getSegmentIdentifier({ year: 2024, month: 1 }));
+      void timelineManager.loadMonthGroup({ year: 2024, month: 1 });
       const abortSpy = vi.spyOn(month!.loader!.cancelToken!, 'abort');
       month?.cancel();
       expect(abortSpy).toBeCalledTimes(1);
-      await timelineManager.loadSegment(getSegmentIdentifier({ year: 2024, month: 1 }));
+      await timelineManager.loadMonthGroup({ year: 2024, month: 1 });
       expect(getMonthGroupByDate(timelineManager, { year: 2024, month: 1 })?.getAssets().length).toEqual(3);
     });
 
     it('prevents loading months multiple times', async () => {
       await Promise.all([
-        timelineManager.loadSegment(getSegmentIdentifier({ year: 2024, month: 1 })),
-        timelineManager.loadSegment(getSegmentIdentifier({ year: 2024, month: 1 })),
+        timelineManager.loadMonthGroup({ year: 2024, month: 1 }),
+        timelineManager.loadMonthGroup({ year: 2024, month: 1 }),
       ]);
       expect(sdkMock.getTimeBucket).toBeCalledTimes(1);
 
-      await timelineManager.loadSegment(getSegmentIdentifier({ year: 2024, month: 1 }));
+      await timelineManager.loadMonthGroup({ year: 2024, month: 1 });
       expect(sdkMock.getTimeBucket).toBeCalledTimes(1);
     });
 
     it('allows loading a canceled month', async () => {
       const month = getMonthGroupByDate(timelineManager, { year: 2024, month: 1 })!;
-      const loadPromise = timelineManager.loadSegment(getSegmentIdentifier({ year: 2024, month: 1 }));
+      const loadPromise = timelineManager.loadMonthGroup({ year: 2024, month: 1 });
 
       month.cancel();
       await loadPromise;
       expect(month?.getAssets().length).toEqual(0);
 
-      await timelineManager.loadSegment(getSegmentIdentifier({ year: 2024, month: 1 }));
+      await timelineManager.loadMonthGroup({ year: 2024, month: 1 });
       expect(month!.getAssets().length).toEqual(3);
     });
   });
@@ -477,7 +477,7 @@ describe('TimelineManager', () => {
     });
 
     it('returns previous assetId', async () => {
-      await timelineManager.loadSegment(getSegmentIdentifier({ year: 2024, month: 1 }));
+      await timelineManager.loadMonthGroup({ year: 2024, month: 1 });
       const month = getMonthGroupByDate(timelineManager, { year: 2024, month: 1 });
 
       const a = month!.getAssets()[0];
@@ -487,8 +487,8 @@ describe('TimelineManager', () => {
     });
 
     it('returns previous assetId spanning multiple months', async () => {
-      await timelineManager.loadSegment(getSegmentIdentifier({ year: 2024, month: 2 }));
-      await timelineManager.loadSegment(getSegmentIdentifier({ year: 2024, month: 3 }));
+      await timelineManager.loadMonthGroup({ year: 2024, month: 2 });
+      await timelineManager.loadMonthGroup({ year: 2024, month: 3 });
 
       const month = getMonthGroupByDate(timelineManager, { year: 2024, month: 2 });
       const previousMonth = getMonthGroupByDate(timelineManager, { year: 2024, month: 3 });
@@ -499,23 +499,23 @@ describe('TimelineManager', () => {
     });
 
     it('loads previous month', async () => {
-      await timelineManager.loadSegment(getSegmentIdentifier({ year: 2024, month: 2 }));
+      await timelineManager.loadMonthGroup({ year: 2024, month: 2 });
       const month = getMonthGroupByDate(timelineManager, { year: 2024, month: 2 });
       const previousMonth = getMonthGroupByDate(timelineManager, { year: 2024, month: 3 });
       const a = month!.getFirstAsset();
       const b = previousMonth!.getFirstAsset();
-      const loadSegmentSpy = vi.spyOn(month!.loader!, 'execute');
+      const loadMonthGroupSpy = vi.spyOn(month!.loader!, 'execute');
       const previousMonthSpy = vi.spyOn(previousMonth!.loader!, 'execute');
       const previous = await timelineManager.getLaterAsset(a);
       expect(previous).toEqual(b);
-      expect(loadSegmentSpy).toBeCalledTimes(0);
+      expect(loadMonthGroupSpy).toBeCalledTimes(0);
       expect(previousMonthSpy).toBeCalledTimes(0);
     });
 
     it('skips removed assets', async () => {
-      await timelineManager.loadSegment(getSegmentIdentifier({ year: 2024, month: 1 }));
-      await timelineManager.loadSegment(getSegmentIdentifier({ year: 2024, month: 2 }));
-      await timelineManager.loadSegment(getSegmentIdentifier({ year: 2024, month: 3 }));
+      await timelineManager.loadMonthGroup({ year: 2024, month: 1 });
+      await timelineManager.loadMonthGroup({ year: 2024, month: 2 });
+      await timelineManager.loadMonthGroup({ year: 2024, month: 3 });
 
       const [assetOne, assetTwo, assetThree] = await getAssets(timelineManager);
       timelineManager.removeAssets([assetTwo.id]);
@@ -523,7 +523,7 @@ describe('TimelineManager', () => {
     });
 
     it('returns null when no more assets', async () => {
-      await timelineManager.loadSegment(getSegmentIdentifier({ year: 2024, month: 3 }));
+      await timelineManager.loadMonthGroup({ year: 2024, month: 3 });
       expect(await timelineManager.getLaterAsset(timelineManager.months[0].getFirstAsset())).toBeUndefined();
     });
   });

web/src/lib/managers/timeline-manager/timeline-manager.svelte.ts

@@ -3,16 +3,12 @@ import { AssetOrder, getAssetInfo, getTimeBuckets } from '@immich/sdk';
 import { authManager } from '$lib/managers/auth-manager.svelte';
 
 import { CancellableTask } from '$lib/utils/cancellable-task';
-import {
-  getSegmentIdentifier,
-  toTimelineAsset,
-  type TimelineDateTime,
-  type TimelineYearMonth,
-} from '$lib/utils/timeline-util';
+import { toTimelineAsset, type TimelineDateTime, type TimelineYearMonth } from '$lib/utils/timeline-util';
 
-import { isEqual } from 'lodash-es';
+import { clamp, debounce, isEqual } from 'lodash-es';
 import { SvelteDate, SvelteMap, SvelteSet } from 'svelte/reactivity';
 
+import { updateIntersectionMonthGroup } from '$lib/managers/timeline-manager/internal/intersection-support.svelte';
 import { updateGeometry } from '$lib/managers/timeline-manager/internal/layout-support.svelte';
 import { loadFromTimeBuckets } from '$lib/managers/timeline-manager/internal/load-support.svelte';
 import {
@@ -27,8 +23,6 @@ import {
   retrieveRange as retrieveRangeUtil,
 } from '$lib/managers/timeline-manager/internal/search-support.svelte';
 import { WebsocketSupport } from '$lib/managers/timeline-manager/internal/websocket-support.svelte';
-import { PhotostreamManager } from '$lib/managers/timeline-manager/PhotostreamManager.svelte';
-import { PhotostreamSegment } from '$lib/managers/timeline-manager/PhotostreamSegment.svelte';
 import { DayGroup } from './day-group.svelte';
 import { isMismatched, updateObject } from './internal/utils.svelte';
 import { MonthGroup } from './month-group.svelte';
@@ -38,14 +32,29 @@ import type {
   Direction,
   ScrubberMonth,
   TimelineAsset,
+  TimelineManagerLayoutOptions,
   TimelineManagerOptions,
+  Viewport,
 } from './types';
 
-export class TimelineManager extends PhotostreamManager {
+export class TimelineManager {
+  isInitialized = $state(false);
+  months: MonthGroup[] = $state([]);
+  topSectionHeight = $state(0);
+  timelineHeight = $derived(this.months.reduce((accumulator, b) => accumulator + b.height, 0) + this.topSectionHeight);
+  assetCount = $derived(this.months.reduce((accumulator, b) => accumulator + b.assetsCount, 0));
+
   albumAssets: Set<string> = new SvelteSet();
+
   scrubberMonths: ScrubberMonth[] = $state([]);
   scrubberTimelineHeight: number = $state(0);
-  #months: MonthGroup[] = $state([]);
+
+  topIntersectingMonthGroup: MonthGroup | undefined = $state();
+
+  visibleWindow = $derived.by(() => ({
+    top: this.#scrollTop,
+    bottom: this.#scrollTop + this.viewportHeight,
+  }));
 
   initTask = new CancellableTask(
     () => {
@@ -63,12 +72,121 @@ export class TimelineManager extends PhotostreamManager {
   );
 
   static #INIT_OPTIONS = {};
-
+  #viewportHeight = $state(0);
+  #viewportWidth = $state(0);
+  #scrollTop = $state(0);
   #websocketSupport: WebsocketSupport | undefined;
+
+  #rowHeight = $state(235);
+  #headerHeight = $state(48);
+  #gap = $state(12);
+
   #options: TimelineManagerOptions = TimelineManager.#INIT_OPTIONS;
 
-  get months() {
-    return this.#months;
+  #scrolling = $state(false);
+  #suspendTransitions = $state(false);
+  #resetScrolling = debounce(() => (this.#scrolling = false), 1000);
+  #resetSuspendTransitions = debounce(() => (this.suspendTransitions = false), 1000);
+  scrollCompensation: {
+    heightDelta: number | undefined;
+    scrollTop: number | undefined;
+    monthGroup: MonthGroup | undefined;
+  } = $state({
+    heightDelta: 0,
+    scrollTop: 0,
+    monthGroup: undefined,
+  });
+
+  constructor() {}
+
+  setLayoutOptions({ headerHeight = 48, rowHeight = 235, gap = 12 }: TimelineManagerLayoutOptions) {
+    let changed = false;
+    changed ||= this.#setHeaderHeight(headerHeight);
+    changed ||= this.#setGap(gap);
+    changed ||= this.#setRowHeight(rowHeight);
+    if (changed) {
+      this.refreshLayout();
+    }
+  }
+
+  #setHeaderHeight(value: number) {
+    if (this.#headerHeight == value) {
+      return false;
+    }
+    this.#headerHeight = value;
+    return true;
+  }
+
+  get headerHeight() {
+    return this.#headerHeight;
+  }
+
+  #setGap(value: number) {
+    if (this.#gap == value) {
+      return false;
+    }
+    this.#gap = value;
+    return true;
+  }
+
+  get gap() {
+    return this.#gap;
+  }
+
+  #setRowHeight(value: number) {
+    if (this.#rowHeight == value) {
+      return false;
+    }
+    this.#rowHeight = value;
+    return true;
+  }
+
+  get rowHeight() {
+    return this.#rowHeight;
+  }
+
+  set scrolling(value: boolean) {
+    this.#scrolling = value;
+    if (value) {
+      this.suspendTransitions = true;
+      this.#resetScrolling();
+    }
+  }
+
+  get scrolling() {
+    return this.#scrolling;
+  }
+
+  set suspendTransitions(value: boolean) {
+    this.#suspendTransitions = value;
+    if (value) {
+      this.#resetSuspendTransitions();
+    }
+  }
+
+  get suspendTransitions() {
+    return this.#suspendTransitions;
+  }
+
+  set viewportWidth(value: number) {
+    const changed = value !== this.#viewportWidth;
+    this.#viewportWidth = value;
+    this.suspendTransitions = true;
+    void this.#updateViewportGeometry(changed);
+  }
+
+  get viewportWidth() {
+    return this.#viewportWidth;
+  }
+
+  set viewportHeight(value: number) {
+    this.#viewportHeight = value;
+    this.#suspendTransitions = true;
+    void this.#updateViewportGeometry(false);
+  }
+
+  get viewportHeight() {
+    return this.#viewportHeight;
   }
 
   async *assetsIterator(options?: {
@@ -80,7 +198,7 @@ export class TimelineManager extends PhotostreamManager {
     const direction = options?.direction ?? 'earlier';
     let { startDayGroup, startAsset } = options ?? {};
     for (const monthGroup of this.monthGroupIterator({ direction, startMonthGroup: options?.startMonthGroup })) {
-      await this.loadSegment(monthGroup.identifier, { cancelable: false });
+      await this.loadMonthGroup(monthGroup.yearMonth, { cancelable: false });
       yield* monthGroup.assetsIterator({ startDayGroup, startAsset, direction });
       startDayGroup = startAsset = undefined;
     }
@@ -116,24 +234,75 @@ export class TimelineManager extends PhotostreamManager {
     this.#websocketSupport = undefined;
   }
 
+  updateSlidingWindow(scrollTop: number) {
+    if (this.#scrollTop !== scrollTop) {
+      this.#scrollTop = scrollTop;
+      this.updateIntersections();
+    }
+  }
+
+  clearScrollCompensation() {
+    this.scrollCompensation = {
+      heightDelta: undefined,
+      scrollTop: undefined,
+      monthGroup: undefined,
+    };
+  }
+
+  updateIntersections() {
+    if (!this.isInitialized || this.visibleWindow.bottom === this.visibleWindow.top) {
+      return;
+    }
+    let topIntersectingMonthGroup = undefined;
+    for (const month of this.months) {
+      updateIntersectionMonthGroup(this, month);
+      if (!topIntersectingMonthGroup && month.actuallyIntersecting) {
+        topIntersectingMonthGroup = month;
+      }
+    }
+    if (topIntersectingMonthGroup !== undefined && this.topIntersectingMonthGroup !== topIntersectingMonthGroup) {
+      this.topIntersectingMonthGroup = topIntersectingMonthGroup;
+    }
+    for (const month of this.months) {
+      if (month === this.topIntersectingMonthGroup) {
+        this.topIntersectingMonthGroup.percent = clamp(
+          (this.visibleWindow.top - this.topIntersectingMonthGroup.top) / this.topIntersectingMonthGroup.height,
+          0,
+          1,
+        );
+      } else {
+        month.percent = 0;
+      }
+    }
+  }
+
+  clearDeferredLayout(month: MonthGroup) {
+    const hasDeferred = month.dayGroups.some((group) => group.deferredLayout);
+    if (hasDeferred) {
+      updateGeometry(this, month, { invalidateHeight: true, noDefer: true });
+      for (const group of month.dayGroups) {
+        group.deferredLayout = false;
+      }
+    }
+  }
+
   async #initializeMonthGroups() {
     const timebuckets = await getTimeBuckets({
       ...authManager.params,
       ...this.#options,
     });
 
-    this.#months = timebuckets.map((timeBucket) => {
+    this.months = timebuckets.map((timeBucket) => {
       const date = new SvelteDate(timeBucket.timeBucket);
       return new MonthGroup(
         this,
         { year: date.getUTCFullYear(), month: date.getUTCMonth() + 1 },
         timeBucket.count,
-        false,
         this.#options.order,
       );
     });
     this.albumAssets.clear();
-    this.updateViewportGeometry(false);
+    this.#updateViewportGeometry(false);
   }
 
   async updateOptions(options: TimelineManagerOptions) {
@@ -144,13 +313,13 @@ export class TimelineManager extends PhotostreamManager {
       return;
     }
     await this.initTask.reset();
-    await this.init(options);
-    this.updateViewportGeometry(false);
+    await this.#init(options);
+    this.#updateViewportGeometry(false);
   }
 
-  async init(options: TimelineManagerOptions) {
+  async #init(options: TimelineManagerOptions) {
     this.isInitialized = false;
-    this.#months = [];
+    this.months = [];
     this.albumAssets.clear();
     await this.initTask.execute(async () => {
       this.#options = options;
@@ -163,8 +332,36 @@ export class TimelineManager extends PhotostreamManager {
     this.isInitialized = false;
   }
 
-  updateViewportGeometry(changedWidth: boolean) {
-    super.updateViewportGeometry(changedWidth);
+  async updateViewport(viewport: Viewport) {
+    if (viewport.height === 0 && viewport.width === 0) {
+      return;
+    }
+
+    if (this.viewportHeight === viewport.height && this.viewportWidth === viewport.width) {
+      return;
+    }
+
+    if (!this.initTask.executed) {
+      await (this.initTask.loading ? this.initTask.waitUntilCompletion() : this.#init(this.#options));
+    }
+
+    const changedWidth = viewport.width !== this.viewportWidth;
+    this.viewportHeight = viewport.height;
+    this.viewportWidth = viewport.width;
+    this.#updateViewportGeometry(changedWidth);
+  }
+
+  #updateViewportGeometry(changedWidth: boolean) {
+    if (!this.isInitialized) {
+      return;
+    }
+    if (this.viewportWidth === 0 || this.viewportHeight === 0) {
+      return;
+    }
+    for (const month of this.months) {
+      updateGeometry(this, month, { invalidateHeight: changedWidth });
+    }
+    this.updateIntersections();
     this.#createScrubberMonths();
   }
 
@@ -179,8 +376,37 @@ export class TimelineManager extends PhotostreamManager {
     this.scrubberTimelineHeight = this.timelineHeight;
   }
 
-  protected fetchSegment(segment: PhotostreamSegment, signal: AbortSignal): Promise<void> {
-    return loadFromTimeBuckets(this, segment as MonthGroup, this.#options, signal);
+  createLayoutOptions() {
+    const viewportWidth = this.viewportWidth;
+
+    return {
+      spacing: 2,
+      heightTolerance: 0.15,
+      rowHeight: this.#rowHeight,
+      rowWidth: Math.floor(viewportWidth),
+    };
+  }
+
+  async loadMonthGroup(yearMonth: TimelineYearMonth, options?: { cancelable: boolean }): Promise<void> {
+    let cancelable = true;
+    if (options) {
+      cancelable = options.cancelable;
+    }
+    const monthGroup = getMonthGroupByDate(this, yearMonth);
+    if (!monthGroup) {
+      return;
+    }
+
+    if (monthGroup.loader?.executed) {
+      return;
+    }
+
+    const result = await monthGroup.loader?.execute(async (signal: AbortSignal) => {
+      await loadFromTimeBuckets(this, monthGroup, this.#options, signal);
+    }, cancelable);
+    if (result === 'LOADED') {
+      updateIntersectionMonthGroup(this, monthGroup);
+    }
   }
 
   addAssets(assets: TimelineAsset[]) {
@@ -216,7 +442,7 @@ export class TimelineManager extends PhotostreamManager {
   }
 
   async #loadMonthGroupAtTime(yearMonth: TimelineYearMonth, options?: { cancelable: boolean }) {
-    await this.loadSegment(getSegmentIdentifier(yearMonth), options);
+    await this.loadMonthGroup(yearMonth, options);
     return getMonthGroupByDate(this, yearMonth);
   }
 
@@ -228,7 +454,7 @@ export class TimelineManager extends PhotostreamManager {
   async getRandomMonthGroup() {
     const random = Math.floor(Math.random() * this.months.length);
     const month = this.months[random];
-    await this.loadSegment(getSegmentIdentifier(month.yearMonth), { cancelable: false });
+    await this.loadMonthGroup(month.yearMonth, { cancelable: false });
     return month;
   }
 
@@ -301,7 +527,7 @@ export class TimelineManager extends PhotostreamManager {
     if (!monthGroup) {
       return;
     }
-    await this.loadSegment(getSegmentIdentifier(dateTime), { cancelable: false });
+    await this.loadMonthGroup(dateTime, { cancelable: false });
     const asset = monthGroup.findClosest(dateTime);
     if (asset) {
       return asset;

web/src/lib/utils/asset-utils.ts

@@ -513,7 +513,7 @@ export const selectAllAssets = async (timelineManager: TimelineManager, assetInt
 
   try {
     for (const monthGroup of timelineManager.months) {
-      await timelineManager.loadSegment(monthGroup.identifier);
+      await timelineManager.loadMonthGroup(monthGroup.yearMonth);
 
       if (!get(isSelectingAllAssets)) {
         assetInteraction.clearMultiselect();

web/src/lib/utils/timeline-util.ts

@@ -29,12 +29,6 @@ export type ScrubberListener = (
   scrubberMonthScrollPercent: number,
 ) => void | Promise<void>;
 
-export const getSegmentIdentifier = (yearMonth: TimelineYearMonth | TimelineDateTime) => ({
-  matches(segment: any) {
-    return segment.yearMonth && segment.yearMonth.year === yearMonth.year && segment.yearMonth.month === yearMonth.month;
-  },
-});
-
 // used for AssetResponseDto.dateTimeOriginal, amongst others
 export const fromISODateTime = (isoDateTime: string, timeZone: string): DateTime<true> =>
   DateTime.fromISO(isoDateTime, { zone: timeZone, locale: get(locale) }) as DateTime<true>;