Skip to content

High performance self-hosted photo and video management solution.

refactor: asset-store (#18938)

Min Idzelise2ffc9d5a10c
diff --git a/web/src/lib/components/album-page/album-viewer.svelte b/web/src/lib/components/album-page/album-viewer.svelte
index 59d4b5e6ea..71cd9de932 100644
--- a/web/src/lib/components/album-page/album-viewer.svelte
+++ b/web/src/lib/components/album-page/album-viewer.svelte
@@ -6,7 +6,7 @@
import AssetSelectControlBar from '$lib/components/photos-page/asset-select-control-bar.svelte';
import { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
import { assetViewingStore } from '$lib/stores/asset-viewing.store';
- import { AssetStore } from '$lib/stores/assets-store.svelte';
+ import { AssetStore } from '$lib/managers/timeline-manager/asset-store.svelte';
import { dragAndDropFilesStore } from '$lib/stores/drag-and-drop-files.store';
import { featureFlags } from '$lib/stores/server-config.store';
import { handlePromiseError } from '$lib/utils';
diff --git a/web/src/lib/components/asset-viewer/actions/action.ts b/web/src/lib/components/asset-viewer/actions/action.ts
index 0918c86bfe..fd37d253aa 100644
--- a/web/src/lib/components/asset-viewer/actions/action.ts
+++ b/web/src/lib/components/asset-viewer/actions/action.ts
@@ -1,5 +1,5 @@
import type { AssetAction } from '$lib/constants';
-import type { TimelineAsset } from '$lib/stores/assets-store.svelte';
+import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
import type { AlbumResponseDto } from '@immich/sdk';
type ActionMap = {
diff --git a/web/src/lib/components/asset-viewer/actions/download-action.svelte b/web/src/lib/components/asset-viewer/actions/download-action.svelte
index 89bf5b72cb..9a2e1a9553 100644
--- a/web/src/lib/components/asset-viewer/actions/download-action.svelte
+++ b/web/src/lib/components/asset-viewer/actions/download-action.svelte
@@ -2,7 +2,7 @@
import { shortcut } from '$lib/actions/shortcut';
import MenuOption from '$lib/components/shared-components/context-menu/menu-option.svelte';
import { authManager } from '$lib/managers/auth-manager.svelte';
- import type { TimelineAsset } from '$lib/stores/assets-store.svelte';
+ import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
import { downloadFile } from '$lib/utils/asset-utils';
import { getAssetInfo } from '@immich/sdk';
import { IconButton } from '@immich/ui';
diff --git a/web/src/lib/components/asset-viewer/actions/set-visibility-action.svelte b/web/src/lib/components/asset-viewer/actions/set-visibility-action.svelte
index ab97427524..1b06bf8e21 100644
--- a/web/src/lib/components/asset-viewer/actions/set-visibility-action.svelte
+++ b/web/src/lib/components/asset-viewer/actions/set-visibility-action.svelte
@@ -3,7 +3,7 @@
import { AssetAction } from '$lib/constants';
import { modalManager } from '$lib/managers/modal-manager.svelte';
- import type { TimelineAsset } from '$lib/stores/assets-store.svelte';
+ import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
import { handleError } from '$lib/utils/handle-error';
import { AssetVisibility, updateAssets } from '@immich/sdk';
import { mdiLockOpenVariantOutline, mdiLockOutline } from '@mdi/js';
diff --git a/web/src/lib/components/asset-viewer/asset-viewer.svelte b/web/src/lib/components/asset-viewer/asset-viewer.svelte
index eadecfff95..e5d2554e2c 100644
--- a/web/src/lib/components/asset-viewer/asset-viewer.svelte
+++ b/web/src/lib/components/asset-viewer/asset-viewer.svelte
@@ -10,7 +10,7 @@
import { authManager } from '$lib/managers/auth-manager.svelte';
import { closeEditorCofirm } from '$lib/stores/asset-editor.store';
import { assetViewingStore } from '$lib/stores/asset-viewing.store';
- import type { TimelineAsset } from '$lib/stores/assets-store.svelte';
+ import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
import { isShowDetail } from '$lib/stores/preferences.store';
import { SlideshowNavigation, SlideshowState, slideshowStore } from '$lib/stores/slideshow.store';
import { user } from '$lib/stores/user.store';
diff --git a/web/src/lib/components/asset-viewer/photo-viewer.svelte b/web/src/lib/components/asset-viewer/photo-viewer.svelte
index 3dffc0e84c..9cb80fb2dd 100644
--- a/web/src/lib/components/asset-viewer/photo-viewer.svelte
+++ b/web/src/lib/components/asset-viewer/photo-viewer.svelte
@@ -4,7 +4,8 @@
import FaceEditor from '$lib/components/asset-viewer/face-editor/face-editor.svelte';
import BrokenAsset from '$lib/components/assets/broken-asset.svelte';
import { castManager } from '$lib/managers/cast-manager.svelte';
- import { photoViewerImgElement, type TimelineAsset } from '$lib/stores/assets-store.svelte';
+ import { photoViewerImgElement } from '$lib/stores/assets-store.svelte';
+ import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
import { isFaceEditMode } from '$lib/stores/face-edit.svelte';
import { boundingBoxesArray } from '$lib/stores/people.store';
import { alwaysLoadOriginalFile } from '$lib/stores/preferences.store';
diff --git a/web/src/lib/components/assets/thumbnail/thumbnail.svelte b/web/src/lib/components/assets/thumbnail/thumbnail.svelte
index 1f9a29268f..2121531cf5 100644
--- a/web/src/lib/components/assets/thumbnail/thumbnail.svelte
+++ b/web/src/lib/components/assets/thumbnail/thumbnail.svelte
@@ -18,7 +18,7 @@
import { thumbhash } from '$lib/actions/thumbhash';
import { authManager } from '$lib/managers/auth-manager.svelte';
- import type { TimelineAsset } from '$lib/stores/assets-store.svelte';
+ import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
import { mobileDevice } from '$lib/stores/mobile-device.svelte';
import { moveFocus } from '$lib/utils/focus-util';
import { currentUrlReplaceAssetId } from '$lib/utils/navigation';
diff --git a/web/src/lib/components/memory-page/memory-viewer.svelte b/web/src/lib/components/memory-page/memory-viewer.svelte
index 92118b4d8c..62e74f5685 100644
--- a/web/src/lib/components/memory-page/memory-viewer.svelte
+++ b/web/src/lib/components/memory-page/memory-viewer.svelte
@@ -27,7 +27,8 @@
import { authManager } from '$lib/managers/auth-manager.svelte';
import { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
import { assetViewingStore } from '$lib/stores/asset-viewing.store';
- import { type TimelineAsset, type Viewport } from '$lib/stores/assets-store.svelte';
+ import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
+ import type { Viewport } from '$lib/managers/timeline-manager/types';
import { type MemoryAsset, memoryStore } from '$lib/stores/memory.store.svelte';
import { locale, videoViewerMuted, videoViewerVolume } from '$lib/stores/preferences.store';
import { preferences } from '$lib/stores/user.store';
diff --git a/web/src/lib/components/photos-page/actions/focus-actions.ts b/web/src/lib/components/photos-page/actions/focus-actions.ts
index 5085faa0a3..3a75820cd8 100644
--- a/web/src/lib/components/photos-page/actions/focus-actions.ts
+++ b/web/src/lib/components/photos-page/actions/focus-actions.ts
@@ -1,4 +1,5 @@
-import type { AssetStore, TimelineAsset } from '$lib/stores/assets-store.svelte';
+import { AssetStore } from '$lib/managers/timeline-manager/asset-store.svelte';
+import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
import { moveFocus } from '$lib/utils/focus-util';
import { InvocationTracker } from '$lib/utils/invocationTracker';
import { tick } from 'svelte';
diff --git a/web/src/lib/components/photos-page/actions/link-live-photo-action.svelte b/web/src/lib/components/photos-page/actions/link-live-photo-action.svelte
index 1d36c79730..09ca94cb25 100644
--- a/web/src/lib/components/photos-page/actions/link-live-photo-action.svelte
+++ b/web/src/lib/components/photos-page/actions/link-live-photo-action.svelte
@@ -1,6 +1,6 @@
<script lang="ts">
import { getAssetControlContext } from '$lib/components/photos-page/asset-select-control-bar.svelte';
- import type { TimelineAsset } from '$lib/stores/assets-store.svelte';
+ import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
import { authManager } from '$lib/managers/auth-manager.svelte';
import type { OnLink, OnUnlink } from '$lib/utils/actions';
import { handleError } from '$lib/utils/handle-error';
diff --git a/web/src/lib/components/photos-page/actions/select-all-assets.svelte b/web/src/lib/components/photos-page/actions/select-all-assets.svelte
index f07bfd53cc..d8a5ab2fdf 100644
--- a/web/src/lib/components/photos-page/actions/select-all-assets.svelte
+++ b/web/src/lib/components/photos-page/actions/select-all-assets.svelte
@@ -1,6 +1,7 @@
<script lang="ts">
import type { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
- import { type AssetStore, isSelectingAllAssets } from '$lib/stores/assets-store.svelte';
+ import { AssetStore } from '$lib/managers/timeline-manager/asset-store.svelte';
+ import { isSelectingAllAssets } from '$lib/stores/assets-store.svelte';
import { cancelMultiselect, selectAllAssets } from '$lib/utils/asset-utils';
import { Button, IconButton } from '@immich/ui';
import { mdiSelectAll, mdiSelectRemove } from '@mdi/js';
diff --git a/web/src/lib/components/photos-page/asset-date-group.svelte b/web/src/lib/components/photos-page/asset-date-group.svelte
index 49fac572e2..7c5d596bc7 100644
--- a/web/src/lib/components/photos-page/asset-date-group.svelte
+++ b/web/src/lib/components/photos-page/asset-date-group.svelte
@@ -1,20 +1,17 @@
<script lang="ts">
import Icon from '$lib/components/elements/icon.svelte';
import type { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
- import {
- type AssetBucket,
- assetSnapshot,
- assetsSnapshot,
- type AssetStore,
- isSelectingAllAssets,
- type TimelineAsset,
- } from '$lib/stores/assets-store.svelte';
+ import { isSelectingAllAssets } from '$lib/stores/assets-store.svelte';
+ import type { AssetStore } from '$lib/managers/timeline-manager/asset-store.svelte';
+ import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
+ import { assetSnapshot, assetsSnapshot } from '$lib/managers/timeline-manager/utils.svelte';
import { navigate } from '$lib/utils/navigation';
import { mdiCheckCircle, mdiCircleOutline } from '@mdi/js';
import { fly, scale } from 'svelte/transition';
import Thumbnail from '../assets/thumbnail/thumbnail.svelte';
+ import type { AssetBucket } from '$lib/managers/timeline-manager/asset-bucket.svelte';
import { uploadAssetsStore } from '$lib/stores/upload';
import { flip } from 'svelte/animate';
diff --git a/web/src/lib/components/photos-page/asset-grid.svelte b/web/src/lib/components/photos-page/asset-grid.svelte
index c0eb75c3ba..dec0c0096c 100644
--- a/web/src/lib/components/photos-page/asset-grid.svelte
+++ b/web/src/lib/components/photos-page/asset-grid.svelte
@@ -18,17 +18,15 @@
import ShortcutsModal from '$lib/modals/ShortcutsModal.svelte';
import type { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
import { assetViewingStore } from '$lib/stores/asset-viewing.store';
- import {
- AssetBucket,
- assetsSnapshot,
- AssetStore,
- isSelectingAllAssets,
- type TimelineAsset,
- } from '$lib/stores/assets-store.svelte';
+ import { isSelectingAllAssets } from '$lib/stores/assets-store.svelte';
+ import { AssetStore } from '$lib/managers/timeline-manager/asset-store.svelte';
+ import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
+ import { assetsSnapshot } from '$lib/managers/timeline-manager/utils.svelte';
import { mobileDevice } from '$lib/stores/mobile-device.svelte';
import { showDeleteModal } from '$lib/stores/preferences.store';
import { searchStore } from '$lib/stores/search.svelte';
import { featureFlags } from '$lib/stores/server-config.store';
+ import type { AssetBucket } from '$lib/managers/timeline-manager/asset-bucket.svelte';
import { handlePromiseError } from '$lib/utils';
import { deleteAssets, updateStackedAssetInTimeline, updateUnstackedAssetInTimeline } from '$lib/utils/actions';
import { archiveAssets, cancelMultiselect, selectAllAssets, stackAssets } from '$lib/utils/asset-utils';
diff --git a/web/src/lib/components/photos-page/asset-select-control-bar.svelte b/web/src/lib/components/photos-page/asset-select-control-bar.svelte
index b21693bc51..df4db5787f 100644
--- a/web/src/lib/components/photos-page/asset-select-control-bar.svelte
+++ b/web/src/lib/components/photos-page/asset-select-control-bar.svelte
@@ -14,7 +14,7 @@
</script>
<script lang="ts">
- import type { TimelineAsset } from '$lib/stores/assets-store.svelte';
+ import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
import { mdiClose } from '@mdi/js';
import type { Snippet } from 'svelte';
import ControlAppBar from '../shared-components/control-app-bar.svelte';
diff --git a/web/src/lib/components/share-page/individual-shared-viewer.svelte b/web/src/lib/components/share-page/individual-shared-viewer.svelte
index fd3dec5e75..0c287a0679 100644
--- a/web/src/lib/components/share-page/individual-shared-viewer.svelte
+++ b/web/src/lib/components/share-page/individual-shared-viewer.svelte
@@ -5,7 +5,7 @@
import { AppRoute, AssetAction } from '$lib/constants';
import { authManager } from '$lib/managers/auth-manager.svelte';
import { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
- import type { Viewport } from '$lib/stores/assets-store.svelte';
+ import type { Viewport } from '$lib/managers/timeline-manager/types';
import { dragAndDropFilesStore } from '$lib/stores/drag-and-drop-files.store';
import { handlePromiseError } from '$lib/utils';
import { cancelMultiselect, downloadArchive } from '$lib/utils/asset-utils';
diff --git a/web/src/lib/components/shared-components/gallery-viewer/gallery-viewer.svelte b/web/src/lib/components/shared-components/gallery-viewer/gallery-viewer.svelte
index 248c14437d..ace77e2dde 100644
--- a/web/src/lib/components/shared-components/gallery-viewer/gallery-viewer.svelte
+++ b/web/src/lib/components/shared-components/gallery-viewer/gallery-viewer.svelte
@@ -8,7 +8,8 @@
import ShortcutsModal from '$lib/modals/ShortcutsModal.svelte';
import type { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
import { assetViewingStore } from '$lib/stores/asset-viewing.store';
- import type { TimelineAsset, Viewport } from '$lib/stores/assets-store.svelte';
+ import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
+ import type { Viewport } from '$lib/managers/timeline-manager/types';
import { showDeleteModal } from '$lib/stores/preferences.store';
import { featureFlags } from '$lib/stores/server-config.store';
import { handlePromiseError } from '$lib/utils';
diff --git a/web/src/lib/components/shared-components/scrubber/scrubber.svelte b/web/src/lib/components/shared-components/scrubber/scrubber.svelte
index c18c7c83b0..93cfa13521 100644
--- a/web/src/lib/components/shared-components/scrubber/scrubber.svelte
+++ b/web/src/lib/components/shared-components/scrubber/scrubber.svelte
@@ -1,6 +1,7 @@
<script lang="ts">
import Icon from '$lib/components/elements/icon.svelte';
- import type { AssetStore, LiteBucket } from '$lib/stores/assets-store.svelte';
+ import { AssetStore } from '$lib/managers/timeline-manager/asset-store.svelte';
+ import type { LiteBucket } from '$lib/managers/timeline-manager/types';
import { mobileDevice } from '$lib/stores/mobile-device.svelte';
import { getTabbable } from '$lib/utils/focus-util';
import { type ScrubberListener } from '$lib/utils/timeline-util';
diff --git a/web/src/lib/managers/timeline-manager/add-context.svelte.ts b/web/src/lib/managers/timeline-manager/add-context.svelte.ts
new file mode 100644
index 0000000000..5c090055cf
--- /dev/null
+++ b/web/src/lib/managers/timeline-manager/add-context.svelte.ts
@@ -0,0 +1,60 @@
+import type { TimelinePlainDate } from '$lib/utils/timeline-util';
+import { AssetOrder } from '@immich/sdk';
+import type { AssetBucket } from './asset-bucket.svelte';
+import type { AssetDateGroup } from './asset-date-group.svelte';
+import type { TimelineAsset } from './types';
+
+export class AddContext {
+ #lookupCache: {
+ [year: number]: { [month: number]: { [day: number]: AssetDateGroup } };
+ } = {};
+ unprocessedAssets: TimelineAsset[] = [];
+ changedDateGroups = new Set<AssetDateGroup>();
+ newDateGroups = new Set<AssetDateGroup>();
+
+ getDateGroup({ year, month, day }: TimelinePlainDate): AssetDateGroup | undefined {
+ return this.#lookupCache[year]?.[month]?.[day];
+ }
+
+ setDateGroup(dateGroup: AssetDateGroup, { year, month, day }: TimelinePlainDate) {
+ if (!this.#lookupCache[year]) {
+ this.#lookupCache[year] = {};
+ }
+ if (!this.#lookupCache[year][month]) {
+ this.#lookupCache[year][month] = {};
+ }
+ this.#lookupCache[year][month][day] = dateGroup;
+ }
+
+ get existingDateGroups() {
+ return this.changedDateGroups.difference(this.newDateGroups);
+ }
+
+ get updatedBuckets() {
+ const updated = new Set<AssetBucket>();
+ for (const group of this.changedDateGroups) {
+ updated.add(group.bucket);
+ }
+ return updated;
+ }
+
+ get bucketsWithNewDateGroups() {
+ const updated = new Set<AssetBucket>();
+ for (const group of this.newDateGroups) {
+ updated.add(group.bucket);
+ }
+ return updated;
+ }
+
+ sort(bucket: AssetBucket, sortOrder: AssetOrder = AssetOrder.Desc) {
+ for (const group of this.changedDateGroups) {
+ group.sortAssets(sortOrder);
+ }
+ for (const group of this.newDateGroups) {
+ group.sortAssets(sortOrder);
+ }
+ if (this.newDateGroups.size > 0) {
+ bucket.sortDateGroups();
+ }
+ }
+}
diff --git a/web/src/lib/managers/timeline-manager/asset-bucket.svelte.ts b/web/src/lib/managers/timeline-manager/asset-bucket.svelte.ts
new file mode 100644
index 0000000000..08607d4331
--- /dev/null
+++ b/web/src/lib/managers/timeline-manager/asset-bucket.svelte.ts
@@ -0,0 +1,361 @@
+import { CancellableTask } from '$lib/utils/cancellable-task';
+import { handleError } from '$lib/utils/handle-error';
+import {
+ formatBucketTitle,
+ formatGroupTitle,
+ fromLocalDateTimeToObject,
+ fromTimelinePlainDate,
+ fromTimelinePlainDateTime,
+ fromTimelinePlainYearMonth,
+ type TimelinePlainDateTime,
+ type TimelinePlainYearMonth,
+} from '$lib/utils/timeline-util';
+import { AssetOrder, type TimeBucketAssetResponseDto } from '@immich/sdk';
+import { t } from 'svelte-i18n';
+import { get } from 'svelte/store';
+import { AddContext } from './add-context.svelte';
+import { AssetDateGroup } from './asset-date-group.svelte';
+import type { AssetStore } from './asset-store.svelte';
+import { IntersectingAsset } from './intersecting-asset.svelte';
+import type { AssetDescriptor, AssetOperation, Direction, MoveAsset, TimelineAsset } from './types';
+
+export class AssetBucket {
+ #intersecting: boolean = $state(false);
+ actuallyIntersecting: boolean = $state(false);
+ isLoaded: boolean = $state(false);
+ dateGroups: AssetDateGroup[] = $state([]);
+ readonly store: AssetStore;
+
+ #bucketHeight: number = $state(0);
+ #top: number = $state(0);
+
+ #initialCount: number = 0;
+ #sortOrder: AssetOrder = AssetOrder.Desc;
+ percent: number = $state(0);
+
+ bucketCount: number = $derived(
+ this.isLoaded
+ ? this.dateGroups.reduce((accumulator, g) => accumulator + g.intersectingAssets.length, 0)
+ : this.#initialCount,
+ );
+ loader: CancellableTask | undefined;
+ isBucketHeightActual: boolean = $state(false);
+
+ readonly bucketDateFormatted: string;
+ readonly yearMonth: TimelinePlainYearMonth;
+
+ constructor(
+ store: AssetStore,
+ yearMonth: TimelinePlainYearMonth,
+ initialCount: number,
+ order: AssetOrder = AssetOrder.Desc,
+ ) {
+ this.store = store;
+ this.#initialCount = initialCount;
+ this.#sortOrder = order;
+
+ this.yearMonth = yearMonth;
+ this.bucketDateFormatted = formatBucketTitle(fromTimelinePlainYearMonth(yearMonth));
+
+ this.loader = new CancellableTask(
+ () => {
+ this.isLoaded = true;
+ },
+ () => {
+ this.dateGroups = [];
+ this.isLoaded = false;
+ },
+ this.#handleLoadError,
+ );
+ }
+
+ set intersecting(newValue: boolean) {
+ const old = this.#intersecting;
+ if (old === newValue) {
+ return;
+ }
+ this.#intersecting = newValue;
+ if (newValue) {
+ void this.store.loadBucket(this.yearMonth);
+ } else {
+ this.cancel();
+ }
+ }
+
+ get intersecting() {
+ return this.#intersecting;
+ }
+
+ get lastDateGroup() {
+ return this.dateGroups.at(-1);
+ }
+
+ getFirstAsset() {
+ return this.dateGroups[0]?.getFirstAsset();
+ }
+
+ getAssets() {
+ // eslint-disable-next-line unicorn/no-array-reduce
+ return this.dateGroups.reduce(
+ (accumulator: TimelineAsset[], g: AssetDateGroup) => accumulator.concat(g.getAssets()),
+ [],
+ );
+ }
+
+ sortDateGroups() {
+ if (this.#sortOrder === AssetOrder.Asc) {
+ return this.dateGroups.sort((a, b) => a.day - b.day);
+ }
+
+ return this.dateGroups.sort((a, b) => b.day - a.day);
+ }
+
+ runAssetOperation(ids: Set<string>, operation: AssetOperation) {
+ if (ids.size === 0) {
+ return {
+ moveAssets: [] as MoveAsset[],
+ processedIds: new Set<string>(),
+ unprocessedIds: ids,
+ changedGeometry: false,
+ };
+ }
+ const { dateGroups } = this;
+ let combinedChangedGeometry = false;
+ let idsToProcess = new Set(ids);
+ const idsProcessed = new Set<string>();
+ const combinedMoveAssets: MoveAsset[][] = [];
+ let index = dateGroups.length;
+ while (index--) {
+ if (idsToProcess.size > 0) {
+ const group = dateGroups[index];
+ const { moveAssets, processedIds, changedGeometry } = group.runAssetOperation(ids, operation);
+ if (moveAssets.length > 0) {
+ combinedMoveAssets.push(moveAssets);
+ }
+ idsToProcess = idsToProcess.difference(processedIds);
+ for (const id of processedIds) {
+ idsProcessed.add(id);
+ }
+ combinedChangedGeometry = combinedChangedGeometry || changedGeometry;
+ if (group.intersectingAssets.length === 0) {
+ dateGroups.splice(index, 1);
+ combinedChangedGeometry = true;
+ }
+ }
+ }
+ return {
+ moveAssets: combinedMoveAssets.flat(),
+ unprocessedIds: idsToProcess,
+ processedIds: idsProcessed,
+ changedGeometry: combinedChangedGeometry,
+ };
+ }
+
+ addAssets(bucketAssets: TimeBucketAssetResponseDto) {
+ const addContext = new AddContext();
+ const people: string[] = [];
+ for (let i = 0; i < bucketAssets.id.length; i++) {
+ const timelineAsset: TimelineAsset = {
+ city: bucketAssets.city[i],
+ country: bucketAssets.country[i],
+ duration: bucketAssets.duration[i],
+ id: bucketAssets.id[i],
+ visibility: bucketAssets.visibility[i],
+ isFavorite: bucketAssets.isFavorite[i],
+ isImage: bucketAssets.isImage[i],
+ isTrashed: bucketAssets.isTrashed[i],
+ isVideo: !bucketAssets.isImage[i],
+ livePhotoVideoId: bucketAssets.livePhotoVideoId[i],
+ localDateTime: fromLocalDateTimeToObject(bucketAssets.localDateTime[i]),
+ ownerId: bucketAssets.ownerId[i],
+ people,
+ projectionType: bucketAssets.projectionType[i],
+ ratio: bucketAssets.ratio[i],
+ stack: bucketAssets.stack?.[i]
+ ? {
+ id: bucketAssets.stack[i]![0],
+ primaryAssetId: bucketAssets.id[i],
+ assetCount: Number.parseInt(bucketAssets.stack[i]![1]),
+ }
+ : null,
+ thumbhash: bucketAssets.thumbhash[i],
+ };
+ this.addTimelineAsset(timelineAsset, addContext);
+ }
+
+ for (const group of addContext.existingDateGroups) {
+ group.sortAssets(this.#sortOrder);
+ }
+
+ if (addContext.newDateGroups.size > 0) {
+ this.sortDateGroups();
+ }
+
+ addContext.sort(this, this.#sortOrder);
+
+ return addContext.unprocessedAssets;
+ }
+
+ addTimelineAsset(timelineAsset: TimelineAsset, addContext: AddContext) {
+ const { localDateTime } = timelineAsset;
+
+ const { year, month } = this.yearMonth;
+ if (month !== localDateTime.month || year !== localDateTime.year) {
+ addContext.unprocessedAssets.push(timelineAsset);
+ return;
+ }
+
+ let dateGroup = addContext.getDateGroup(localDateTime) || this.findDateGroupByDay(localDateTime.day);
+ if (dateGroup) {
+ addContext.setDateGroup(dateGroup, localDateTime);
+ } else {
+ const groupTitle = formatGroupTitle(fromTimelinePlainDate(localDateTime));
+ dateGroup = new AssetDateGroup(this, this.dateGroups.length, localDateTime.day, groupTitle);
+ this.dateGroups.push(dateGroup);
+ addContext.setDateGroup(dateGroup, localDateTime);
+ addContext.newDateGroups.add(dateGroup);
+ }
+
+ const intersectingAsset = new IntersectingAsset(dateGroup, timelineAsset);
+ dateGroup.intersectingAssets.push(intersectingAsset);
+ addContext.changedDateGroups.add(dateGroup);
+ }
+
+ getRandomDateGroup() {
+ const random = Math.floor(Math.random() * this.dateGroups.length);
+ return this.dateGroups[random];
+ }
+
+ getRandomAsset() {
+ return this.getRandomDateGroup()?.getRandomAsset()?.asset;
+ }
+
+ get viewId() {
+ const { year, month } = this.yearMonth;
+ return year + '-' + month;
+ }
+
+ set bucketHeight(height: number) {
+ if (this.#bucketHeight === height) {
+ return;
+ }
+ const { store, percent } = this;
+ const index = store.buckets.indexOf(this);
+ const bucketHeightDelta = height - this.#bucketHeight;
+ this.#bucketHeight = height;
+ const prevBucket = store.buckets[index - 1];
+ if (prevBucket) {
+ const newTop = prevBucket.#top + prevBucket.#bucketHeight;
+ if (this.#top !== newTop) {
+ this.#top = newTop;
+ }
+ }
+ for (let cursor = index + 1; cursor < store.buckets.length; cursor++) {
+ const bucket = this.store.buckets[cursor];
+ const newTop = bucket.#top + bucketHeightDelta;
+ if (bucket.#top !== newTop) {
+ bucket.#top = newTop;
+ }
+ }
+ if (store.topIntersectingBucket) {
+ const currentIndex = store.buckets.indexOf(store.topIntersectingBucket);
+ if (currentIndex > 0) {
+ if (index < currentIndex) {
+ store.scrollCompensation = {
+ heightDelta: bucketHeightDelta,
+ scrollTop: undefined,
+ bucket: this,
+ };
+ } else if (percent > 0) {
+ const top = this.top + height * percent;
+ store.scrollCompensation = {
+ heightDelta: undefined,
+ scrollTop: top,
+ bucket: this,
+ };
+ }
+ }
+ }
+ }
+
+ get bucketHeight() {
+ return this.#bucketHeight;
+ }
+
+ get top(): number {
+ return this.#top + this.store.topSectionHeight;
+ }
+
+ #handleLoadError(error: unknown) {
+ const _$t = get(t);
+ handleError(error, _$t('errors.failed_to_load_assets'));
+ }
+
+ findDateGroupForAsset(asset: TimelineAsset) {
+ for (const group of this.dateGroups) {
+ if (group.intersectingAssets.some((IntersectingAsset) => IntersectingAsset.id === asset.id)) {
+ return group;
+ }
+ }
+ }
+
+ findDateGroupByDay(day: number) {
+ return this.dateGroups.find((group) => group.day === day);
+ }
+
+ findAssetAbsolutePosition(assetId: string) {
+ this.store.clearDeferredLayout(this);
+ for (const group of this.dateGroups) {
+ const intersectingAsset = group.intersectingAssets.find((asset) => asset.id === assetId);
+ if (intersectingAsset) {
+ if (!intersectingAsset.position) {
+ console.warn('No position for asset');
+ break;
+ }
+ return this.top + group.top + intersectingAsset.position.top + this.store.headerHeight;
+ }
+ }
+ return -1;
+ }
+
+ *assetsIterator(options?: { startDateGroup?: AssetDateGroup; startAsset?: TimelineAsset; direction?: Direction }) {
+ const direction = options?.direction ?? 'earlier';
+ let { startAsset } = options ?? {};
+ const isEarlier = direction === 'earlier';
+ let groupIndex = options?.startDateGroup
+ ? this.dateGroups.indexOf(options.startDateGroup)
+ : isEarlier
+ ? 0
+ : this.dateGroups.length - 1;
+
+ while (groupIndex >= 0 && groupIndex < this.dateGroups.length) {
+ const group = this.dateGroups[groupIndex];
+ yield* group.assetsIterator({ startAsset, direction });
+ startAsset = undefined;
+ groupIndex += isEarlier ? 1 : -1;
+ }
+ }
+
+ findAssetById(assetDescriptor: AssetDescriptor) {
+ return this.assetsIterator().find((asset) => asset.id === assetDescriptor.id);
+ }
+
+ findClosest(target: TimelinePlainDateTime) {
+ const targetDate = fromTimelinePlainDateTime(target);
+ let closest = undefined;
+ let smallestDiff = Infinity;
+ for (const current of this.assetsIterator()) {
+ const currentAssetDate = fromTimelinePlainDateTime(current.localDateTime);
+ const diff = Math.abs(targetDate.diff(currentAssetDate).as('milliseconds'));
+ if (diff < smallestDiff) {
+ smallestDiff = diff;
+ closest = current;
+ }
+ }
+ return closest;
+ }
+
+ cancel() {
+ this.loader?.cancel();
+ }
+}
diff --git a/web/src/lib/managers/timeline-manager/asset-date-group.svelte.ts b/web/src/lib/managers/timeline-manager/asset-date-group.svelte.ts
new file mode 100644
index 0000000000..e27aaabbe4
--- /dev/null
+++ b/web/src/lib/managers/timeline-manager/asset-date-group.svelte.ts
@@ -0,0 +1,162 @@
+import type { CommonLayoutOptions } from '$lib/utils/layout-utils';
+import { getJustifiedLayoutFromAssets, getPosition } from '$lib/utils/layout-utils';
+import { plainDateTimeCompare } from '$lib/utils/timeline-util';
+import { AssetOrder } from '@immich/sdk';
+import type { AssetBucket } from './asset-bucket.svelte';
+import { IntersectingAsset } from './intersecting-asset.svelte';
+import type { AssetOperation, Direction, MoveAsset, TimelineAsset } from './types';
+
+export class AssetDateGroup {
+ readonly bucket: AssetBucket;
+ readonly index: number;
+ readonly groupTitle: string;
+ readonly day: number;
+ intersectingAssets: IntersectingAsset[] = $state([]);
+
+ height = $state(0);
+ width = $state(0);
+ intersecting = $derived.by(() => this.intersectingAssets.some((asset) => asset.intersecting));
+
+ #top: number = $state(0);
+ #left: number = $state(0);
+ #row = $state(0);
+ #col = $state(0);
+ #deferredLayout = false;
+
+ constructor(bucket: AssetBucket, index: number, day: number, groupTitle: string) {
+ this.index = index;
+ this.bucket = bucket;
+ this.day = day;
+ this.groupTitle = groupTitle;
+ }
+
+ get top() {
+ return this.#top;
+ }
+
+ set top(value: number) {
+ this.#top = value;
+ }
+
+ get left() {
+ return this.#left;
+ }
+
+ set left(value: number) {
+ this.#left = value;
+ }
+
+ get row() {
+ return this.#row;
+ }
+
+ set row(value: number) {
+ this.#row = value;
+ }
+
+ get col() {
+ return this.#col;
+ }
+
+ set col(value: number) {
+ this.#col = value;
+ }
+
+ get deferredLayout() {
+ return this.#deferredLayout;
+ }
+
+ set deferredLayout(value: boolean) {
+ this.#deferredLayout = value;
+ }
+
+ sortAssets(sortOrder: AssetOrder = AssetOrder.Desc) {
+ const sortFn = plainDateTimeCompare.bind(undefined, sortOrder === AssetOrder.Asc);
+ this.intersectingAssets.sort((a, b) => sortFn(a.asset.localDateTime, b.asset.localDateTime));
+ }
+
+ getFirstAsset() {
+ return this.intersectingAssets[0]?.asset;
+ }
+
+ getRandomAsset() {
+ const random = Math.floor(Math.random() * this.intersectingAssets.length);
+ return this.intersectingAssets[random];
+ }
+
+ *assetsIterator(options: { startAsset?: TimelineAsset; direction?: Direction } = {}) {
+ const isEarlier = (options?.direction ?? 'earlier') === 'earlier';
+ let assetIndex = options?.startAsset
+ ? this.intersectingAssets.findIndex((intersectingAsset) => intersectingAsset.asset.id === options.startAsset!.id)
+ : isEarlier
+ ? 0
+ : this.intersectingAssets.length - 1;
+
+ while (assetIndex >= 0 && assetIndex < this.intersectingAssets.length) {
+ const intersectingAsset = this.intersectingAssets[assetIndex];
+ yield intersectingAsset.asset;
+ assetIndex += isEarlier ? 1 : -1;
+ }
+ }
+
+ getAssets() {
+ return this.intersectingAssets.map((intersectingasset) => intersectingasset.asset);
+ }
+
+ runAssetOperation(ids: Set<string>, operation: AssetOperation) {
+ if (ids.size === 0) {
+ return {
+ moveAssets: [] as MoveAsset[],
+ processedIds: new Set<string>(),
+ unprocessedIds: ids,
+ changedGeometry: false,
+ };
+ }
+ const unprocessedIds = new Set<string>(ids);
+ const processedIds = new Set<string>();
+ const moveAssets: MoveAsset[] = [];
+ let changedGeometry = false;
+ for (const assetId of unprocessedIds) {
+ const index = this.intersectingAssets.findIndex((ia) => ia.id == assetId);
+ if (index === -1) {
+ continue;
+ }
+
+ const asset = this.intersectingAssets[index].asset!;
+ const oldTime = { ...asset.localDateTime };
+ let { remove } = operation(asset);
+ const newTime = asset.localDateTime;
+ if (oldTime.year !== newTime.year || oldTime.month !== newTime.month || oldTime.day !== newTime.day) {
+ const { year, month, day } = newTime;
+ remove = true;
+ moveAssets.push({ asset, date: { year, month, day } });
+ }
+ unprocessedIds.delete(assetId);
+ processedIds.add(assetId);
+ if (remove || this.bucket.store.isExcluded(asset)) {
+ this.intersectingAssets.splice(index, 1);
+ changedGeometry = true;
+ }
+ }
+ return { moveAssets, processedIds, unprocessedIds, changedGeometry };
+ }
+
+ layout(options: CommonLayoutOptions, noDefer: boolean) {
+ if (!noDefer && !this.bucket.intersecting) {
+ this.#deferredLayout = true;
+ return;
+ }
+ const assets = this.intersectingAssets.map((intersetingAsset) => intersetingAsset.asset!);
+ const geometry = getJustifiedLayoutFromAssets(assets, options);
+ this.width = geometry.containerWidth;
+ this.height = assets.length === 0 ? 0 : geometry.containerHeight;
+ for (let i = 0; i < this.intersectingAssets.length; i++) {
+ const position = getPosition(geometry, i);
+ this.intersectingAssets[i].position = position;
+ }
+ }
+
+ get absoluteDateGroupTop() {
+ return this.bucket.top + this.#top;
+ }
+}
diff --git a/web/src/lib/managers/timeline-manager/asset-store.svelte.ts b/web/src/lib/managers/timeline-manager/asset-store.svelte.ts
new file mode 100644
index 0000000000..620ebaed0b
--- /dev/null
+++ b/web/src/lib/managers/timeline-manager/asset-store.svelte.ts
@@ -0,0 +1,934 @@
+import { authManager } from '$lib/managers/auth-manager.svelte';
+import { websocketEvents } from '$lib/stores/websocket';
+import { CancellableTask } from '$lib/utils/cancellable-task';
+import {
+ plainDateTimeCompare,
+ toISOLocalDateTime,
+ toTimelineAsset,
+ type TimelinePlainDate,
+ type TimelinePlainDateTime,
+ type TimelinePlainYearMonth,
+} from '$lib/utils/timeline-util';
+import { TUNABLES } from '$lib/utils/tunables';
+import { getAssetInfo, getTimeBucket, getTimeBuckets } from '@immich/sdk';
+import { clamp, debounce, isEqual, throttle } from 'lodash-es';
+import { SvelteSet } from 'svelte/reactivity';
+import type { Unsubscriber } from 'svelte/store';
+import { AddContext } from './add-context.svelte';
+import { AssetBucket } from './asset-bucket.svelte';
+import { AssetDateGroup } from './asset-date-group.svelte';
+import type {
+ AssetDescriptor,
+ AssetOperation,
+ AssetStoreLayoutOptions,
+ AssetStoreOptions,
+ Direction,
+ LiteBucket,
+ PendingChange,
+ TimelineAsset,
+ UpdateGeometryOptions,
+ Viewport,
+} from './types';
+import { isMismatched, updateObject } from './utils.svelte';
+
+const {
+ TIMELINE: { INTERSECTION_EXPAND_TOP, INTERSECTION_EXPAND_BOTTOM },
+} = TUNABLES;
+
+export class AssetStore {
+ isInitialized = $state(false);
+ buckets: AssetBucket[] = $state([]);
+ topSectionHeight = $state(0);
+ timelineHeight = $derived(
+ this.buckets.reduce((accumulator, b) => accumulator + b.bucketHeight, 0) + this.topSectionHeight,
+ );
+ count = $derived(this.buckets.reduce((accumulator, b) => accumulator + b.bucketCount, 0));
+
+ albumAssets: Set<string> = new SvelteSet();
+
+ scrubberBuckets: LiteBucket[] = $state([]);
+ scrubberTimelineHeight: number = $state(0);
+
+ topIntersectingBucket: AssetBucket | undefined = $state();
+
+ visibleWindow = $derived.by(() => ({
+ top: this.#scrollTop,
+ bottom: this.#scrollTop + this.viewportHeight,
+ }));
+
+ initTask = new CancellableTask(
+ () => {
+ this.isInitialized = true;
+ if (this.#options.albumId || this.#options.personId) {
+ return;
+ }
+ this.connect();
+ },
+ () => {
+ this.disconnect();
+ this.isInitialized = false;
+ },
+ () => void 0,
+ );
+
+ static #INIT_OPTIONS = {};
+ #viewportHeight = $state(0);
+ #viewportWidth = $state(0);
+ #scrollTop = $state(0);
+ #pendingChanges: PendingChange[] = [];
+ #unsubscribers: Unsubscriber[] = [];
+
+ #rowHeight = $state(235);
+ #headerHeight = $state(48);
+ #gap = $state(12);
+
+ #options: AssetStoreOptions = AssetStore.#INIT_OPTIONS;
+
+ #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;
+ bucket: AssetBucket | undefined;
+ } = $state({
+ heightDelta: 0,
+ scrollTop: 0,
+ bucket: undefined,
+ });
+
+ constructor() {}
+
+ setLayoutOptions({ headerHeight = 48, rowHeight = 235, gap = 12 }: AssetStoreLayoutOptions) {
+ 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?: {
+ startBucket?: AssetBucket;
+ startDateGroup?: AssetDateGroup;
+ startAsset?: TimelineAsset;
+ direction?: Direction;
+ }) {
+ const direction = options?.direction ?? 'earlier';
+ let { startDateGroup, startAsset } = options ?? {};
+ for (const bucket of this.bucketsIterator({ direction, startBucket: options?.startBucket })) {
+ await this.loadBucket(bucket.yearMonth, { cancelable: false });
+ yield* bucket.assetsIterator({ startDateGroup, startAsset, direction });
+ startDateGroup = startAsset = undefined;
+ }
+ }
+
+ *bucketsIterator(options?: { direction?: Direction; startBucket?: AssetBucket }) {
+ const isEarlier = options?.direction === 'earlier';
+ let startIndex = options?.startBucket
+ ? this.buckets.indexOf(options.startBucket)
+ : isEarlier
+ ? 0
+ : this.buckets.length - 1;
+
+ while (startIndex >= 0 && startIndex < this.buckets.length) {
+ yield this.buckets[startIndex];
+ startIndex += isEarlier ? 1 : -1;
+ }
+ }
+
+ #addPendingChanges(...changes: PendingChange[]) {
+ this.#pendingChanges.push(...changes);
+ this.#processPendingChanges();
+ }
+
+ connect() {
+ this.#unsubscribers.push(
+ websocketEvents.on('on_upload_success', (asset) =>
+ this.#addPendingChanges({ type: 'add', values: [toTimelineAsset(asset)] }),
+ ),
+ websocketEvents.on('on_asset_trash', (ids) => this.#addPendingChanges({ type: 'trash', values: ids })),
+ websocketEvents.on('on_asset_update', (asset) =>
+ this.#addPendingChanges({ type: 'update', values: [toTimelineAsset(asset)] }),
+ ),
+ websocketEvents.on('on_asset_delete', (id: string) => this.#addPendingChanges({ type: 'delete', values: [id] })),
+ );
+ }
+
+ disconnect() {
+ for (const unsubscribe of this.#unsubscribers) {
+ unsubscribe();
+ }
+ this.#unsubscribers = [];
+ }
+
+ #getPendingChangeBatches() {
+ const batch: {
+ add: TimelineAsset[];
+ update: TimelineAsset[];
+ remove: string[];
+ } = {
+ add: [],
+ update: [],
+ remove: [],
+ };
+ for (const { type, values } of this.#pendingChanges) {
+ switch (type) {
+ case 'add': {
+ batch.add.push(...values);
+ break;
+ }
+ case 'update': {
+ batch.update.push(...values);
+ break;
+ }
+ case 'delete':
+ case 'trash': {
+ batch.remove.push(...values);
+ break;
+ }
+ }
+ }
+ return batch;
+ }
+
+ #findBucketForAsset(id: string) {
+ for (const bucket of this.buckets) {
+ const asset = bucket.findAssetById({ id });
+ if (asset) {
+ return { bucket, asset };
+ }
+ }
+ }
+
+ #findBucketForDate(targetYearMonth: TimelinePlainYearMonth) {
+ for (const bucket of this.buckets) {
+ const { year, month } = bucket.yearMonth;
+ if (month === targetYearMonth.month && year === targetYearMonth.year) {
+ return bucket;
+ }
+ }
+ }
+
+ updateSlidingWindow(scrollTop: number) {
+ if (this.#scrollTop !== scrollTop) {
+ this.#scrollTop = scrollTop;
+ this.updateIntersections();
+ }
+ }
+
+ clearScrollCompensation() {
+ this.scrollCompensation = {
+ heightDelta: undefined,
+ scrollTop: undefined,
+ bucket: undefined,
+ };
+ }
+
+ updateIntersections() {
+ if (!this.isInitialized || this.visibleWindow.bottom === this.visibleWindow.top) {
+ return;
+ }
+ let topIntersectingBucket = undefined;
+ for (const bucket of this.buckets) {
+ this.#updateIntersection(bucket);
+ if (!topIntersectingBucket && bucket.actuallyIntersecting) {
+ topIntersectingBucket = bucket;
+ }
+ }
+ if (topIntersectingBucket !== undefined && this.topIntersectingBucket !== topIntersectingBucket) {
+ this.topIntersectingBucket = topIntersectingBucket;
+ }
+ for (const bucket of this.buckets) {
+ if (bucket === this.topIntersectingBucket) {
+ this.topIntersectingBucket.percent = clamp(
+ (this.visibleWindow.top - this.topIntersectingBucket.top) / this.topIntersectingBucket.bucketHeight,
+ 0,
+ 1,
+ );
+ } else {
+ bucket.percent = 0;
+ }
+ }
+ }
+
+ #calculateIntersecting(bucket: AssetBucket, expandTop: number, expandBottom: number) {
+ const bucketTop = bucket.top;
+ const bucketBottom = bucketTop + bucket.bucketHeight;
+ const topWindow = this.visibleWindow.top - expandTop;
+ const bottomWindow = this.visibleWindow.bottom + expandBottom;
+
+ return (
+ (bucketTop >= topWindow && bucketTop < bottomWindow) ||
+ (bucketBottom >= topWindow && bucketBottom < bottomWindow) ||
+ (bucketTop < topWindow && bucketBottom >= bottomWindow)
+ );
+ }
+
+ clearDeferredLayout(bucket: AssetBucket) {
+ const hasDeferred = bucket.dateGroups.some((group) => group.deferredLayout);
+ if (hasDeferred) {
+ this.#updateGeometry(bucket, { invalidateHeight: true, noDefer: true });
+ for (const group of bucket.dateGroups) {
+ group.deferredLayout = false;
+ }
+ }
+ }
+
+ #updateIntersection(bucket: AssetBucket) {
+ const actuallyIntersecting = this.#calculateIntersecting(bucket, 0, 0);
+ let preIntersecting = false;
+ if (!actuallyIntersecting) {
+ preIntersecting = this.#calculateIntersecting(bucket, INTERSECTION_EXPAND_TOP, INTERSECTION_EXPAND_BOTTOM);
+ }
+ bucket.intersecting = actuallyIntersecting || preIntersecting;
+ bucket.actuallyIntersecting = actuallyIntersecting;
+ if (preIntersecting || actuallyIntersecting) {
+ this.clearDeferredLayout(bucket);
+ }
+ }
+
+ #processPendingChanges = throttle(() => {
+ const { add, update, remove } = this.#getPendingChangeBatches();
+ if (add.length > 0) {
+ this.addAssets(add);
+ }
+ if (update.length > 0) {
+ this.updateAssets(update);
+ }
+ if (remove.length > 0) {
+ this.removeAssets(remove);
+ }
+ this.#pendingChanges = [];
+ }, 2500);
+
+ async #initializeTimeBuckets() {
+ const timebuckets = await getTimeBuckets({
+ ...this.#options,
+ key: authManager.key,
+ });
+
+ this.buckets = timebuckets.map((bucket) => {
+ const date = new Date(bucket.timeBucket);
+ return new AssetBucket(
+ this,
+ { year: date.getUTCFullYear(), month: date.getUTCMonth() + 1 },
+ bucket.count,
+ this.#options.order,
+ );
+ });
+ this.albumAssets.clear();
+ this.#updateViewportGeometry(false);
+ }
+
+ async updateOptions(options: AssetStoreOptions) {
+ if (options.deferInit) {
+ return;
+ }
+ if (this.#options !== AssetStore.#INIT_OPTIONS && isEqual(this.#options, options)) {
+ return;
+ }
+ await this.initTask.reset();
+ await this.#init(options);
+ this.#updateViewportGeometry(false);
+ }
+
+ async #init(options: AssetStoreOptions) {
+ this.isInitialized = false;
+ this.buckets = [];
+ this.albumAssets.clear();
+ await this.initTask.execute(async () => {
+ this.#options = options;
+ await this.#initializeTimeBuckets();
+ }, true);
+ }
+
+ public destroy() {
+ this.disconnect();
+ 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);
+ }
+
+ #updateViewportGeometry(changedWidth: boolean) {
+ if (!this.isInitialized) {
+ return;
+ }
+ if (this.viewportWidth === 0 || this.viewportHeight === 0) {
+ return;
+ }
+ for (const bucket of this.buckets) {
+ this.#updateGeometry(bucket, { invalidateHeight: changedWidth });
+ }
+ this.updateIntersections();
+ this.#createScrubBuckets();
+ }
+
+ #createScrubBuckets() {
+ this.scrubberBuckets = this.buckets.map((bucket) => ({
+ assetCount: bucket.bucketCount,
+ year: bucket.yearMonth.year,
+ month: bucket.yearMonth.month,
+ bucketDateFormattted: bucket.bucketDateFormatted,
+ bucketHeight: bucket.bucketHeight,
+ }));
+ this.scrubberTimelineHeight = this.timelineHeight;
+ }
+
+ createLayoutOptions() {
+ const viewportWidth = this.viewportWidth;
+
+ return {
+ spacing: 2,
+ heightTolerance: 0.15,
+ rowHeight: this.#rowHeight,
+ rowWidth: Math.floor(viewportWidth),
+ };
+ }
+
+ #updateGeometry(bucket: AssetBucket, options: UpdateGeometryOptions) {
+ const { invalidateHeight, noDefer = false } = options;
+ if (invalidateHeight) {
+ bucket.isBucketHeightActual = false;
+ }
+ if (!bucket.isLoaded) {
+ const viewportWidth = this.viewportWidth;
+ if (!bucket.isBucketHeightActual) {
+ const unwrappedWidth = (3 / 2) * bucket.bucketCount * this.#rowHeight * (7 / 10);
+ const rows = Math.ceil(unwrappedWidth / viewportWidth);
+ const height = 51 + Math.max(1, rows) * this.#rowHeight;
+ bucket.bucketHeight = height;
+ }
+ return;
+ }
+ this.#layoutBucket(bucket, noDefer);
+ }
+
+ #layoutBucket(bucket: AssetBucket, noDefer: boolean = false) {
+ let cummulativeHeight = 0;
+ let cummulativeWidth = 0;
+ let lastRowHeight = 0;
+ let lastRow = 0;
+
+ let dateGroupRow = 0;
+ let dateGroupCol = 0;
+
+ const rowSpaceRemaining: number[] = Array.from({ length: bucket.dateGroups.length });
+ rowSpaceRemaining.fill(this.viewportWidth, 0, bucket.dateGroups.length);
+ const options = this.createLayoutOptions();
+ for (const assetGroup of bucket.dateGroups) {
+ assetGroup.layout(options, noDefer);
+ rowSpaceRemaining[dateGroupRow] -= assetGroup.width - 1;
+ if (dateGroupCol > 0) {
+ rowSpaceRemaining[dateGroupRow] -= this.gap;
+ }
+ if (rowSpaceRemaining[dateGroupRow] >= 0) {
+ assetGroup.row = dateGroupRow;
+ assetGroup.col = dateGroupCol;
+ assetGroup.left = cummulativeWidth;
+ assetGroup.top = cummulativeHeight;
+
+ dateGroupCol++;
+
+ cummulativeWidth += assetGroup.width + this.gap;
+ } else {
+ cummulativeWidth = 0;
+ dateGroupRow++;
+ dateGroupCol = 0;
+ assetGroup.row = dateGroupRow;
+ assetGroup.col = dateGroupCol;
+ assetGroup.left = cummulativeWidth;
+
+ rowSpaceRemaining[dateGroupRow] -= assetGroup.width;
+ dateGroupCol++;
+ cummulativeHeight += lastRowHeight;
+ assetGroup.top = cummulativeHeight;
+ cummulativeWidth += assetGroup.width + this.gap;
+ lastRow = assetGroup.row - 1;
+ }
+ lastRowHeight = assetGroup.height + this.headerHeight;
+ }
+ if (lastRow === 0 || lastRow !== bucket.lastDateGroup?.row) {
+ cummulativeHeight += lastRowHeight;
+ }
+
+ bucket.bucketHeight = cummulativeHeight;
+ bucket.isBucketHeightActual = true;
+ }
+
+ async loadBucket(yearMonth: TimelinePlainYearMonth, options?: { cancelable: boolean }): Promise<void> {
+ let cancelable = true;
+ if (options) {
+ cancelable = options.cancelable;
+ }
+ const bucket = this.getBucketByDate(yearMonth);
+ if (!bucket) {
+ return;
+ }
+
+ if (bucket.loader?.executed) {
+ return;
+ }
+
+ const result = await bucket.loader?.execute(async (signal: AbortSignal) => {
+ if (bucket.getFirstAsset()) {
+ return;
+ }
+ const timeBucket = toISOLocalDateTime(bucket.yearMonth);
+ const key = authManager.key;
+ const bucketResponse = await getTimeBucket(
+ {
+ ...this.#options,
+ timeBucket,
+ key,
+ },
+ { signal },
+ );
+ if (bucketResponse) {
+ if (this.#options.timelineAlbumId) {
+ const albumAssets = await getTimeBucket(
+ {
+ albumId: this.#options.timelineAlbumId,
+ timeBucket,
+ key,
+ },
+ { signal },
+ );
+ for (const id of albumAssets.id) {
+ this.albumAssets.add(id);
+ }
+ }
+ const unprocessedAssets = bucket.addAssets(bucketResponse);
+ if (unprocessedAssets.length > 0) {
+ console.error(
+ `Warning: getTimeBucket API returning assets not in requested month: ${bucket.yearMonth.month}, ${JSON.stringify(
+ unprocessedAssets.map((unprocessed) => ({
+ id: unprocessed.id,
+ localDateTime: unprocessed.localDateTime,
+ })),
+ )}`,
+ );
+ }
+ this.#layoutBucket(bucket);
+ }
+ }, cancelable);
+ if (result === 'LOADED') {
+ this.#updateIntersection(bucket);
+ }
+ }
+
+ addAssets(assets: TimelineAsset[]) {
+ const assetsToUpdate: TimelineAsset[] = [];
+
+ for (const asset of assets) {
+ if (this.isExcluded(asset)) {
+ continue;
+ }
+ assetsToUpdate.push(asset);
+ }
+
+ const notUpdated = this.updateAssets(assetsToUpdate);
+ this.#addAssetsToBuckets([...notUpdated]);
+ }
+
+ #addAssetsToBuckets(assets: TimelineAsset[]) {
+ if (assets.length === 0) {
+ return;
+ }
+
+ const addContext = new AddContext();
+ const updatedBuckets = new Set<AssetBucket>();
+ const bucketCount = this.buckets.length;
+ for (const asset of assets) {
+ let bucket = this.getBucketByDate(asset.localDateTime);
+
+ if (!bucket) {
+ bucket = new AssetBucket(this, asset.localDateTime, 1, this.#options.order);
+ bucket.isLoaded = true;
+ this.buckets.push(bucket);
+ }
+
+ bucket.addTimelineAsset(asset, addContext);
+ updatedBuckets.add(bucket);
+ }
+
+ if (this.buckets.length !== bucketCount) {
+ this.buckets.sort((a, b) => {
+ return a.yearMonth.year === b.yearMonth.year
+ ? b.yearMonth.month - a.yearMonth.month
+ : b.yearMonth.year - a.yearMonth.year;
+ });
+ }
+
+ for (const group of addContext.existingDateGroups) {
+ group.sortAssets(this.#options.order);
+ }
+
+ for (const bucket of addContext.bucketsWithNewDateGroups) {
+ bucket.sortDateGroups();
+ }
+
+ for (const bucket of addContext.updatedBuckets) {
+ bucket.sortDateGroups();
+ this.#updateGeometry(bucket, { invalidateHeight: true });
+ }
+ this.updateIntersections();
+ }
+
+ getBucketByDate(targetYearMonth: TimelinePlainYearMonth): AssetBucket | undefined {
+ return this.buckets.find(
+ (bucket) => bucket.yearMonth.year === targetYearMonth.year && bucket.yearMonth.month === targetYearMonth.month,
+ );
+ }
+
+ async findBucketForAsset(id: string) {
+ if (!this.isInitialized) {
+ await this.initTask.waitUntilCompletion();
+ }
+ let { bucket } = this.#findBucketForAsset(id) ?? {};
+ if (bucket) {
+ return bucket;
+ }
+ const asset = toTimelineAsset(await getAssetInfo({ id, key: authManager.key }));
+ if (!asset || this.isExcluded(asset)) {
+ return;
+ }
+ bucket = await this.#loadBucketAtTime(asset.localDateTime, { cancelable: false });
+ if (bucket?.findAssetById({ id })) {
+ return bucket;
+ }
+ }
+
+ async #loadBucketAtTime(yearMonth: TimelinePlainYearMonth, options?: { cancelable: boolean }) {
+ await this.loadBucket(yearMonth, options);
+ return this.getBucketByDate(yearMonth);
+ }
+
+ getBucketIndexByAssetId(assetId: string) {
+ const bucketInfo = this.#findBucketForAsset(assetId);
+ return bucketInfo?.bucket;
+ }
+
+ async getRandomBucket() {
+ const random = Math.floor(Math.random() * this.buckets.length);
+ const bucket = this.buckets[random];
+ await this.loadBucket(bucket.yearMonth, { cancelable: false });
+ return bucket;
+ }
+
+ async getRandomAsset() {
+ const bucket = await this.getRandomBucket();
+ return bucket?.getRandomAsset();
+ }
+
+ #runAssetOperation(ids: Set<string>, operation: AssetOperation) {
+ if (ids.size === 0) {
+ return { processedIds: new Set(), unprocessedIds: ids, changedGeometry: false };
+ }
+
+ const changedBuckets = new Set<AssetBucket>();
+ let idsToProcess = new Set(ids);
+ const idsProcessed = new Set<string>();
+ const combinedMoveAssets: { asset: TimelineAsset; date: TimelinePlainDate }[][] = [];
+ for (const bucket of this.buckets) {
+ if (idsToProcess.size > 0) {
+ const { moveAssets, processedIds, changedGeometry } = bucket.runAssetOperation(idsToProcess, operation);
+ if (moveAssets.length > 0) {
+ combinedMoveAssets.push(moveAssets);
+ }
+ idsToProcess = idsToProcess.difference(processedIds);
+ for (const id of processedIds) {
+ idsProcessed.add(id);
+ }
+ if (changedGeometry) {
+ changedBuckets.add(bucket);
+ }
+ }
+ }
+ if (combinedMoveAssets.length > 0) {
+ this.#addAssetsToBuckets(combinedMoveAssets.flat().map((a) => a.asset));
+ }
+ const changedGeometry = changedBuckets.size > 0;
+ for (const bucket of changedBuckets) {
+ this.#updateGeometry(bucket, { invalidateHeight: true });
+ }
+ if (changedGeometry) {
+ this.updateIntersections();
+ }
+ return { unprocessedIds: idsToProcess, processedIds: idsProcessed, changedGeometry };
+ }
+
+ updateAssetOperation(ids: string[], operation: AssetOperation) {
+ this.#runAssetOperation(new Set(ids), operation);
+ }
+
+ updateAssets(assets: TimelineAsset[]) {
+ const lookup = new Map<string, TimelineAsset>(assets.map((asset) => [asset.id, asset]));
+ const { unprocessedIds } = this.#runAssetOperation(new Set(lookup.keys()), (asset) => {
+ updateObject(asset, lookup.get(asset.id));
+ return { remove: false };
+ });
+ return unprocessedIds.values().map((id) => lookup.get(id)!);
+ }
+
+ removeAssets(ids: string[]) {
+ const { unprocessedIds } = this.#runAssetOperation(new Set(ids), () => {
+ return { remove: true };
+ });
+ return [...unprocessedIds];
+ }
+
+ refreshLayout() {
+ for (const bucket of this.buckets) {
+ this.#updateGeometry(bucket, { invalidateHeight: true });
+ }
+ this.updateIntersections();
+ }
+
+ getFirstAsset(): TimelineAsset | undefined {
+ return this.buckets[0]?.getFirstAsset();
+ }
+
+ async getLaterAsset(
+ assetDescriptor: AssetDescriptor,
+ interval: 'asset' | 'day' | 'month' | 'year' = 'asset',
+ ): Promise<TimelineAsset | undefined> {
+ return await this.#getAssetWithOffset(assetDescriptor, interval, 'later');
+ }
+
+ async getEarlierAsset(
+ assetDescriptor: AssetDescriptor,
+ interval: 'asset' | 'day' | 'month' | 'year' = 'asset',
+ ): Promise<TimelineAsset | undefined> {
+ return await this.#getAssetWithOffset(assetDescriptor, interval, 'earlier');
+ }
+
+ async getClosestAssetToDate(dateTime: TimelinePlainDateTime) {
+ const bucket = this.#findBucketForDate(dateTime);
+ if (!bucket) {
+ return;
+ }
+ await this.loadBucket(dateTime, { cancelable: false });
+ const asset = bucket.findClosest(dateTime);
+ if (asset) {
+ return asset;
+ }
+ for await (const asset of this.assetsIterator({ startBucket: bucket })) {
+ return asset;
+ }
+ }
+
+ async retrieveRange(start: AssetDescriptor, end: AssetDescriptor) {
+ let { asset: startAsset, bucket: startBucket } = this.#findBucketForAsset(start.id) ?? {};
+ if (!startBucket || !startAsset) {
+ return [];
+ }
+ let { asset: endAsset, bucket: endBucket } = this.#findBucketForAsset(end.id) ?? {};
+ if (!endBucket || !endAsset) {
+ return [];
+ }
+ let direction: Direction = 'earlier';
+ if (plainDateTimeCompare(true, startAsset.localDateTime, endAsset.localDateTime) < 0) {
+ [startAsset, endAsset] = [endAsset, startAsset];
+ [startBucket, endBucket] = [endBucket, startBucket];
+ direction = 'earlier';
+ }
+
+ const range: TimelineAsset[] = [];
+ const startDateGroup = startBucket.findDateGroupForAsset(startAsset);
+ for await (const targetAsset of this.assetsIterator({
+ startBucket,
+ startDateGroup,
+ startAsset,
+ direction,
+ })) {
+ range.push(targetAsset);
+ if (targetAsset.id === endAsset.id) {
+ break;
+ }
+ }
+ return range;
+ }
+
+ async #getAssetWithOffset(
+ assetDescriptor: AssetDescriptor,
+ interval: 'asset' | 'day' | 'month' | 'year' = 'asset',
+ direction: Direction,
+ ): Promise<TimelineAsset | undefined> {
+ const { asset, bucket } = this.#findBucketForAsset(assetDescriptor.id) ?? {};
+ if (!bucket || !asset) {
+ return;
+ }
+
+ switch (interval) {
+ case 'asset': {
+ return this.#getAssetByAssetOffset(asset, bucket, direction);
+ }
+ case 'day': {
+ return this.#getAssetByDayOffset(asset, bucket, direction);
+ }
+ case 'month': {
+ return this.#getAssetByMonthOffset(bucket, direction);
+ }
+ case 'year': {
+ return this.#getAssetByYearOffset(bucket, direction);
+ }
+ }
+ }
+
+ async #getAssetByAssetOffset(asset: TimelineAsset, bucket: AssetBucket, direction: Direction) {
+ const dateGroup = bucket.findDateGroupForAsset(asset);
+ for await (const targetAsset of this.assetsIterator({
+ startBucket: bucket,
+ startDateGroup: dateGroup,
+ startAsset: asset,
+ direction,
+ })) {
+ if (asset.id === targetAsset.id) {
+ continue;
+ }
+ return targetAsset;
+ }
+ }
+
+ async #getAssetByDayOffset(asset: TimelineAsset, bucket: AssetBucket, direction: Direction) {
+ const dateGroup = bucket.findDateGroupForAsset(asset);
+ for await (const targetAsset of this.assetsIterator({
+ startBucket: bucket,
+ startDateGroup: dateGroup,
+ startAsset: asset,
+ direction,
+ })) {
+ if (targetAsset.localDateTime.day !== asset.localDateTime.day) {
+ return targetAsset;
+ }
+ }
+ }
+
+ async #getAssetByMonthOffset(bucket: AssetBucket, direction: Direction) {
+ for (const targetBucket of this.bucketsIterator({ startBucket: bucket, direction })) {
+ if (targetBucket.yearMonth.month !== bucket.yearMonth.month) {
+ for await (const targetAsset of this.assetsIterator({ startBucket: targetBucket, direction })) {
+ return targetAsset;
+ }
+ }
+ }
+ }
+
+ async #getAssetByYearOffset(bucket: AssetBucket, direction: Direction) {
+ for (const targetBucket of this.bucketsIterator({ startBucket: bucket, direction })) {
+ if (targetBucket.yearMonth.year !== bucket.yearMonth.year) {
+ for await (const targetAsset of this.assetsIterator({ startBucket: targetBucket, direction })) {
+ return targetAsset;
+ }
+ }
+ }
+ }
+
+ isExcluded(asset: TimelineAsset) {
+ return (
+ isMismatched(this.#options.visibility, asset.visibility) ||
+ isMismatched(this.#options.isFavorite, asset.isFavorite) ||
+ isMismatched(this.#options.isTrashed, asset.isTrashed)
+ );
+ }
+}
diff --git a/web/src/lib/managers/timeline-manager/intersecting-asset.svelte.ts b/web/src/lib/managers/timeline-manager/intersecting-asset.svelte.ts
new file mode 100644
index 0000000000..e2928a8076
--- /dev/null
+++ b/web/src/lib/managers/timeline-manager/intersecting-asset.svelte.ts
@@ -0,0 +1,45 @@
+import type { CommonPosition } from '$lib/utils/layout-utils';
+import { TUNABLES } from '$lib/utils/tunables';
+import type { AssetDateGroup } from './asset-date-group.svelte';
+import type { TimelineAsset } from './types';
+
+const {
+ TIMELINE: { INTERSECTION_EXPAND_TOP, INTERSECTION_EXPAND_BOTTOM },
+} = TUNABLES;
+
+export class IntersectingAsset {
+ readonly #group: AssetDateGroup;
+
+ intersecting = $derived.by(() => {
+ if (!this.position) {
+ return false;
+ }
+
+ const store = this.#group.bucket.store;
+
+ const scrollCompensation = store.scrollCompensation;
+ const scrollCompensationHeightDelta = scrollCompensation?.heightDelta ?? 0;
+
+ const topWindow =
+ store.visibleWindow.top - store.headerHeight - INTERSECTION_EXPAND_TOP + scrollCompensationHeightDelta;
+ const bottomWindow =
+ store.visibleWindow.bottom + store.headerHeight + INTERSECTION_EXPAND_BOTTOM + scrollCompensationHeightDelta;
+ const positionTop = this.#group.absoluteDateGroupTop + this.position.top;
+ const positionBottom = positionTop + this.position.height;
+
+ const intersecting =
+ (positionTop >= topWindow && positionTop < bottomWindow) ||
+ (positionBottom >= topWindow && positionBottom < bottomWindow) ||
+ (positionTop < topWindow && positionBottom >= bottomWindow);
+ return intersecting;
+ });
+
+ position: CommonPosition | undefined = $state();
+ asset: TimelineAsset = <TimelineAsset>$state();
+ id: string | undefined = $derived(this.asset?.id);
+
+ constructor(group: AssetDateGroup, asset: TimelineAsset) {
+ this.#group = group;
+ this.asset = asset;
+ }
+}
diff --git a/web/src/lib/managers/timeline-manager/types.ts b/web/src/lib/managers/timeline-manager/types.ts
new file mode 100644
index 0000000000..778ac69f26
--- /dev/null
+++ b/web/src/lib/managers/timeline-manager/types.ts
@@ -0,0 +1,93 @@
+import type { TimelinePlainDate, TimelinePlainDateTime } from '$lib/utils/timeline-util';
+import type { AssetStackResponseDto, AssetVisibility } from '@immich/sdk';
+
+export type AssetApiGetTimeBucketsRequest = Parameters<typeof import('@immich/sdk').getTimeBuckets>[0];
+
+export type AssetStoreOptions = Omit<AssetApiGetTimeBucketsRequest, 'size'> & {
+ timelineAlbumId?: string;
+ deferInit?: boolean;
+};
+
+export type AssetDescriptor = { id: string };
+
+export type Direction = 'earlier' | 'later';
+
+export type TimelineAsset = {
+ id: string;
+ ownerId: string;
+ ratio: number;
+ thumbhash: string | null;
+ localDateTime: TimelinePlainDateTime;
+ visibility: AssetVisibility;
+ isFavorite: boolean;
+ isTrashed: boolean;
+ isVideo: boolean;
+ isImage: boolean;
+ stack: AssetStackResponseDto | null;
+ duration: string | null;
+ projectionType: string | null;
+ livePhotoVideoId: string | null;
+ city: string | null;
+ country: string | null;
+ people: string[];
+};
+
+export type AssetOperation = (asset: TimelineAsset) => { remove: boolean };
+
+export type MoveAsset = { asset: TimelineAsset; date: TimelinePlainDate };
+
+export interface Viewport {
+ width: number;
+ height: number;
+}
+
+export type ViewportXY = Viewport & {
+ x: number;
+ y: number;
+};
+
+export interface AddAsset {
+ type: 'add';
+ values: TimelineAsset[];
+}
+
+export interface UpdateAsset {
+ type: 'update';
+ values: TimelineAsset[];
+}
+
+export interface DeleteAsset {
+ type: 'delete';
+ values: string[];
+}
+
+export interface TrashAssets {
+ type: 'trash';
+ values: string[];
+}
+
+export interface UpdateStackAssets {
+ type: 'update_stack_assets';
+ values: string[];
+}
+
+export type PendingChange = AddAsset | UpdateAsset | DeleteAsset | TrashAssets | UpdateStackAssets;
+
+export type LiteBucket = {
+ bucketHeight: number;
+ assetCount: number;
+ year: number;
+ month: number;
+ bucketDateFormattted: string;
+};
+
+export type AssetStoreLayoutOptions = {
+ rowHeight?: number;
+ headerHeight?: number;
+ gap?: number;
+};
+
+export interface UpdateGeometryOptions {
+ invalidateHeight: boolean;
+ noDefer?: boolean;
+}
diff --git a/web/src/lib/managers/timeline-manager/utils.svelte.ts b/web/src/lib/managers/timeline-manager/utils.svelte.ts
new file mode 100644
index 0000000000..e036a77af9
--- /dev/null
+++ b/web/src/lib/managers/timeline-manager/utils.svelte.ts
@@ -0,0 +1,34 @@
+import type { TimelineAsset } from './types';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function updateObject(target: any, source: any): boolean {
+ if (!target) {
+ return false;
+ }
+ let updated = false;
+ for (const key in source) {
+ if (!Object.prototype.hasOwnProperty.call(source, key)) {
+ continue;
+ }
+ if (key === '__proto__' || key === 'constructor') {
+ continue;
+ }
+ const isDate = target[key] instanceof Date;
+ if (typeof target[key] === 'object' && !isDate) {
+ updated = updated || updateObject(target[key], source[key]);
+ } else {
+ if (target[key] !== source[key]) {
+ target[key] = source[key];
+ updated = true;
+ }
+ }
+ }
+ return updated;
+}
+
+export function isMismatched<T>(option: T | undefined, value: T): boolean {
+ return option === undefined ? false : option !== value;
+}
+
+export const assetSnapshot = (asset: TimelineAsset): TimelineAsset => $state.snapshot(asset);
+export const assetsSnapshot = (assets: TimelineAsset[]) => assets.map((asset) => $state.snapshot(asset));
diff --git a/web/src/lib/stores/asset-interaction.svelte.ts b/web/src/lib/stores/asset-interaction.svelte.ts
index 41ce8c8d27..9dee11f238 100644
--- a/web/src/lib/stores/asset-interaction.svelte.ts
+++ b/web/src/lib/stores/asset-interaction.svelte.ts
@@ -1,4 +1,4 @@
-import type { TimelineAsset } from '$lib/stores/assets-store.svelte';
+import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
import { user } from '$lib/stores/user.store';
import { AssetVisibility, type UserAdminResponseDto } from '@immich/sdk';
import { SvelteSet } from 'svelte/reactivity';
diff --git a/web/src/lib/stores/asset-viewing.store.ts b/web/src/lib/stores/asset-viewing.store.ts
index 84d6852fed..2cd20d9d20 100644
--- a/web/src/lib/stores/asset-viewing.store.ts
+++ b/web/src/lib/stores/asset-viewing.store.ts
@@ -1,5 +1,5 @@
import { authManager } from '$lib/managers/auth-manager.svelte';
-import type { TimelineAsset } from '$lib/stores/assets-store.svelte';
+import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
import { type AssetGridRouteSearchParams } from '$lib/utils/navigation';
import { getAssetInfo, type AssetResponseDto } from '@immich/sdk';
import { readonly, writable } from 'svelte/store';
diff --git a/web/src/lib/stores/assets-store.spec.ts b/web/src/lib/stores/assets-store.spec.ts
index c6e7686cdc..e17015ace2 100644
--- a/web/src/lib/stores/assets-store.spec.ts
+++ b/web/src/lib/stores/assets-store.spec.ts
@@ -1,9 +1,10 @@
import { sdkMock } from '$lib/__mocks__/sdk.mock';
+import { AssetStore } from '$lib/managers/timeline-manager/asset-store.svelte';
+import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
import { AbortError } from '$lib/utils';
import { fromLocalDateTimeToObject } from '$lib/utils/timeline-util';
import { type AssetResponseDto, type TimeBucketAssetResponseDto } from '@immich/sdk';
import { timelineAssetFactory, toResponseDto } from '@test-data/factories/asset-factory';
-import { AssetStore, type TimelineAsset } from './assets-store.svelte';
async function getAssets(store: AssetStore) {
const assets = [];
diff --git a/web/src/lib/stores/assets-store.svelte.ts b/web/src/lib/stores/assets-store.svelte.ts
index 36b4da573a..cef5d98e3b 100644
--- a/web/src/lib/stores/assets-store.svelte.ts
+++ b/web/src/lib/stores/assets-store.svelte.ts
@@ -1,1676 +1,4 @@
-import { authManager } from '$lib/managers/auth-manager.svelte';
-
-import { CancellableTask } from '$lib/utils/cancellable-task';
-import {
- getJustifiedLayoutFromAssets,
- getPosition,
- type CommonLayoutOptions,
- type CommonPosition,
-} from '$lib/utils/layout-utils';
-import {
- formatBucketTitle,
- formatGroupTitle,
- fromLocalDateTimeToObject,
- fromTimelinePlainDate,
- fromTimelinePlainDateTime,
- fromTimelinePlainYearMonth,
- plainDateTimeCompare,
- toISOLocalDateTime,
- toTimelineAsset,
- type TimelinePlainDate,
- type TimelinePlainDateTime,
- type TimelinePlainYearMonth,
-} from '$lib/utils/timeline-util';
-import { TUNABLES } from '$lib/utils/tunables';
-import {
- AssetOrder,
- AssetVisibility,
- getAssetInfo,
- getTimeBucket,
- getTimeBuckets,
- type AssetStackResponseDto,
- type TimeBucketAssetResponseDto,
-} from '@immich/sdk';
-import { clamp, debounce, isEqual, throttle } from 'lodash-es';
-import { t } from 'svelte-i18n';
-import { SvelteSet } from 'svelte/reactivity';
-import { get, writable, type Unsubscriber } from 'svelte/store';
-import { handleError } from '../utils/handle-error';
-import { websocketEvents } from './websocket';
-const {
- TIMELINE: { INTERSECTION_EXPAND_TOP, INTERSECTION_EXPAND_BOTTOM },
-} = TUNABLES;
-
-type AssetApiGetTimeBucketsRequest = Parameters<typeof getTimeBuckets>[0];
-
-export type AssetStoreOptions = Omit<AssetApiGetTimeBucketsRequest, 'size'> & {
- timelineAlbumId?: string;
- deferInit?: boolean;
-};
-type AssetDescriptor = { id: string };
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function updateObject(target: any, source: any): boolean {
- if (!target) {
- return false;
- }
- let updated = false;
- for (const key in source) {
- // eslint-disable-next-line no-prototype-builtins
- if (!source.hasOwnProperty(key)) {
- continue;
- }
- const isDate = target[key] instanceof Date;
- if (typeof target[key] === 'object' && !isDate) {
- updated = updated || updateObject(target[key], source[key]);
- } else {
- // Otherwise, directly copy the value
- if (target[key] !== source[key]) {
- target[key] = source[key];
- updated = true;
- }
- }
- }
- return updated;
-}
-type Direction = 'earlier' | 'later';
-
-export const assetSnapshot = (asset: TimelineAsset): TimelineAsset => $state.snapshot(asset);
-export const assetsSnapshot = (assets: TimelineAsset[]) => assets.map((asset) => $state.snapshot(asset));
-
-export type TimelineAsset = {
- id: string;
- ownerId: string;
- ratio: number;
- thumbhash: string | null;
- localDateTime: TimelinePlainDateTime;
- visibility: AssetVisibility;
- isFavorite: boolean;
- isTrashed: boolean;
- isVideo: boolean;
- isImage: boolean;
- stack: AssetStackResponseDto | null;
- duration: string | null;
- projectionType: string | null;
- livePhotoVideoId: string | null;
- city: string | null;
- country: string | null;
- people: string[];
-};
-
-class IntersectingAsset {
- // --- public ---
- readonly #group: AssetDateGroup;
-
- intersecting = $derived.by(() => {
- if (!this.position) {
- return false;
- }
-
- const store = this.#group.bucket.store;
-
- const scrollCompensation = store.scrollCompensation;
- const scrollCompensationHeightDelta = scrollCompensation?.heightDelta ?? 0;
-
- const topWindow =
- store.visibleWindow.top - store.headerHeight - INTERSECTION_EXPAND_TOP + scrollCompensationHeightDelta;
- const bottomWindow =
- store.visibleWindow.bottom + store.headerHeight + INTERSECTION_EXPAND_BOTTOM + scrollCompensationHeightDelta;
- const positionTop = this.#group.absoluteDateGroupTop + this.position.top;
- const positionBottom = positionTop + this.position.height;
-
- const intersecting =
- (positionTop >= topWindow && positionTop < bottomWindow) ||
- (positionBottom >= topWindow && positionBottom < bottomWindow) ||
- (positionTop < topWindow && positionBottom >= bottomWindow);
- return intersecting;
- });
-
- position: CommonPosition | undefined = $state();
- asset: TimelineAsset = <TimelineAsset>$state();
- id: string | undefined = $derived(this.asset?.id);
-
- constructor(group: AssetDateGroup, asset: TimelineAsset) {
- this.#group = group;
- this.asset = asset;
- }
-}
-
-type AssetOperation = (asset: TimelineAsset) => { remove: boolean };
-
-type MoveAsset = { asset: TimelineAsset; date: TimelinePlainDate };
-
-export class AssetDateGroup {
- // --- public
- readonly bucket: AssetBucket;
- readonly index: number;
- readonly groupTitle: string;
- readonly day: number;
- intersectingAssets: IntersectingAsset[] = $state([]);
-
- height = $state(0);
- width = $state(0);
- intersecting = $derived.by(() => this.intersectingAssets.some((asset) => asset.intersecting));
-
- // --- private
- top: number = $state(0);
- left: number = $state(0);
- row = $state(0);
- col = $state(0);
- deferredLayout = false;
-
- constructor(bucket: AssetBucket, index: number, day: number, groupTitle: string) {
- this.index = index;
- this.bucket = bucket;
- this.day = day;
- this.groupTitle = groupTitle;
- }
-
- sortAssets(sortOrder: AssetOrder = AssetOrder.Desc) {
- const sortFn = plainDateTimeCompare.bind(undefined, sortOrder === AssetOrder.Asc);
- this.intersectingAssets.sort((a, b) => sortFn(a.asset.localDateTime, b.asset.localDateTime));
- }
-
- getFirstAsset() {
- return this.intersectingAssets[0]?.asset;
- }
-
- getRandomAsset() {
- const random = Math.floor(Math.random() * this.intersectingAssets.length);
- return this.intersectingAssets[random];
- }
-
- *assetsIterator(options: { startAsset?: TimelineAsset; direction?: Direction } = {}) {
- const isEarlier = (options?.direction ?? 'earlier') === 'earlier';
- let assetIndex = options?.startAsset
- ? this.intersectingAssets.findIndex((intersectingAsset) => intersectingAsset.asset.id === options.startAsset!.id)
- : isEarlier
- ? 0
- : this.intersectingAssets.length - 1;
-
- while (assetIndex >= 0 && assetIndex < this.intersectingAssets.length) {
- const intersectingAsset = this.intersectingAssets[assetIndex];
- yield intersectingAsset.asset;
- assetIndex += isEarlier ? 1 : -1;
- }
- }
-
- getAssets() {
- return this.intersectingAssets.map((intersectingasset) => intersectingasset.asset);
- }
-
- runAssetOperation(ids: Set<string>, operation: AssetOperation) {
- if (ids.size === 0) {
- return {
- moveAssets: [] as MoveAsset[],
- processedIds: new Set<string>(),
- unprocessedIds: ids,
- changedGeometry: false,
- };
- }
- const unprocessedIds = new Set<string>(ids);
- const processedIds = new Set<string>();
- const moveAssets: MoveAsset[] = [];
- let changedGeometry = false;
- for (const assetId of unprocessedIds) {
- const index = this.intersectingAssets.findIndex((ia) => ia.id == assetId);
- if (index === -1) {
- continue;
- }
-
- const asset = this.intersectingAssets[index].asset!;
- const oldTime = { ...asset.localDateTime };
- let { remove } = operation(asset);
- const newTime = asset.localDateTime;
- if (oldTime.year !== newTime.year || oldTime.month !== newTime.month || oldTime.day !== newTime.day) {
- const { year, month, day } = newTime;
- remove = true;
- moveAssets.push({ asset, date: { year, month, day } });
- }
- unprocessedIds.delete(assetId);
- processedIds.add(assetId);
- if (remove || this.bucket.store.isExcluded(asset)) {
- this.intersectingAssets.splice(index, 1);
- changedGeometry = true;
- }
- }
- return { moveAssets, processedIds, unprocessedIds, changedGeometry };
- }
-
- layout(options: CommonLayoutOptions, noDefer: boolean) {
- if (!noDefer && !this.bucket.intersecting) {
- this.deferredLayout = true;
- return;
- }
- const assets = this.intersectingAssets.map((intersetingAsset) => intersetingAsset.asset!);
- const geometry = getJustifiedLayoutFromAssets(assets, options);
- this.width = geometry.containerWidth;
- this.height = assets.length === 0 ? 0 : geometry.containerHeight;
- for (let i = 0; i < this.intersectingAssets.length; i++) {
- const position = getPosition(geometry, i);
- this.intersectingAssets[i].position = position;
- }
- }
-
- get absoluteDateGroupTop() {
- return this.bucket.top + this.top;
- }
-}
-
-export interface Viewport {
- width: number;
- height: number;
-}
-
-export type ViewportXY = Viewport & {
- x: number;
- y: number;
-};
-
-class AddContext {
- lookupCache: {
- [year: number]: { [month: number]: { [day: number]: AssetDateGroup } };
- } = {};
- unprocessedAssets: TimelineAsset[] = [];
- changedDateGroups = new Set<AssetDateGroup>();
- newDateGroups = new Set<AssetDateGroup>();
-
- getDateGroup({ year, month, day }: TimelinePlainDate): AssetDateGroup | undefined {
- return this.lookupCache[year]?.[month]?.[day];
- }
-
- setDateGroup(dateGroup: AssetDateGroup, { year, month, day }: TimelinePlainDate) {
- if (!this.lookupCache[year]) {
- this.lookupCache[year] = {};
- }
- if (!this.lookupCache[year][month]) {
- this.lookupCache[year][month] = {};
- }
- this.lookupCache[year][month][day] = dateGroup;
- }
-
- get existingDateGroups() {
- return this.changedDateGroups.difference(this.newDateGroups);
- }
-
- get updatedBuckets() {
- const updated = new Set<AssetBucket>();
- for (const group of this.changedDateGroups) {
- updated.add(group.bucket);
- }
- return updated;
- }
-
- get bucketsWithNewDateGroups() {
- const updated = new Set<AssetBucket>();
- for (const group of this.newDateGroups) {
- updated.add(group.bucket);
- }
- return updated;
- }
-
- sort(bucket: AssetBucket, sortOrder: AssetOrder = AssetOrder.Desc) {
- for (const group of this.changedDateGroups) {
- group.sortAssets(sortOrder);
- }
- for (const group of this.newDateGroups) {
- group.sortAssets(sortOrder);
- }
- if (this.newDateGroups.size > 0) {
- bucket.sortDateGroups();
- }
- }
-}
-
-export class AssetBucket {
- // --- public ---
- #intersecting: boolean = $state(false);
- actuallyIntersecting: boolean = $state(false);
- isLoaded: boolean = $state(false);
- dateGroups: AssetDateGroup[] = $state([]);
- readonly store: AssetStore;
-
- // --- private ---
- /**
- * The DOM height of the bucket in pixel
- * This value is first estimated by the number of asset and later is corrected as the user scroll
- * Do not derive this height, it is important for it to be updated at specific times, so that
- * calculateing a delta between estimated and actual (when measured) is correct.
- */
- #bucketHeight: number = $state(0);
- #top: number = $state(0);
-
- #initialCount: number = 0;
- #sortOrder: AssetOrder = AssetOrder.Desc;
- percent: number = $state(0);
- // --- should be private, but is used by AssetStore ---
-
- bucketCount: number = $derived(
- this.isLoaded
- ? this.dateGroups.reduce((accumulator, g) => accumulator + g.intersectingAssets.length, 0)
- : this.#initialCount,
- );
- loader: CancellableTask | undefined;
- isBucketHeightActual: boolean = $state(false);
-
- readonly bucketDateFormatted: string;
- readonly yearMonth: TimelinePlainYearMonth;
-
- constructor(
- store: AssetStore,
- yearMonth: TimelinePlainYearMonth,
- initialCount: number,
- order: AssetOrder = AssetOrder.Desc,
- ) {
- this.store = store;
- this.#initialCount = initialCount;
- this.#sortOrder = order;
-
- this.yearMonth = yearMonth;
- this.bucketDateFormatted = formatBucketTitle(fromTimelinePlainYearMonth(yearMonth));
-
- this.loader = new CancellableTask(
- () => {
- this.isLoaded = true;
- },
- () => {
- this.dateGroups = [];
- this.isLoaded = false;
- },
- this.handleLoadError,
- );
- }
-
- set intersecting(newValue: boolean) {
- const old = this.#intersecting;
- if (old === newValue) {
- return;
- }
- this.#intersecting = newValue;
- if (newValue) {
- void this.store.loadBucket(this.yearMonth);
- } else {
- this.cancel();
- }
- }
-
- get intersecting() {
- return this.#intersecting;
- }
-
- get lastDateGroup() {
- return this.dateGroups.at(-1);
- }
-
- getFirstAsset() {
- return this.dateGroups[0]?.getFirstAsset();
- }
-
- getAssets() {
- // eslint-disable-next-line unicorn/no-array-reduce
- return this.dateGroups.reduce(
- (accumulator: TimelineAsset[], g: AssetDateGroup) => accumulator.concat(g.getAssets()),
- [],
- );
- }
-
- sortDateGroups() {
- if (this.#sortOrder === AssetOrder.Asc) {
- return this.dateGroups.sort((a, b) => a.day - b.day);
- }
-
- return this.dateGroups.sort((a, b) => b.day - a.day);
- }
-
- runAssetOperation(ids: Set<string>, operation: AssetOperation) {
- if (ids.size === 0) {
- return {
- moveAssets: [] as MoveAsset[],
- processedIds: new Set<string>(),
- unprocessedIds: ids,
- changedGeometry: false,
- };
- }
- const { dateGroups } = this;
- let combinedChangedGeometry = false;
- let idsToProcess = new Set(ids);
- const idsProcessed = new Set<string>();
- const combinedMoveAssets: MoveAsset[][] = [];
- let index = dateGroups.length;
- while (index--) {
- if (idsToProcess.size > 0) {
- const group = dateGroups[index];
- const { moveAssets, processedIds, changedGeometry } = group.runAssetOperation(ids, operation);
- if (moveAssets.length > 0) {
- combinedMoveAssets.push(moveAssets);
- }
- idsToProcess = idsToProcess.difference(processedIds);
- for (const id of processedIds) {
- idsProcessed.add(id);
- }
- combinedChangedGeometry = combinedChangedGeometry || changedGeometry;
- if (group.intersectingAssets.length === 0) {
- dateGroups.splice(index, 1);
- combinedChangedGeometry = true;
- }
- }
- }
- return {
- moveAssets: combinedMoveAssets.flat(),
- unprocessedIds: idsToProcess,
- processedIds: idsProcessed,
- changedGeometry: combinedChangedGeometry,
- };
- }
-
- addAssets(bucketAssets: TimeBucketAssetResponseDto) {
- const addContext = new AddContext();
- const people: string[] = [];
- for (let i = 0; i < bucketAssets.id.length; i++) {
- const timelineAsset: TimelineAsset = {
- city: bucketAssets.city[i],
- country: bucketAssets.country[i],
- duration: bucketAssets.duration[i],
- id: bucketAssets.id[i],
- visibility: bucketAssets.visibility[i],
- isFavorite: bucketAssets.isFavorite[i],
- isImage: bucketAssets.isImage[i],
- isTrashed: bucketAssets.isTrashed[i],
- isVideo: !bucketAssets.isImage[i],
- livePhotoVideoId: bucketAssets.livePhotoVideoId[i],
- localDateTime: fromLocalDateTimeToObject(bucketAssets.localDateTime[i]),
- ownerId: bucketAssets.ownerId[i],
- people,
- projectionType: bucketAssets.projectionType[i],
- ratio: bucketAssets.ratio[i],
- stack: bucketAssets.stack?.[i]
- ? {
- id: bucketAssets.stack[i]![0],
- primaryAssetId: bucketAssets.id[i],
- assetCount: Number.parseInt(bucketAssets.stack[i]![1]),
- }
- : null,
- thumbhash: bucketAssets.thumbhash[i],
- };
- this.addTimelineAsset(timelineAsset, addContext);
- }
-
- for (const group of addContext.existingDateGroups) {
- group.sortAssets(this.#sortOrder);
- }
-
- if (addContext.newDateGroups.size > 0) {
- this.sortDateGroups();
- }
-
- addContext.sort(this, this.#sortOrder);
-
- return addContext.unprocessedAssets;
- }
-
- addTimelineAsset(timelineAsset: TimelineAsset, addContext: AddContext) {
- const { localDateTime } = timelineAsset;
-
- const { year, month } = this.yearMonth;
- if (month !== localDateTime.month || year !== localDateTime.year) {
- addContext.unprocessedAssets.push(timelineAsset);
- return;
- }
-
- let dateGroup = addContext.getDateGroup(localDateTime) || this.findDateGroupByDay(localDateTime.day);
- if (dateGroup) {
- addContext.setDateGroup(dateGroup, localDateTime);
- } else {
- const groupTitle = formatGroupTitle(fromTimelinePlainDate(localDateTime));
- dateGroup = new AssetDateGroup(this, this.dateGroups.length, localDateTime.day, groupTitle);
- this.dateGroups.push(dateGroup);
- addContext.setDateGroup(dateGroup, localDateTime);
- addContext.newDateGroups.add(dateGroup);
- }
-
- const intersectingAsset = new IntersectingAsset(dateGroup, timelineAsset);
- dateGroup.intersectingAssets.push(intersectingAsset);
- addContext.changedDateGroups.add(dateGroup);
- }
-
- getRandomDateGroup() {
- const random = Math.floor(Math.random() * this.dateGroups.length);
- return this.dateGroups[random];
- }
-
- getRandomAsset() {
- return this.getRandomDateGroup()?.getRandomAsset()?.asset;
- }
-
- /** The svelte key for this view model object */
- get viewId() {
- const { year, month } = this.yearMonth;
- return year + '-' + month;
- }
-
- set bucketHeight(height: number) {
- if (this.#bucketHeight === height) {
- return;
- }
- const { store, percent } = this;
- const index = store.buckets.indexOf(this);
- const bucketHeightDelta = height - this.#bucketHeight;
- this.#bucketHeight = height;
- const prevBucket = store.buckets[index - 1];
- if (prevBucket) {
- const newTop = prevBucket.#top + prevBucket.#bucketHeight;
- if (this.#top !== newTop) {
- this.#top = newTop;
- }
- }
- for (let cursor = index + 1; cursor < store.buckets.length; cursor++) {
- const bucket = this.store.buckets[cursor];
- const newTop = bucket.#top + bucketHeightDelta;
- if (bucket.#top !== newTop) {
- bucket.#top = newTop;
- }
- }
- if (store.topIntersectingBucket) {
- const currentIndex = store.buckets.indexOf(store.topIntersectingBucket);
- // if the bucket is 'before' the last intersecting bucket in the sliding window
- // then adjust the scroll position by the delta, to compensate for the bucket
- // size adjustment
- if (currentIndex > 0) {
- if (index < currentIndex) {
- store.scrollCompensation = {
- heightDelta: bucketHeightDelta,
- scrollTop: undefined,
- bucket: this,
- };
- } else if (percent > 0) {
- const top = this.top + height * percent;
- store.scrollCompensation = {
- heightDelta: undefined,
- scrollTop: top,
- bucket: this,
- };
- }
- }
- }
- }
-
- get bucketHeight() {
- return this.#bucketHeight;
- }
-
- get top(): number {
- return this.#top + this.store.topSectionHeight;
- }
-
- handleLoadError(error: unknown) {
- const _$t = get(t);
- handleError(error, _$t('errors.failed_to_load_assets'));
- }
-
- findDateGroupForAsset(asset: TimelineAsset) {
- for (const group of this.dateGroups) {
- if (group.intersectingAssets.some((IntersectingAsset) => IntersectingAsset.id === asset.id)) {
- return group;
- }
- }
- }
-
- findDateGroupByDay(day: number) {
- return this.dateGroups.find((group) => group.day === day);
- }
-
- findAssetAbsolutePosition(assetId: string) {
- this.store.clearDeferredLayout(this);
- for (const group of this.dateGroups) {
- const intersectingAsset = group.intersectingAssets.find((asset) => asset.id === assetId);
- if (intersectingAsset) {
- if (!intersectingAsset.position) {
- console.warn('No position for asset');
- break;
- }
- return this.top + group.top + intersectingAsset.position.top + this.store.headerHeight;
- }
- }
- return -1;
- }
-
- *assetsIterator(options?: { startDateGroup?: AssetDateGroup; startAsset?: TimelineAsset; direction?: Direction }) {
- const direction = options?.direction ?? 'earlier';
- let { startAsset } = options ?? {};
- const isEarlier = direction === 'earlier';
- let groupIndex = options?.startDateGroup
- ? this.dateGroups.indexOf(options.startDateGroup)
- : isEarlier
- ? 0
- : this.dateGroups.length - 1;
-
- while (groupIndex >= 0 && groupIndex < this.dateGroups.length) {
- const group = this.dateGroups[groupIndex];
- yield* group.assetsIterator({ startAsset, direction });
- startAsset = undefined;
- groupIndex += isEarlier ? 1 : -1;
- }
- }
-
- findAssetById(assetDescriptor: AssetDescriptor) {
- return this.assetsIterator().find((asset) => asset.id === assetDescriptor.id);
- }
-
- findClosest(target: TimelinePlainDateTime) {
- const targetDate = fromTimelinePlainDateTime(target);
- let closest = undefined;
- let smallestDiff = Infinity;
- for (const current of this.assetsIterator()) {
- const currentAssetDate = fromTimelinePlainDateTime(current.localDateTime);
- const diff = Math.abs(targetDate.diff(currentAssetDate).as('milliseconds'));
- if (diff < smallestDiff) {
- smallestDiff = diff;
- closest = current;
- }
- }
- return closest;
- }
-
- cancel() {
- this.loader?.cancel();
- }
-}
-
-const isMismatched = <T>(option: T | undefined, value: T): boolean => (option === undefined ? false : option !== value);
-
-interface AddAsset {
- type: 'add';
- values: TimelineAsset[];
-}
-
-interface UpdateAsset {
- type: 'update';
- values: TimelineAsset[];
-}
-
-interface DeleteAsset {
- type: 'delete';
- values: string[];
-}
-
-interface TrashAssets {
- type: 'trash';
- values: string[];
-}
-interface UpdateStackAssets {
- type: 'update_stack_assets';
- values: string[];
-}
+import { writable } from 'svelte/store';
export const photoViewerImgElement = writable<HTMLImageElement | null>(null);
-
-type PendingChange = AddAsset | UpdateAsset | DeleteAsset | TrashAssets | UpdateStackAssets;
-
-export type LiteBucket = {
- bucketHeight: number;
- assetCount: number;
- year: number;
- month: number;
- bucketDateFormattted: string;
-};
-
-type AssetStoreLayoutOptions = {
- rowHeight?: number;
- headerHeight?: number;
- gap?: number;
-};
-interface UpdateGeometryOptions {
- invalidateHeight: boolean;
- noDefer?: boolean;
-}
-
-export class AssetStore {
- // --- public ----
- isInitialized = $state(false);
- buckets: AssetBucket[] = $state([]);
- topSectionHeight = $state(0);
- timelineHeight = $derived(
- this.buckets.reduce((accumulator, b) => accumulator + b.bucketHeight, 0) + this.topSectionHeight,
- );
- count = $derived(this.buckets.reduce((accumulator, b) => accumulator + b.bucketCount, 0));
-
- // todo - name this better
- albumAssets: Set<string> = new SvelteSet();
-
- // -- for scrubber only
- scrubberBuckets: LiteBucket[] = $state([]);
- scrubberTimelineHeight: number = $state(0);
-
- // -- should be private, but used by AssetBucket
- topIntersectingBucket: AssetBucket | undefined = $state();
-
- visibleWindow = $derived.by(() => ({
- top: this.#scrollTop,
- bottom: this.#scrollTop + this.viewportHeight,
- }));
-
- initTask = new CancellableTask(
- () => {
- this.isInitialized = true;
- if (this.#options.albumId || this.#options.personId) {
- return;
- }
- this.connect();
- },
- () => {
- this.disconnect();
- this.isInitialized = false;
- },
- () => void 0,
- );
-
- // --- private
- static #INIT_OPTIONS = {};
- #viewportHeight = $state(0);
- #viewportWidth = $state(0);
- #scrollTop = $state(0);
- #pendingChanges: PendingChange[] = [];
- #unsubscribers: Unsubscriber[] = [];
-
- #rowHeight = $state(235);
- #headerHeight = $state(48);
- #gap = $state(12);
-
- #options: AssetStoreOptions = AssetStore.#INIT_OPTIONS;
-
- #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;
- bucket: AssetBucket | undefined;
- } = $state({
- heightDelta: 0,
- scrollTop: 0,
- bucket: undefined,
- });
-
- constructor() {}
-
- setLayoutOptions({ headerHeight = 48, rowHeight = 235, gap = 12 }: AssetStoreLayoutOptions) {
- 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;
- // side-effect - its ok!
- void this.#updateViewportGeometry(changed);
- }
-
- get viewportWidth() {
- return this.#viewportWidth;
- }
-
- set viewportHeight(value: number) {
- this.#viewportHeight = value;
- this.#suspendTransitions = true;
- // side-effect - its ok!
- void this.#updateViewportGeometry(false);
- }
-
- get viewportHeight() {
- return this.#viewportHeight;
- }
-
- async *assetsIterator(options?: {
- startBucket?: AssetBucket;
- startDateGroup?: AssetDateGroup;
- startAsset?: TimelineAsset;
- direction?: Direction;
- }) {
- const direction = options?.direction ?? 'earlier';
- let { startDateGroup, startAsset } = options ?? {};
- for (const bucket of this.bucketsIterator({ direction, startBucket: options?.startBucket })) {
- await this.loadBucket(bucket.yearMonth, { cancelable: false });
- yield* bucket.assetsIterator({ startDateGroup, startAsset, direction });
- // after the first bucket, we won't find startDateGroup or startAsset, so clear them
- startDateGroup = startAsset = undefined;
- }
- }
-
- *bucketsIterator(options?: { direction?: Direction; startBucket?: AssetBucket }) {
- const isEarlier = options?.direction === 'earlier';
- let startIndex = options?.startBucket
- ? this.buckets.indexOf(options.startBucket)
- : isEarlier
- ? 0
- : this.buckets.length - 1;
-
- while (startIndex >= 0 && startIndex < this.buckets.length) {
- yield this.buckets[startIndex];
- startIndex += isEarlier ? 1 : -1;
- }
- }
-
- #addPendingChanges(...changes: PendingChange[]) {
- this.#pendingChanges.push(...changes);
- this.#processPendingChanges();
- }
-
- connect() {
- this.#unsubscribers.push(
- websocketEvents.on('on_upload_success', (asset) =>
- this.#addPendingChanges({ type: 'add', values: [toTimelineAsset(asset)] }),
- ),
- websocketEvents.on('on_asset_trash', (ids) => this.#addPendingChanges({ type: 'trash', values: ids })),
- websocketEvents.on('on_asset_update', (asset) =>
- this.#addPendingChanges({ type: 'update', values: [toTimelineAsset(asset)] }),
- ),
- websocketEvents.on('on_asset_delete', (id: string) => this.#addPendingChanges({ type: 'delete', values: [id] })),
- );
- }
-
- disconnect() {
- for (const unsubscribe of this.#unsubscribers) {
- unsubscribe();
- }
- this.#unsubscribers = [];
- }
-
- #getPendingChangeBatches() {
- const batch: {
- add: TimelineAsset[];
- update: TimelineAsset[];
- remove: string[];
- } = {
- add: [],
- update: [],
- remove: [],
- };
- for (const { type, values } of this.#pendingChanges) {
- switch (type) {
- case 'add': {
- batch.add.push(...values);
-
- break;
- }
- case 'update': {
- batch.update.push(...values);
-
- break;
- }
- case 'delete':
- case 'trash': {
- batch.remove.push(...values);
-
- break;
- }
- // No default
- }
- }
- return batch;
- }
-
- #findBucketForAsset(id: string) {
- for (const bucket of this.buckets) {
- const asset = bucket.findAssetById({ id });
- if (asset) {
- return { bucket, asset };
- }
- }
- }
-
- #findBucketForDate(targetYearMonth: TimelinePlainYearMonth) {
- for (const bucket of this.buckets) {
- const { year, month } = bucket.yearMonth;
- if (month === targetYearMonth.month && year === targetYearMonth.year) {
- return bucket;
- }
- }
- }
-
- updateSlidingWindow(scrollTop: number) {
- if (this.#scrollTop !== scrollTop) {
- this.#scrollTop = scrollTop;
- this.updateIntersections();
- }
- }
-
- clearScrollCompensation() {
- this.scrollCompensation = {
- heightDelta: undefined,
- scrollTop: undefined,
- bucket: undefined,
- };
- }
-
- updateIntersections() {
- if (!this.isInitialized || this.visibleWindow.bottom === this.visibleWindow.top) {
- return;
- }
- let topIntersectingBucket = undefined;
- for (const bucket of this.buckets) {
- this.#updateIntersection(bucket);
- if (!topIntersectingBucket && bucket.actuallyIntersecting) {
- topIntersectingBucket = bucket;
- }
- }
- if (topIntersectingBucket !== undefined && this.topIntersectingBucket !== topIntersectingBucket) {
- this.topIntersectingBucket = topIntersectingBucket;
- }
- for (const bucket of this.buckets) {
- if (bucket === this.topIntersectingBucket) {
- this.topIntersectingBucket.percent = clamp(
- (this.visibleWindow.top - this.topIntersectingBucket.top) / this.topIntersectingBucket.bucketHeight,
- 0,
- 1,
- );
- } else {
- bucket.percent = 0;
- }
- }
- }
-
- #calculateIntersecting(bucket: AssetBucket, expandTop: number, expandBottom: number) {
- const bucketTop = bucket.top;
- const bucketBottom = bucketTop + bucket.bucketHeight;
- const topWindow = this.visibleWindow.top - expandTop;
- const bottomWindow = this.visibleWindow.bottom + expandBottom;
-
- // a bucket intersections if
- // 1) bucket's bottom is in the visible range -or-
- // 2) bucket's bottom is in the visible range -or-
- // 3) bucket's top is above visible range and bottom is below visible range
- return (
- (bucketTop >= topWindow && bucketTop < bottomWindow) ||
- (bucketBottom >= topWindow && bucketBottom < bottomWindow) ||
- (bucketTop < topWindow && bucketBottom >= bottomWindow)
- );
- }
-
- clearDeferredLayout(bucket: AssetBucket) {
- const hasDeferred = bucket.dateGroups.some((group) => group.deferredLayout);
- if (hasDeferred) {
- this.#updateGeometry(bucket, { invalidateHeight: true, noDefer: true });
- for (const group of bucket.dateGroups) {
- group.deferredLayout = false;
- }
- }
- }
-
- #updateIntersection(bucket: AssetBucket) {
- const actuallyIntersecting = this.#calculateIntersecting(bucket, 0, 0);
- let preIntersecting = false;
- if (!actuallyIntersecting) {
- preIntersecting = this.#calculateIntersecting(bucket, INTERSECTION_EXPAND_TOP, INTERSECTION_EXPAND_BOTTOM);
- }
- bucket.intersecting = actuallyIntersecting || preIntersecting;
- bucket.actuallyIntersecting = actuallyIntersecting;
- if (preIntersecting || actuallyIntersecting) {
- this.clearDeferredLayout(bucket);
- }
- }
-
- #processPendingChanges = throttle(() => {
- const { add, update, remove } = this.#getPendingChangeBatches();
- if (add.length > 0) {
- this.addAssets(add);
- }
- if (update.length > 0) {
- this.updateAssets(update);
- }
- if (remove.length > 0) {
- this.removeAssets(remove);
- }
- this.#pendingChanges = [];
- }, 2500);
-
- async #initialiazeTimeBuckets() {
- const timebuckets = await getTimeBuckets({
- ...this.#options,
- key: authManager.key,
- });
-
- this.buckets = timebuckets.map((bucket) => {
- const date = new Date(bucket.timeBucket);
- return new AssetBucket(
- this,
- { year: date.getUTCFullYear(), month: date.getUTCMonth() + 1 },
- bucket.count,
- this.#options.order,
- );
- });
- this.albumAssets.clear();
- this.#updateViewportGeometry(false);
- }
-
- /**
- * If the timeline query options change (i.e. albumId, isArchived, isFavorite, etc)
- * call this method to recreate all buckets based on the new options.
- *
- * @param options The query options for time bucket queries.
- */
- async updateOptions(options: AssetStoreOptions) {
- if (options.deferInit) {
- return;
- }
- if (this.#options !== AssetStore.#INIT_OPTIONS && isEqual(this.#options, options)) {
- return;
- }
- await this.initTask.reset();
- await this.#init(options);
- this.#updateViewportGeometry(false);
- }
-
- async #init(options: AssetStoreOptions) {
- // doing the following outside of the task reduces flickr
- this.isInitialized = false;
- this.buckets = [];
- this.albumAssets.clear();
- await this.initTask.execute(async () => {
- this.#options = options;
- await this.#initialiazeTimeBuckets();
- }, true);
- }
-
- public destroy() {
- this.disconnect();
- 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;
- }
-
- // special case updateViewport before or soon after call to updateOptions
- if (!this.initTask.executed) {
- // eslint-disable-next-line unicorn/prefer-ternary
- if (this.initTask.loading) {
- await this.initTask.waitUntilCompletion();
- } else {
- // not executed and not loaded means we should init now, and init will
- // also update geometry so just return after
- await this.#init(this.#options);
- }
- }
-
- // changing width affects the actual height, and needs to re-layout
- 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 bucket of this.buckets) {
- this.#updateGeometry(bucket, { invalidateHeight: changedWidth });
- }
- this.updateIntersections();
- this.#createScrubBuckets();
- }
-
- #createScrubBuckets() {
- this.scrubberBuckets = this.buckets.map((bucket) => ({
- assetCount: bucket.bucketCount,
- year: bucket.yearMonth.year,
- month: bucket.yearMonth.month,
- bucketDateFormattted: bucket.bucketDateFormatted,
- bucketHeight: bucket.bucketHeight,
- }));
- this.scrubberTimelineHeight = this.timelineHeight;
- }
-
- createLayoutOptions() {
- const viewportWidth = this.viewportWidth;
-
- return {
- spacing: 2,
- heightTolerance: 0.15,
- rowHeight: this.#rowHeight,
- rowWidth: Math.floor(viewportWidth),
- };
- }
-
- #updateGeometry(bucket: AssetBucket, options: UpdateGeometryOptions) {
- const { invalidateHeight, noDefer = false } = options;
- if (invalidateHeight) {
- bucket.isBucketHeightActual = false;
- }
- if (!bucket.isLoaded) {
- // optimize - if bucket already has data, no need to create estimates
- const viewportWidth = this.viewportWidth;
- if (!bucket.isBucketHeightActual) {
- const unwrappedWidth = (3 / 2) * bucket.bucketCount * this.#rowHeight * (7 / 10);
- const rows = Math.ceil(unwrappedWidth / viewportWidth);
- const height = 51 + Math.max(1, rows) * this.#rowHeight;
- bucket.bucketHeight = height;
- }
- return;
- }
- this.#layoutBucket(bucket, noDefer);
- }
-
- #layoutBucket(bucket: AssetBucket, noDefer: boolean = false) {
- // these are top offsets, for each row
- let cummulativeHeight = 0;
- // these are left offsets of each group, for each row
- let cummulativeWidth = 0;
- let lastRowHeight = 0;
- let lastRow = 0;
-
- let dateGroupRow = 0;
- let dateGroupCol = 0;
-
- const rowSpaceRemaining: number[] = Array.from({ length: bucket.dateGroups.length });
- rowSpaceRemaining.fill(this.viewportWidth, 0, bucket.dateGroups.length);
- const options = this.createLayoutOptions();
- for (const assetGroup of bucket.dateGroups) {
- assetGroup.layout(options, noDefer);
- rowSpaceRemaining[dateGroupRow] -= assetGroup.width - 1;
- if (dateGroupCol > 0) {
- rowSpaceRemaining[dateGroupRow] -= this.gap;
- }
- if (rowSpaceRemaining[dateGroupRow] >= 0) {
- assetGroup.row = dateGroupRow;
- assetGroup.col = dateGroupCol;
- assetGroup.left = cummulativeWidth;
- assetGroup.top = cummulativeHeight;
-
- dateGroupCol++;
-
- cummulativeWidth += assetGroup.width + this.gap;
- } else {
- // starting a new row, we need to update the last col of the previous row
- cummulativeWidth = 0;
- dateGroupRow++;
- dateGroupCol = 0;
- assetGroup.row = dateGroupRow;
- assetGroup.col = dateGroupCol;
- assetGroup.left = cummulativeWidth;
-
- rowSpaceRemaining[dateGroupRow] -= assetGroup.width;
- dateGroupCol++;
- cummulativeHeight += lastRowHeight;
- assetGroup.top = cummulativeHeight;
- cummulativeWidth += assetGroup.width + this.gap;
- lastRow = assetGroup.row - 1;
- }
- lastRowHeight = assetGroup.height + this.headerHeight;
- }
- if (lastRow === 0 || lastRow !== bucket.lastDateGroup?.row) {
- cummulativeHeight += lastRowHeight;
- }
-
- bucket.bucketHeight = cummulativeHeight;
- bucket.isBucketHeightActual = true;
- }
-
- async loadBucket(yearMonth: TimelinePlainYearMonth, options?: { cancelable: boolean }): Promise<void> {
- let cancelable = true;
- if (options) {
- cancelable = options.cancelable;
- }
- const bucket = this.getBucketByDate(yearMonth);
- if (!bucket) {
- return;
- }
-
- if (bucket.loader?.executed) {
- return;
- }
-
- const result = await bucket.loader?.execute(async (signal: AbortSignal) => {
- if (bucket.getFirstAsset()) {
- // this happens when a bucket was created by an event instead of via a loadBucket call
- // so no need to load the bucket, it already has assets
- return;
- }
- const timeBucket = toISOLocalDateTime(bucket.yearMonth);
- const key = authManager.key;
- const bucketResponse = await getTimeBucket(
- {
- ...this.#options,
- timeBucket,
- key,
- },
- { signal },
- );
- if (bucketResponse) {
- if (this.#options.timelineAlbumId) {
- const albumAssets = await getTimeBucket(
- {
- albumId: this.#options.timelineAlbumId,
- timeBucket,
- key,
- },
- { signal },
- );
- for (const id of albumAssets.id) {
- this.albumAssets.add(id);
- }
- }
- const unprocessedAssets = bucket.addAssets(bucketResponse);
- if (unprocessedAssets.length > 0) {
- console.error(
- `Warning: getTimeBucket API returning assets not in requested month: ${bucket.yearMonth.month}, ${JSON.stringify(
- unprocessedAssets.map((unprocessed) => ({
- id: unprocessed.id,
- localDateTime: unprocessed.localDateTime,
- })),
- )}`,
- );
- }
- this.#layoutBucket(bucket);
- }
- }, cancelable);
- if (result === 'LOADED') {
- this.#updateIntersection(bucket);
- }
- }
-
- addAssets(assets: TimelineAsset[]) {
- const assetsToUpdate: TimelineAsset[] = [];
-
- for (const asset of assets) {
- if (this.isExcluded(asset)) {
- continue;
- }
- assetsToUpdate.push(asset);
- }
-
- const notUpdated = this.updateAssets(assetsToUpdate);
- this.#addAssetsToBuckets([...notUpdated]);
- }
-
- #addAssetsToBuckets(assets: TimelineAsset[]) {
- if (assets.length === 0) {
- return;
- }
-
- const addContext = new AddContext();
- const updatedBuckets = new Set<AssetBucket>();
- const bucketCount = this.buckets.length;
- for (const asset of assets) {
- let bucket = this.getBucketByDate(asset.localDateTime);
-
- if (!bucket) {
- bucket = new AssetBucket(this, asset.localDateTime, 1, this.#options.order);
- bucket.isLoaded = true;
- this.buckets.push(bucket);
- }
-
- bucket.addTimelineAsset(asset, addContext);
- updatedBuckets.add(bucket);
- }
-
- if (this.buckets.length !== bucketCount) {
- this.buckets.sort((a, b) => {
- return a.yearMonth.year === b.yearMonth.year
- ? b.yearMonth.month - a.yearMonth.month
- : b.yearMonth.year - a.yearMonth.year;
- });
- }
-
- for (const group of addContext.existingDateGroups) {
- group.sortAssets(this.#options.order);
- }
-
- for (const bucket of addContext.bucketsWithNewDateGroups) {
- bucket.sortDateGroups();
- }
-
- for (const bucket of addContext.updatedBuckets) {
- bucket.sortDateGroups();
- this.#updateGeometry(bucket, { invalidateHeight: true });
- }
- this.updateIntersections();
- }
-
- getBucketByDate(targetYearMonth: TimelinePlainYearMonth): AssetBucket | undefined {
- return this.buckets.find(
- (bucket) => bucket.yearMonth.year === targetYearMonth.year && bucket.yearMonth.month === targetYearMonth.month,
- );
- }
-
- async findBucketForAsset(id: string) {
- if (!this.isInitialized) {
- await this.initTask.waitUntilCompletion();
- }
- let { bucket } = this.#findBucketForAsset(id) ?? {};
- if (bucket) {
- return bucket;
- }
- const asset = toTimelineAsset(await getAssetInfo({ id, key: authManager.key }));
- if (!asset || this.isExcluded(asset)) {
- return;
- }
- bucket = await this.#loadBucketAtTime(asset.localDateTime, { cancelable: false });
- if (bucket?.findAssetById({ id })) {
- return bucket;
- }
- }
-
- async #loadBucketAtTime(yearMonth: TimelinePlainYearMonth, options?: { cancelable: boolean }) {
- await this.loadBucket(yearMonth, options);
- return this.getBucketByDate(yearMonth);
- }
-
- getBucketIndexByAssetId(assetId: string) {
- const bucketInfo = this.#findBucketForAsset(assetId);
- return bucketInfo?.bucket;
- }
-
- async getRandomBucket() {
- const random = Math.floor(Math.random() * this.buckets.length);
- const bucket = this.buckets[random];
- await this.loadBucket(bucket.yearMonth, { cancelable: false });
- return bucket;
- }
-
- async getRandomAsset() {
- const bucket = await this.getRandomBucket();
- return bucket?.getRandomAsset();
- }
-
- // runs op on assets, returns unprocessed
- #runAssetOperation(ids: Set<string>, operation: AssetOperation) {
- if (ids.size === 0) {
- return { processedIds: new Set(), unprocessedIds: ids, changedGeometry: false };
- }
-
- const changedBuckets = new Set<AssetBucket>();
- let idsToProcess = new Set(ids);
- const idsProcessed = new Set<string>();
- const combinedMoveAssets: { asset: TimelineAsset; date: TimelinePlainDate }[][] = [];
- for (const bucket of this.buckets) {
- if (idsToProcess.size > 0) {
- const { moveAssets, processedIds, changedGeometry } = bucket.runAssetOperation(idsToProcess, operation);
- if (moveAssets.length > 0) {
- combinedMoveAssets.push(moveAssets);
- }
- idsToProcess = idsToProcess.difference(processedIds);
- for (const id of processedIds) {
- idsProcessed.add(id);
- }
- if (changedGeometry) {
- changedBuckets.add(bucket);
- }
- }
- }
- if (combinedMoveAssets.length > 0) {
- this.#addAssetsToBuckets(combinedMoveAssets.flat().map((a) => a.asset));
- }
- const changedGeometry = changedBuckets.size > 0;
- for (const bucket of changedBuckets) {
- this.#updateGeometry(bucket, { invalidateHeight: true });
- }
- if (changedGeometry) {
- this.updateIntersections();
- }
- return { unprocessedIds: idsToProcess, processedIds: idsProcessed, changedGeometry };
- }
-
- /**
- * Runs a callback on a list of asset ids. The assets in the AssetStore are reactive -
- * any change to the asset (i.e. changing isFavorite, isArchived, etc) will automatically
- * cause the UI to update with no further actions needed. Changing the date of an asset
- * will automatically move it to another bucket if needed. Removing the asset will remove
- * it from any view that is showing it.
- *
- * @param ids to run the operation on
- * @param operation callback to update the specified asset ids
- */
- updateAssetOperation(ids: string[], operation: AssetOperation) {
- this.#runAssetOperation(new Set(ids), operation);
- }
-
- updateAssets(assets: TimelineAsset[]) {
- const lookup = new Map<string, TimelineAsset>(assets.map((asset) => [asset.id, asset]));
- const { unprocessedIds } = this.#runAssetOperation(new Set(lookup.keys()), (asset) => {
- updateObject(asset, lookup.get(asset.id));
- return { remove: false };
- });
- return unprocessedIds.values().map((id) => lookup.get(id)!);
- }
-
- removeAssets(ids: string[]) {
- const { unprocessedIds } = this.#runAssetOperation(new Set(ids), () => {
- return { remove: true };
- });
- return [...unprocessedIds];
- }
-
- refreshLayout() {
- for (const bucket of this.buckets) {
- this.#updateGeometry(bucket, { invalidateHeight: true });
- }
- this.updateIntersections();
- }
-
- getFirstAsset(): TimelineAsset | undefined {
- return this.buckets[0]?.getFirstAsset();
- }
-
- async getLaterAsset(
- assetDescriptor: AssetDescriptor,
- interval: 'asset' | 'day' | 'month' | 'year' = 'asset',
- ): Promise<TimelineAsset | undefined> {
- return await this.#getAssetWithOffset(assetDescriptor, interval, 'later');
- }
-
- async getEarlierAsset(
- assetDescriptor: AssetDescriptor,
- interval: 'asset' | 'day' | 'month' | 'year' = 'asset',
- ): Promise<TimelineAsset | undefined> {
- return await this.#getAssetWithOffset(assetDescriptor, interval, 'earlier');
- }
-
- async getClosestAssetToDate(dateTime: TimelinePlainDateTime) {
- const bucket = this.#findBucketForDate(dateTime);
- if (!bucket) {
- return;
- }
- await this.loadBucket(dateTime, { cancelable: false });
- const asset = bucket.findClosest(dateTime);
- if (asset) {
- return asset;
- }
- for await (const asset of this.assetsIterator({ startBucket: bucket })) {
- return asset;
- }
- }
-
- async retrieveRange(start: AssetDescriptor, end: AssetDescriptor) {
- let { asset: startAsset, bucket: startBucket } = this.#findBucketForAsset(start.id) ?? {};
- if (!startBucket || !startAsset) {
- return [];
- }
- let { asset: endAsset, bucket: endBucket } = this.#findBucketForAsset(end.id) ?? {};
- if (!endBucket || !endAsset) {
- return [];
- }
- let direction: Direction = 'earlier';
- if (plainDateTimeCompare(true, startAsset.localDateTime, endAsset.localDateTime) < 0) {
- // swap startAsset, startBucket with endAsset, endBucket
- [startAsset, endAsset] = [endAsset, startAsset];
- [startBucket, endBucket] = [endBucket, startBucket];
- direction = 'earlier';
- }
-
- const range: TimelineAsset[] = [];
- const startDateGroup = startBucket.findDateGroupForAsset(startAsset);
- for await (const targetAsset of this.assetsIterator({
- startBucket,
- startDateGroup,
- startAsset,
- direction,
- })) {
- range.push(targetAsset);
- if (targetAsset.id === endAsset.id) {
- break;
- }
- }
- return range;
- }
-
- async #getAssetWithOffset(
- assetDescriptor: AssetDescriptor,
- interval: 'asset' | 'day' | 'month' | 'year' = 'asset',
- direction: Direction,
- ): Promise<TimelineAsset | undefined> {
- const { asset, bucket } = this.#findBucketForAsset(assetDescriptor.id) ?? {};
- if (!bucket || !asset) {
- return;
- }
-
- switch (interval) {
- case 'asset': {
- return this.#getAssetByAssetOffset(asset, bucket, direction);
- }
- case 'day': {
- return this.#getAssetByDayOffset(asset, bucket, direction);
- }
- case 'month': {
- return this.#getAssetByMonthOffset(bucket, direction);
- }
- case 'year': {
- return this.#getAssetByYearOffset(bucket, direction);
- }
- }
- }
-
- async #getAssetByAssetOffset(asset: TimelineAsset, bucket: AssetBucket, direction: Direction) {
- const dateGroup = bucket.findDateGroupForAsset(asset);
- for await (const targetAsset of this.assetsIterator({
- startBucket: bucket,
- startDateGroup: dateGroup,
- startAsset: asset,
- direction,
- })) {
- if (asset.id === targetAsset.id) {
- continue;
- }
- return targetAsset;
- }
- }
-
- async #getAssetByDayOffset(asset: TimelineAsset, bucket: AssetBucket, direction: Direction) {
- const dateGroup = bucket.findDateGroupForAsset(asset);
- for await (const targetAsset of this.assetsIterator({
- startBucket: bucket,
- startDateGroup: dateGroup,
- startAsset: asset,
- direction,
- })) {
- if (targetAsset.localDateTime.day !== asset.localDateTime.day) {
- return targetAsset;
- }
- }
- }
-
- // starting at bucket, go to the earlier/later bucket by month, returning the first asset in that bucket
- async #getAssetByMonthOffset(bucket: AssetBucket, direction: Direction) {
- for (const targetBucket of this.bucketsIterator({ startBucket: bucket, direction })) {
- if (targetBucket.yearMonth.month !== bucket.yearMonth.month) {
- for await (const targetAsset of this.assetsIterator({ startBucket: targetBucket, direction })) {
- return targetAsset;
- }
- }
- }
- }
-
- async #getAssetByYearOffset(bucket: AssetBucket, direction: Direction) {
- for (const targetBucket of this.bucketsIterator({ startBucket: bucket, direction })) {
- if (targetBucket.yearMonth.year !== bucket.yearMonth.year) {
- for await (const targetAsset of this.assetsIterator({ startBucket: targetBucket, direction })) {
- return targetAsset;
- }
- }
- }
- }
-
- isExcluded(asset: TimelineAsset) {
- return (
- isMismatched(this.#options.visibility, asset.visibility) ||
- isMismatched(this.#options.isFavorite, asset.isFavorite) ||
- isMismatched(this.#options.isTrashed, asset.isTrashed)
- );
- }
-}
-
export const isSelectingAllAssets = writable(false);
diff --git a/web/src/lib/stores/memory.store.svelte.ts b/web/src/lib/stores/memory.store.svelte.ts
index 611291f87f..bc42053a21 100644
--- a/web/src/lib/stores/memory.store.svelte.ts
+++ b/web/src/lib/stores/memory.store.svelte.ts
@@ -1,5 +1,5 @@
import { eventManager } from '$lib/managers/event-manager.svelte';
-import type { TimelineAsset } from '$lib/stores/assets-store.svelte';
+import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
import { asLocalTimeISO } from '$lib/utils/date-time';
import { toTimelineAsset } from '$lib/utils/timeline-util';
import { deleteMemory, type MemoryResponseDto, removeMemoryAssets, searchMemories, updateMemory } from '@immich/sdk';
diff --git a/web/src/lib/utils/actions.ts b/web/src/lib/utils/actions.ts
index 166ca94f74..b975864a07 100644
--- a/web/src/lib/utils/actions.ts
+++ b/web/src/lib/utils/actions.ts
@@ -1,5 +1,6 @@
import { notificationController, NotificationType } from '$lib/components/shared-components/notification/notification';
-import type { AssetStore, TimelineAsset } from '$lib/stores/assets-store.svelte';
+import { AssetStore } from '$lib/managers/timeline-manager/asset-store.svelte';
+import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
import type { StackResponse } from '$lib/utils/asset-utils';
import { AssetVisibility, deleteAssets as deleteBulk, restoreAssets } from '@immich/sdk';
import { t } from 'svelte-i18n';
diff --git a/web/src/lib/utils/asset-utils.ts b/web/src/lib/utils/asset-utils.ts
index 1838cb8eb5..cb4c9eeff0 100644
--- a/web/src/lib/utils/asset-utils.ts
+++ b/web/src/lib/utils/asset-utils.ts
@@ -5,13 +5,11 @@ import { notificationController, NotificationType } from '$lib/components/shared
import { AppRoute } from '$lib/constants';
import { authManager } from '$lib/managers/auth-manager.svelte';
import { downloadManager } from '$lib/managers/download-manager.svelte';
+import type { AssetStore } from '$lib/managers/timeline-manager/asset-store.svelte';
+import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
+import { assetsSnapshot } from '$lib/managers/timeline-manager/utils.svelte';
import type { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
-import {
- assetsSnapshot,
- isSelectingAllAssets,
- type AssetStore,
- type TimelineAsset,
-} from '$lib/stores/assets-store.svelte';
+import { isSelectingAllAssets } from '$lib/stores/assets-store.svelte';
import { preferences } from '$lib/stores/user.store';
import { downloadRequest, withError } from '$lib/utils';
import { createAlbum } from '$lib/utils/album-utils';
diff --git a/web/src/lib/utils/layout-utils.ts b/web/src/lib/utils/layout-utils.ts
index 511e0781f4..e60fa3b9e1 100644
--- a/web/src/lib/utils/layout-utils.ts
+++ b/web/src/lib/utils/layout-utils.ts
@@ -2,7 +2,7 @@
// note: it's important that this is not imported in more than one file due to https://github.com/sveltejs/kit/issues/7805
// import { JustifiedLayout, type LayoutOptions } from '@immich/justified-layout-wasm';
-import type { TimelineAsset } from '$lib/stores/assets-store.svelte';
+import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
import { getAssetRatio } from '$lib/utils/asset-utils';
import { isTimelineAsset } from '$lib/utils/timeline-util';
import type { AssetResponseDto } from '@immich/sdk';
diff --git a/web/src/lib/utils/thumbnail-util.spec.ts b/web/src/lib/utils/thumbnail-util.spec.ts
index 65df82bee3..9e8a8ee66d 100644
--- a/web/src/lib/utils/thumbnail-util.spec.ts
+++ b/web/src/lib/utils/thumbnail-util.spec.ts
@@ -1,4 +1,4 @@
-import type { TimelineAsset } from '$lib/stores/assets-store.svelte';
+import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
import { getAltText } from '$lib/utils/thumbnail-util';
import { AssetVisibility } from '@immich/sdk';
import { init, register, waitLocale } from 'svelte-i18n';
diff --git a/web/src/lib/utils/thumbnail-util.ts b/web/src/lib/utils/thumbnail-util.ts
index 2b5982d510..89cbf3a6a8 100644
--- a/web/src/lib/utils/thumbnail-util.ts
+++ b/web/src/lib/utils/thumbnail-util.ts
@@ -1,4 +1,4 @@
-import type { TimelineAsset } from '$lib/stores/assets-store.svelte';
+import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
import { locale } from '$lib/stores/preferences.store';
import { fromTimelinePlainDateTime } from '$lib/utils/timeline-util';
import { t } from 'svelte-i18n';
diff --git a/web/src/lib/utils/timeline-util.ts b/web/src/lib/utils/timeline-util.ts
index 7538e0e02c..6829bc67f9 100644
--- a/web/src/lib/utils/timeline-util.ts
+++ b/web/src/lib/utils/timeline-util.ts
@@ -1,4 +1,4 @@
-import type { TimelineAsset } from '$lib/stores/assets-store.svelte';
+import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
import { locale } from '$lib/stores/preferences.store';
import { getAssetRatio } from '$lib/utils/asset-utils';
import { AssetTypeEnum, type AssetResponseDto } from '@immich/sdk';
diff --git a/web/src/routes/(user)/albums/[albumId=id]/[[photos=photos]]/[[assetId=id]]/+page.svelte b/web/src/routes/(user)/albums/[albumId=id]/[[photos=photos]]/[[assetId=id]]/+page.svelte
index 6e52b858ba..897763efdc 100644
--- a/web/src/routes/(user)/albums/[albumId=id]/[[photos=photos]]/[[assetId=id]]/+page.svelte
+++ b/web/src/routes/(user)/albums/[albumId=id]/[[photos=photos]]/[[assetId=id]]/+page.svelte
@@ -42,7 +42,7 @@
import SharedLinkCreateModal from '$lib/modals/SharedLinkCreateModal.svelte';
import { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
import { assetViewingStore } from '$lib/stores/asset-viewing.store';
- import { AssetStore } from '$lib/stores/assets-store.svelte';
+ import { AssetStore } from '$lib/managers/timeline-manager/asset-store.svelte';
import { featureFlags } from '$lib/stores/server-config.store';
import { SlideshowNavigation, SlideshowState, slideshowStore } from '$lib/stores/slideshow.store';
import { preferences, user } from '$lib/stores/user.store';
@@ -87,7 +87,7 @@
import { t } from 'svelte-i18n';
import { fly } from 'svelte/transition';
import type { PageData } from './$types';
- import { type TimelineAsset } from '$lib/stores/assets-store.svelte';
+ import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
interface Props {
data: PageData;
diff --git a/web/src/routes/(user)/archive/[[photos=photos]]/[[assetId=id]]/+page.svelte b/web/src/routes/(user)/archive/[[photos=photos]]/[[assetId=id]]/+page.svelte
index 39096ac38b..1c95054887 100644
--- a/web/src/routes/(user)/archive/[[photos=photos]]/[[assetId=id]]/+page.svelte
+++ b/web/src/routes/(user)/archive/[[photos=photos]]/[[assetId=id]]/+page.svelte
@@ -15,7 +15,7 @@
import SetVisibilityAction from '$lib/components/photos-page/actions/set-visibility-action.svelte';
import { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
- import { AssetStore } from '$lib/stores/assets-store.svelte';
+ import { AssetStore } from '$lib/managers/timeline-manager/asset-store.svelte';
import { AssetVisibility } from '@immich/sdk';
import { mdiDotsVertical, mdiPlus } from '@mdi/js';
import { onDestroy } from 'svelte';
diff --git a/web/src/routes/(user)/favorites/[[photos=photos]]/[[assetId=id]]/+page.svelte b/web/src/routes/(user)/favorites/[[photos=photos]]/[[assetId=id]]/+page.svelte
index 119eaed943..fe42d079f8 100644
--- a/web/src/routes/(user)/favorites/[[photos=photos]]/[[assetId=id]]/+page.svelte
+++ b/web/src/routes/(user)/favorites/[[photos=photos]]/[[assetId=id]]/+page.svelte
@@ -18,7 +18,7 @@
import EmptyPlaceholder from '$lib/components/shared-components/empty-placeholder.svelte';
import { AssetAction } from '$lib/constants';
import { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
- import { AssetStore } from '$lib/stores/assets-store.svelte';
+ import { AssetStore } from '$lib/managers/timeline-manager/asset-store.svelte';
import { preferences } from '$lib/stores/user.store';
import { mdiDotsVertical, mdiPlus } from '@mdi/js';
import { onDestroy } from 'svelte';
diff --git a/web/src/routes/(user)/folders/[[photos=photos]]/[[assetId=id]]/+page.svelte b/web/src/routes/(user)/folders/[[photos=photos]]/[[assetId=id]]/+page.svelte
index 8b02e01d84..89df31562e 100644
--- a/web/src/routes/(user)/folders/[[photos=photos]]/[[assetId=id]]/+page.svelte
+++ b/web/src/routes/(user)/folders/[[photos=photos]]/[[assetId=id]]/+page.svelte
@@ -23,7 +23,7 @@
import Sidebar from '$lib/components/sidebar/sidebar.svelte';
import { AppRoute, QueryParameter } from '$lib/constants';
import { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
- import type { Viewport } from '$lib/stores/assets-store.svelte';
+ import type { Viewport } from '$lib/managers/timeline-manager/types';
import { foldersStore } from '$lib/stores/folders.svelte';
import { preferences } from '$lib/stores/user.store';
import { cancelMultiselect } from '$lib/utils/asset-utils';
diff --git a/web/src/routes/(user)/locked/[[photos=photos]]/[[assetId=id]]/+page.svelte b/web/src/routes/(user)/locked/[[photos=photos]]/[[assetId=id]]/+page.svelte
index 32b20ab1dd..e1a80ab95f 100644
--- a/web/src/routes/(user)/locked/[[photos=photos]]/[[assetId=id]]/+page.svelte
+++ b/web/src/routes/(user)/locked/[[photos=photos]]/[[assetId=id]]/+page.svelte
@@ -13,7 +13,7 @@
import EmptyPlaceholder from '$lib/components/shared-components/empty-placeholder.svelte';
import { AppRoute, AssetAction } from '$lib/constants';
import { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
- import { AssetStore } from '$lib/stores/assets-store.svelte';
+ import { AssetStore } from '$lib/managers/timeline-manager/asset-store.svelte';
import { AssetVisibility, lockAuthSession } from '@immich/sdk';
import { Button } from '@immich/ui';
import { mdiDotsVertical, mdiLockOutline } from '@mdi/js';
diff --git a/web/src/routes/(user)/partners/[userId]/[[photos=photos]]/[[assetId=id]]/+page.svelte b/web/src/routes/(user)/partners/[userId]/[[photos=photos]]/[[assetId=id]]/+page.svelte
index 48d830d78c..16cf6ffceb 100644
--- a/web/src/routes/(user)/partners/[userId]/[[photos=photos]]/[[assetId=id]]/+page.svelte
+++ b/web/src/routes/(user)/partners/[userId]/[[photos=photos]]/[[assetId=id]]/+page.svelte
@@ -9,7 +9,7 @@
import ControlAppBar from '$lib/components/shared-components/control-app-bar.svelte';
import { AppRoute } from '$lib/constants';
import { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
- import { AssetStore } from '$lib/stores/assets-store.svelte';
+ import { AssetStore } from '$lib/managers/timeline-manager/asset-store.svelte';
import { AssetVisibility } from '@immich/sdk';
import { mdiArrowLeft, mdiPlus } from '@mdi/js';
import { onDestroy } from 'svelte';
diff --git a/web/src/routes/(user)/people/[personId]/[[photos=photos]]/[[assetId=id]]/+page.svelte b/web/src/routes/(user)/people/[personId]/[[photos=photos]]/[[assetId=id]]/+page.svelte
index 6a28786bf9..c93d93f81d 100644
--- a/web/src/routes/(user)/people/[personId]/[[photos=photos]]/[[assetId=id]]/+page.svelte
+++ b/web/src/routes/(user)/people/[personId]/[[photos=photos]]/[[assetId=id]]/+page.svelte
@@ -36,7 +36,8 @@
import PersonMergeSuggestionModal from '$lib/modals/PersonMergeSuggestionModal.svelte';
import { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
import { assetViewingStore } from '$lib/stores/asset-viewing.store';
- import { AssetStore, type TimelineAsset } from '$lib/stores/assets-store.svelte';
+ import { AssetStore } from '$lib/managers/timeline-manager/asset-store.svelte';
+ import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
import { locale } from '$lib/stores/preferences.store';
import { preferences } from '$lib/stores/user.store';
import { websocketEvents } from '$lib/stores/websocket';
diff --git a/web/src/routes/(user)/photos/[[assetId=id]]/+page.svelte b/web/src/routes/(user)/photos/[[assetId=id]]/+page.svelte
index 4a9adaa898..49b6790756 100644
--- a/web/src/routes/(user)/photos/[[assetId=id]]/+page.svelte
+++ b/web/src/routes/(user)/photos/[[assetId=id]]/+page.svelte
@@ -24,7 +24,7 @@
import { AssetAction } from '$lib/constants';
import { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
import { assetViewingStore } from '$lib/stores/asset-viewing.store';
- import { AssetStore } from '$lib/stores/assets-store.svelte';
+ import { AssetStore } from '$lib/managers/timeline-manager/asset-store.svelte';
import { isFaceEditMode } from '$lib/stores/face-edit.svelte';
import { preferences, user } from '$lib/stores/user.store';
import {
diff --git a/web/src/routes/(user)/search/[[photos=photos]]/[[assetId=id]]/+page.svelte b/web/src/routes/(user)/search/[[photos=photos]]/[[assetId=id]]/+page.svelte
index 6e19917022..f3c90ee4b0 100644
--- a/web/src/routes/(user)/search/[[photos=photos]]/[[assetId=id]]/+page.svelte
+++ b/web/src/routes/(user)/search/[[photos=photos]]/[[assetId=id]]/+page.svelte
@@ -25,7 +25,8 @@
import { AppRoute, QueryParameter } from '$lib/constants';
import { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
import { assetViewingStore } from '$lib/stores/asset-viewing.store';
- import { AssetStore, type TimelineAsset, type Viewport } from '$lib/stores/assets-store.svelte';
+ import { AssetStore } from '$lib/managers/timeline-manager/asset-store.svelte';
+ import type { TimelineAsset, Viewport } from '$lib/managers/timeline-manager/types';
import { lang, locale } from '$lib/stores/preferences.store';
import { featureFlags } from '$lib/stores/server-config.store';
import { preferences } from '$lib/stores/user.store';
diff --git a/web/src/routes/(user)/tags/[[photos=photos]]/[[assetId=id]]/+page.svelte b/web/src/routes/(user)/tags/[[photos=photos]]/[[assetId=id]]/+page.svelte
index c897ed4791..a42c6534a7 100644
--- a/web/src/routes/(user)/tags/[[photos=photos]]/[[assetId=id]]/+page.svelte
+++ b/web/src/routes/(user)/tags/[[photos=photos]]/[[assetId=id]]/+page.svelte
@@ -16,7 +16,7 @@
import { AppRoute, AssetAction, QueryParameter, SettingInputFieldType } from '$lib/constants';
import { modalManager } from '$lib/managers/modal-manager.svelte';
import { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
- import { AssetStore } from '$lib/stores/assets-store.svelte';
+ import { AssetStore } from '$lib/managers/timeline-manager/asset-store.svelte';
import { buildTree, normalizeTreePath } from '$lib/utils/tree-utils';
import { deleteTag, getAllTags, updateTag, upsertTags, type TagResponseDto } from '@immich/sdk';
import { Button, HStack, Modal, ModalBody, ModalFooter, Text } from '@immich/ui';
diff --git a/web/src/routes/(user)/trash/[[photos=photos]]/[[assetId=id]]/+page.svelte b/web/src/routes/(user)/trash/[[photos=photos]]/[[assetId=id]]/+page.svelte
index 36ff2ec266..37c1a5b46c 100644
--- a/web/src/routes/(user)/trash/[[photos=photos]]/[[assetId=id]]/+page.svelte
+++ b/web/src/routes/(user)/trash/[[photos=photos]]/[[assetId=id]]/+page.svelte
@@ -15,7 +15,7 @@
import { AppRoute } from '$lib/constants';
import { modalManager } from '$lib/managers/modal-manager.svelte';
import { AssetInteraction } from '$lib/stores/asset-interaction.svelte';
- import { AssetStore } from '$lib/stores/assets-store.svelte';
+ import { AssetStore } from '$lib/managers/timeline-manager/asset-store.svelte';
import { featureFlags, serverConfig } from '$lib/stores/server-config.store';
import { handlePromiseError } from '$lib/utils';
import { handleError } from '$lib/utils/handle-error';
diff --git a/web/src/test-data/factories/asset-factory.ts b/web/src/test-data/factories/asset-factory.ts
index bca6a61d7d..1955e79b72 100644
--- a/web/src/test-data/factories/asset-factory.ts
+++ b/web/src/test-data/factories/asset-factory.ts
@@ -1,4 +1,4 @@
-import type { TimelineAsset } from '$lib/stores/assets-store.svelte';
+import type { TimelineAsset } from '$lib/managers/timeline-manager/types';
import { fromLocalDateTimeToObject, fromTimelinePlainDateTime } from '$lib/utils/timeline-util';
import { faker } from '@faker-js/faker';
import { AssetTypeEnum, AssetVisibility, type AssetResponseDto, type TimeBucketAssetResponseDto } from '@immich/sdk';