fix: Fix folder media in timeline when camera is not timeline supported (#2246)

- Closes: #2205
2025-11-24 14:33:06 -08:00
parent f50bef7446
commit 1f6a4ddce2
20 changed files with 1011 additions and 421 deletions
@@ -1188,11 +1188,16 @@ describe('CameraManager', async () => {
        expect(await manager.initializeCamerasFromConfig()).toBeTruthy();

        engine.getQueryResultMaxAge.mockReturnValue(60);
-        expect(manager.areMediaQueriesResultsFresh(queries, resultsTimestamp)).toBe(
+        expect(manager.areMediaQueriesResultsFresh(resultsTimestamp, queries)).toBe(
          expectedFresh,
        );
      },
    );
+
+    it('should always return false for null queries', () => {
+      const manager = createCameraManager(createCardAPI(), mock<CameraManagerEngine>());
+      expect(manager.areMediaQueriesResultsFresh(new Date(), null)).toBe(false);
+    });
  });

  describe('should get media seek time', () => {
@@ -53,6 +53,7 @@ const calculateButtons = (
    hass?: HomeAssistant;
    config?: AdvancedCameraCardConfig;
    cameraManager?: CameraManager;
+    foldersManager?: FoldersManager;
    view?: View | null;
    viewManager?: ViewManager;
  },
@@ -66,6 +67,7 @@ const calculateButtons = (
    options?.hass ?? createHASS(),
    options?.config ?? createConfig(),
    cameraManager,
+    options?.foldersManager ?? mock<FoldersManager>(),
    {
      ...options,
      view:
@@ -1,6 +1,8 @@
+import { add } from 'date-fns';
 import { DataSet } from 'vis-data';
 import { TimelineWindow } from 'vis-timeline';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mock } from 'vitest-mock-extended';
 import { CameraManager } from '../../../src/camera-manager/manager';
 import {
  Engine,
@@ -11,13 +13,15 @@ import {
  RecordingSegmentsQuery,
  RecordingSegmentsQueryResults,
 } from '../../../src/camera-manager/types';
+import { FoldersManager } from '../../../src/card-controller/folders/manager';
 import {
  AdvancedCameraCardTimelineItem,
  TimelineDataSource,
 } from '../../../src/components-lib/timeline/source';
-import { TimelineKey } from '../../../src/components-lib/timeline/types';
+import { TimelineKeys } from '../../../src/components-lib/timeline/types';
+import { ConditionStateManagerReadonlyInterface } from '../../../src/conditions/types';
 import { ViewMediaType } from '../../../src/view/item';
-import { EventMediaQuery } from '../../../src/view/query';
+import { FolderViewQuery } from '../../../src/view/query';
 import {
  createCameraManager,
  createFolder,
@@ -26,7 +30,7 @@ import {
  TestViewMedia,
 } from '../../test-utils';

-const CAMERA_ID = 'CAMERA_ID';
+const CAMERA_ID = 'camera-1';
 const TEST_MEDIA_ID = 'TEST_MEDIA_ID';
 const RECORDING_SEGMENT_ID = 'SEGMENT_ID';
 const EXPECTED_RECORDING_ID = `recording-${CAMERA_ID}-${RECORDING_SEGMENT_ID}`;
@@ -34,13 +38,21 @@ const EXPECTED_RECORDING_ID = `recording-${CAMERA_ID}-${RECORDING_SEGMENT_ID}`;
 const start = new Date('2025-09-21T19:31:06Z');
 const end = new Date('2025-09-21T19:31:15Z');

-const testMedia = new TestViewMedia({
+const testCameraMedia = new TestViewMedia({
  cameraID: CAMERA_ID,
  id: TEST_MEDIA_ID,
  startTime: start,
  endTime: end,
 });

+const folder = createFolder({ id: 'folder/folder-1', title: 'Folder Title' });
+const testFolderMedia = new TestViewMedia({
+  folder,
+  id: TEST_MEDIA_ID,
+  startTime: start,
+  endTime: end,
+});
+
 const createTestCameraManager = (): CameraManager => {
  const cameraManager = createCameraManager(
    createStore([
@@ -62,7 +74,7 @@ const createTestCameraManager = (): CameraManager => {
  };

  vi.mocked(cameraManager.generateDefaultEventQueries).mockReturnValue([eventQuery]);
-  vi.mocked(cameraManager.executeMediaQueries).mockResolvedValue([testMedia]);
+  vi.mocked(cameraManager.executeMediaQueries).mockResolvedValue([testCameraMedia]);

  const recordingSegmentQuery: RecordingSegmentsQuery = {
    type: QueryType.RecordingSegments,
@@ -92,33 +104,83 @@ const createTestCameraManager = (): CameraManager => {
 };

 describe('TimelineDataSource', () => {
-  const folder = createFolder({ id: 'folder/FOLDER_ID', title: 'Folder Title' });
-  const timelineKeys: TimelineKey[] = [
-    { type: 'camera', cameraID: 'CAMERA_ID' },
-    { type: 'folder', folder: folder },
-  ];
+  const cameraTimelineKeys: TimelineKeys = {
+    type: 'camera',
+    cameraIDs: new Set(['camera-1', 'camera-2']),
+  };
+  const folderTimelineKeys: TimelineKeys = {
+    type: 'folder',
+    folder,
+  };

  beforeEach(() => {
    vi.clearAllMocks();
  });

-  describe('should get groups', () => {
-    it('should get mixed groups', () => {
+  describe('should get key type', () => {
+    it('should get camera key type', () => {
      const source = new TimelineDataSource(
        createTestCameraManager(),
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
+        'all',
+        true,
+      );
+
+      expect(source.getKeyType()).toBe('camera');
+    });
+
+    it('should get folder key type', () => {
+      const source = new TimelineDataSource(
+        createTestCameraManager(),
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        folderTimelineKeys,
+        'all',
+        true,
+      );
+
+      expect(source.getKeyType()).toBe('folder');
+    });
+  });
+
+  describe('should get groups', () => {
+    it('should get camera based groups', () => {
+      const source = new TimelineDataSource(
+        createTestCameraManager(),
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
        'all',
        true,
      );

      expect(source.groups.length).toBe(2);
-      expect(source.groups.get('camera/CAMERA_ID')).toEqual({
+      expect(source.groups.get('camera/camera-1')).toEqual({
        content: 'Camera Title',
-        id: 'camera/CAMERA_ID',
+        id: 'camera/camera-1',
      });
-      expect(source.groups.get('folder/FOLDER_ID')).toEqual({
+      expect(source.groups.get('camera/camera-2')).toEqual({
+        content: 'Camera Title',
+        id: 'camera/camera-2',
+      });
+    });
+
+    it('should get folder based groups', () => {
+      const source = new TimelineDataSource(
+        createTestCameraManager(),
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        folderTimelineKeys,
+        'all',
+        true,
+      );
+
+      expect(source.groups.length).toBe(1);
+      expect(source.groups.get('folder/folder-1')).toEqual({
        content: 'Folder Title',
-        id: 'folder/FOLDER_ID',
+        id: 'folder/folder-1',
      });
    });

@@ -126,28 +188,58 @@ describe('TimelineDataSource', () => {
      const cameraManager = createTestCameraManager();
      vi.mocked(cameraManager.getCameraMetadata).mockReturnValue(null);

-      const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', true);
+      const source = new TimelineDataSource(
+        cameraManager,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
+        'all',
+        true,
+      );

-      expect(source.groups.get('camera/CAMERA_ID')).toEqual({
-        content: 'CAMERA_ID',
-        id: 'camera/CAMERA_ID',
+      expect(source.groups.get('camera/camera-1')).toEqual({
+        content: 'camera-1',
+        id: 'camera/camera-1',
      });
    });

    it('should use folder id if folder has no title', () => {
-      const folder = createFolder({ id: 'folder/FOLDER_ID' });
-      const timelineKeys: TimelineKey[] = [{ type: 'folder', folder: folder }];
+      const folder = createFolder({ id: 'folder/folder-1' });
+      const timelineKeys: TimelineKeys = { type: 'folder', folder };

      const source = new TimelineDataSource(
        createTestCameraManager(),
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
        timelineKeys,
        'all',
        true,
      );

-      expect(source.groups.get('folder/FOLDER_ID')).toEqual({
-        content: 'folder/FOLDER_ID',
-        id: 'folder/FOLDER_ID',
+      expect(source.groups.length).toBe(1);
+      expect(source.groups.get('folder/folder-1')).toEqual({
+        content: 'folder/folder-1',
+        id: 'folder/folder-1',
+      });
+    });
+
+    it('should have no groups if a folder key has no folder', () => {
+      const folder = createFolder({ id: 'folder/folder-1' });
+      const timelineKeys: TimelineKeys = { type: 'folder', folder };
+
+      const source = new TimelineDataSource(
+        createTestCameraManager(),
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        timelineKeys,
+        'all',
+        true,
+      );
+
+      expect(source.groups.length).toBe(1);
+      expect(source.groups.get('folder/folder-1')).toEqual({
+        content: 'folder/folder-1',
+        id: 'folder/folder-1',
      });
    });
  });
@@ -158,7 +250,7 @@ describe('TimelineDataSource', () => {
      const endTime = new Date('2025-09-21T15:35:28Z');
      const id = 'EVENT_ID';
      const media = new TestViewMedia({
-        cameraID: 'CAMERA_ID',
+        cameraID: 'camera-1',
        id,
        startTime,
        endTime,
@@ -166,7 +258,9 @@ describe('TimelineDataSource', () => {

      const source = new TimelineDataSource(
        createTestCameraManager(),
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
        'all',
        true,
      );
@@ -178,7 +272,7 @@ describe('TimelineDataSource', () => {
        start: startTime.getTime(),
        end: endTime.getTime(),
        media,
-        group: 'camera/CAMERA_ID',
+        group: 'camera/camera-1',
        content: '',
        type: 'range',
      });
@@ -200,7 +294,9 @@ describe('TimelineDataSource', () => {

      const source = new TimelineDataSource(
        createTestCameraManager(),
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        folderTimelineKeys,
        'all',
        true,
      );
@@ -221,7 +317,9 @@ describe('TimelineDataSource', () => {
    it('should ignore non-events media', () => {
      const source = new TimelineDataSource(
        createTestCameraManager(),
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
        'all',
        true,
      );
@@ -238,7 +336,9 @@ describe('TimelineDataSource', () => {
    it('should ignore null results', () => {
      const source = new TimelineDataSource(
        createTestCameraManager(),
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
        'all',
        true,
      );
@@ -251,7 +351,9 @@ describe('TimelineDataSource', () => {
    it('should ignore media without camera or folder ownership', () => {
      const source = new TimelineDataSource(
        createTestCameraManager(),
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
        'all',
        true,
      );
@@ -279,83 +381,195 @@ describe('TimelineDataSource', () => {
        vi.restoreAllMocks();
      });

-      it('should refresh events successfully', async () => {
-        const source = new TimelineDataSource(
-          createTestCameraManager(),
-          timelineKeys,
-          'all',
-          false,
-        );
-        const view = createView();
+      describe('should refresh events from camera', () => {
+        it('should refresh events successfully', async () => {
+          const source = new TimelineDataSource(
+            createTestCameraManager(),
+            mock<FoldersManager>(),
+            mock<ConditionStateManagerReadonlyInterface>(),
+            cameraTimelineKeys,
+            'all',
+            false,
+          );
+          const view = createView();

-        await source.refresh(window, view);
+          await source.refresh(window, { view });

-        expect(source.dataset.length).toBe(1);
+          expect(source.dataset.length).toBe(1);

-        expect(source.dataset.get('TEST_MEDIA_ID')).toEqual({
-          id: 'TEST_MEDIA_ID',
-          content: '',
-          start: new Date('2025-09-21T19:31:06Z').getTime(),
-          end: new Date('2025-09-21T19:31:15Z').getTime(),
-          media: testMedia,
-          type: 'range',
-          group: 'camera/CAMERA_ID',
+          expect(source.dataset.get('TEST_MEDIA_ID')).toEqual({
+            id: 'TEST_MEDIA_ID',
+            content: '',
+            start: new Date('2025-09-21T19:31:06Z').getTime(),
+            end: new Date('2025-09-21T19:31:15Z').getTime(),
+            media: testCameraMedia,
+            type: 'range',
+            group: 'camera/camera-1',
+          });
+        });
+
+        it('should refresh events and handle exception', async () => {
+          const consoleSpy = vi.spyOn(global.console, 'warn').mockReturnValue(undefined);
+
+          const cameraManager = createTestCameraManager();
+          vi.mocked(cameraManager.executeMediaQueries).mockRejectedValue(
+            new Error('Error fetching events'),
+          );
+
+          const source = new TimelineDataSource(
+            cameraManager,
+            mock<FoldersManager>(),
+            mock<ConditionStateManagerReadonlyInterface>(),
+            cameraTimelineKeys,
+            'all',
+            false,
+          );
+
+          expect(source.dataset.length).toBe(0);
+
+          await source.refresh(window);
+
+          expect(source.dataset.length).toBe(0);
+
+          expect(consoleSpy).toHaveBeenCalledWith('Error fetching events');
+        });
+
+        it('should not refresh events when window is cached', async () => {
+          const cameraManager = createTestCameraManager();
+          const source = new TimelineDataSource(
+            cameraManager,
+            mock<FoldersManager>(),
+            mock<ConditionStateManagerReadonlyInterface>(),
+            cameraTimelineKeys,
+            'all',
+            false,
+          );
+          const view = createView();
+
+          await source.refresh(window, { view });
+          expect(source.dataset.length).toBe(1);
+
+          await source.refresh(window, { view });
+          expect(source.dataset.length).toBe(1);
+          expect(cameraManager.executeMediaQueries).toHaveBeenCalledTimes(1);
+        });
+
+        it('should not refresh events when unable to create event queries', async () => {
+          const cameraManager = createTestCameraManager();
+          vi.mocked(cameraManager.generateDefaultEventQueries).mockReturnValue(null);
+
+          const source = new TimelineDataSource(
+            cameraManager,
+            mock<FoldersManager>(),
+            mock<ConditionStateManagerReadonlyInterface>(),
+            cameraTimelineKeys,
+            'all',
+            false,
+          );
+
+          await source.refresh(window);
+          expect(source.dataset.length).toBe(0);
        });
      });

-      it('should refresh events and handle exception', async () => {
-        const consoleSpy = vi.spyOn(global.console, 'warn').mockReturnValue(undefined);
+      describe('should refresh events from folder', () => {
+        it('should refresh events successfully', async () => {
+          const foldersManager = mock<FoldersManager>();
+          vi.mocked(foldersManager.generateDefaultFolderQuery).mockReturnValue({
+            folder,
+            path: [{}],
+          });
+          vi.mocked(foldersManager.expandFolder).mockResolvedValue([testFolderMedia]);

-        const cameraManager = createTestCameraManager();
-        vi.mocked(cameraManager.executeMediaQueries).mockRejectedValue(
-          new Error('Error fetching events'),
-        );
+          const source = new TimelineDataSource(
+            mock<CameraManager>(),
+            foldersManager,
+            mock<ConditionStateManagerReadonlyInterface>(),
+            folderTimelineKeys,
+            'all',
+            false,
+          );
+          const view = createView();

-        const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', false);
+          await source.refresh(window, { view });

-        expect(source.dataset.length).toBe(0);
+          expect(source.dataset.length).toBe(1);

-        await source.refresh(window);
+          expect(source.dataset.get('TEST_MEDIA_ID')).toEqual({
+            id: 'TEST_MEDIA_ID',
+            content: '',
+            start: new Date('2025-09-21T19:31:06Z').getTime(),
+            end: new Date('2025-09-21T19:31:15Z').getTime(),
+            media: testFolderMedia,
+            type: 'range',
+            group: 'folder/folder-1',
+            query: expect.any(FolderViewQuery),
+          });
+        });

-        expect(source.dataset.length).toBe(0);
+        describe('should refresh events from folder cached', () => {
+          beforeAll(() => {
+            vi.useFakeTimers();
+          });

-        expect(consoleSpy).toHaveBeenCalledWith('Error fetching events');
-      });
+          afterAll(() => {
+            vi.useRealTimers();
+          });

-      it('should not refresh events when window is cached', async () => {
-        const cameraManager = createTestCameraManager();
-        const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', false);
-        const view = createView();
+          it('should refresh events only when not cached', async () => {
+            const foldersManager = mock<FoldersManager>();
+            vi.mocked(foldersManager.generateDefaultFolderQuery).mockReturnValue({
+              folder,
+              path: [{}],
+            });
+            vi.mocked(foldersManager.expandFolder).mockResolvedValue([testFolderMedia]);

-        await source.refresh(window, view);
-        expect(source.dataset.length).toBe(1);
+            const source = new TimelineDataSource(
+              mock<CameraManager>(),
+              foldersManager,
+              mock<ConditionStateManagerReadonlyInterface>(),
+              folderTimelineKeys,
+              'all',
+              false,
+            );
+            const view = createView();

-        await source.refresh(window, view);
-        expect(source.dataset.length).toBe(1);
-        expect(cameraManager.executeMediaQueries).toHaveBeenCalledTimes(1);
-      });
+            await source.refresh(window, { view });
+            await source.refresh(window, { view });
+            await source.refresh(window, { view });

-      it('should not refresh events when events in view', async () => {
-        const source = new TimelineDataSource(
-          createTestCameraManager(),
-          timelineKeys,
-          'all',
-          false,
-        );
+            expect(foldersManager.expandFolder).toHaveBeenCalledTimes(1);
+          });

-        await source.refresh(window, createView({ query: new EventMediaQuery() }));
+          it('should refresh events when cached expired', async () => {
+            const start = new Date();
+            vi.setSystemTime(start);
+            const foldersManager = mock<FoldersManager>();
+            vi.mocked(foldersManager.generateDefaultFolderQuery).mockReturnValue({
+              folder,
+              path: [{}],
+            });
+            vi.mocked(foldersManager.expandFolder).mockResolvedValue([testFolderMedia]);

-        expect(source.dataset.length).toBe(0);
-      });
+            const source = new TimelineDataSource(
+              mock<CameraManager>(),
+              foldersManager,
+              mock<ConditionStateManagerReadonlyInterface>(),
+              folderTimelineKeys,
+              'all',
+              false,
+            );
+            const view = createView();

-      it('should not refresh events when unable to create event queries', async () => {
-        const cameraManager = createTestCameraManager();
-        vi.mocked(cameraManager.generateDefaultEventQueries).mockReturnValue(null);
+            await source.refresh(window, { view });

-        const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', false);
+            vi.setSystemTime(add(start, { hours: 1 }));

-        await source.refresh(window);
-        expect(source.dataset.length).toBe(0);
+            await source.refresh(window, { view });
+
+            expect(foldersManager.expandFolder).toHaveBeenCalledTimes(2);
+          });
+        });
      });
    });

@@ -369,7 +583,9 @@ describe('TimelineDataSource', () => {
      it('should refresh recordings successfully', async () => {
        const source = new TimelineDataSource(
          createTestCameraManager(),
-          timelineKeys,
+          mock<FoldersManager>(),
+          mock<ConditionStateManagerReadonlyInterface>(),
+          cameraTimelineKeys,
          'all',
          true,
        );
@@ -382,7 +598,7 @@ describe('TimelineDataSource', () => {
        expect(source.dataset.get(EXPECTED_RECORDING_ID)).toEqual({
          content: '',
          end: 1695307875000,
-          group: 'camera/CAMERA_ID',
+          group: 'camera/camera-1',
          id: EXPECTED_RECORDING_ID,
          start: 1695307866000,
          type: 'background',
@@ -397,7 +613,14 @@ describe('TimelineDataSource', () => {
          new Error('Error fetching recordings'),
        );

-        const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', true);
+        const source = new TimelineDataSource(
+          cameraManager,
+          mock<FoldersManager>(),
+          mock<ConditionStateManagerReadonlyInterface>(),
+          cameraTimelineKeys,
+          'all',
+          true,
+        );

        expect(getRecordings(source.dataset).length).toBe(0);

@@ -410,7 +633,14 @@ describe('TimelineDataSource', () => {

      it('should not refresh recordings when window is cached', async () => {
        const cameraManager = createTestCameraManager();
-        const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', true);
+        const source = new TimelineDataSource(
+          cameraManager,
+          mock<FoldersManager>(),
+          mock<ConditionStateManagerReadonlyInterface>(),
+          cameraTimelineKeys,
+          'all',
+          true,
+        );

        await source.refresh(window);
        expect(getRecordings(source.dataset).length).toBe(1);
@@ -424,7 +654,9 @@ describe('TimelineDataSource', () => {
      it('should not refresh recordings when recordings disabled', async () => {
        const source = new TimelineDataSource(
          createTestCameraManager(),
-          timelineKeys,
+          mock<FoldersManager>(),
+          mock<ConditionStateManagerReadonlyInterface>(),
+          cameraTimelineKeys,
          'all',

          // Disable recordings.
@@ -436,12 +668,31 @@ describe('TimelineDataSource', () => {
        expect(source.dataset.get(EXPECTED_RECORDING_ID)).toBeNull();
      });

-      it('should not refresh recordings without any cameras', async () => {
-        const timelineKeys: TimelineKey[] = [{ type: 'folder', folder: folder }];
-
+      it('should not refresh recordings with folders', async () => {
        const source = new TimelineDataSource(
          createTestCameraManager(),
-          timelineKeys,
+          mock<FoldersManager>(),
+          mock<ConditionStateManagerReadonlyInterface>(),
+          folderTimelineKeys,
+          'all',
+          true,
+        );
+
+        await source.refresh(window);
+
+        expect(source.dataset.get(EXPECTED_RECORDING_ID)).toBeNull();
+      });
+
+      it('should not refresh recordings without cameras', async () => {
+        const emptycameraTimelineKeys: TimelineKeys = {
+          type: 'camera',
+          cameraIDs: new Set(),
+        };
+        const source = new TimelineDataSource(
+          createTestCameraManager(),
+          mock<FoldersManager>(),
+          mock<ConditionStateManagerReadonlyInterface>(),
+          emptycameraTimelineKeys,
          'all',
          true,
        );
@@ -457,7 +708,14 @@ describe('TimelineDataSource', () => {
          null,
        );

-        const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', true);
+        const source = new TimelineDataSource(
+          cameraManager,
+          mock<FoldersManager>(),
+          mock<ConditionStateManagerReadonlyInterface>(),
+          cameraTimelineKeys,
+          'all',
+          true,
+        );

        await source.refresh(window);

@@ -499,7 +757,14 @@ describe('TimelineDataSource', () => {
          ]),
        );

-        const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', true);
+        const source = new TimelineDataSource(
+          cameraManager,
+          mock<FoldersManager>(),
+          mock<ConditionStateManagerReadonlyInterface>(),
+          cameraTimelineKeys,
+          'all',
+          true,
+        );

        await source.refresh(window);

@@ -507,8 +772,8 @@ describe('TimelineDataSource', () => {
          {
            content: '',
            end: 1695307885000,
-            group: 'camera/CAMERA_ID',
-            id: 'recording-CAMERA_ID-SEGMENT_ID',
+            group: 'camera/camera-1',
+            id: 'recording-camera-1-SEGMENT_ID',
            start: 1695307866000,
            type: 'background',
          },
@@ -547,15 +812,22 @@ describe('TimelineDataSource', () => {
          new Map([[recordingSegmentQuery, recordingSegmentsQueryResults]]),
        );

-        const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', true);
+        const source = new TimelineDataSource(
+          cameraManager,
+          mock<FoldersManager>(),
+          mock<ConditionStateManagerReadonlyInterface>(),
+          cameraTimelineKeys,
+          'all',
+          true,
+        );
        source.dataset.add({
-          id: 'recording-CAMERA_ID-SEGMENT_ID',
+          id: 'recording-camera-1-SEGMENT_ID',
          start: 1695307866000,

          // No end time.
          end: undefined,

-          group: 'camera/CAMERA_ID',
+          group: 'camera/camera-1',
          content: '',
          type: 'background',
        });
@@ -566,8 +838,8 @@ describe('TimelineDataSource', () => {
          {
            content: '',
            end: 1695307885000,
-            group: 'camera/CAMERA_ID',
-            id: 'recording-CAMERA_ID-SEGMENT_ID',
+            group: 'camera/camera-1',
+            id: 'recording-camera-1-SEGMENT_ID',
            start: 1695307866000,
            type: 'background',
          },
@@ -622,7 +894,14 @@ describe('TimelineDataSource', () => {
          ]),
        );

-        const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', true);
+        const source = new TimelineDataSource(
+          cameraManager,
+          mock<FoldersManager>(),
+          mock<ConditionStateManagerReadonlyInterface>(),
+          cameraTimelineKeys,
+          'all',
+          true,
+        );

        await source.refresh(window);

@@ -653,10 +932,11 @@ describe('TimelineDataSource', () => {
    const window: TimelineWindow = { start, end };

    it('should not event queries without cameras', () => {
-      const timelineKeys: TimelineKey[] = [{ type: 'folder', folder: folder }];
      const source = new TimelineDataSource(
        createCameraManager(),
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        folderTimelineKeys,
        'all',
        true,
      );
@@ -672,11 +952,18 @@ describe('TimelineDataSource', () => {
          },
        ]),
      );
-      const source = new TimelineDataSource(cameraManager, timelineKeys, 'clips', false);
+      const source = new TimelineDataSource(
+        cameraManager,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
+        'clips',
+        false,
+      );
      source.getTimelineEventQueries(window);

      expect(cameraManager.generateDefaultEventQueries).toBeCalledWith(
-        new Set([CAMERA_ID]),
+        new Set(['camera-1', 'camera-2']),
        {
          start,
          end,
@@ -695,14 +982,16 @@ describe('TimelineDataSource', () => {
      );
      const source = new TimelineDataSource(
        cameraManager,
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
        'snapshots',
        false,
      );
      source.getTimelineEventQueries(window);

      expect(cameraManager.generateDefaultEventQueries).toBeCalledWith(
-        new Set([CAMERA_ID]),
+        new Set(['camera-1', 'camera-2']),
        {
          start,
          end,
@@ -712,14 +1001,51 @@ describe('TimelineDataSource', () => {
    });
  });

+  describe('should get timeline folder queries', () => {
+    it('should not get folder queries without a folder', () => {
+      const source = new TimelineDataSource(
+        createCameraManager(),
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
+        'all',
+        true,
+      );
+
+      expect(source.getTimelineFolderQuery()).toBeNull();
+    });
+
+    it('should get folder queries', () => {
+      const foldersManager = mock<FoldersManager>();
+      vi.mocked(foldersManager.generateDefaultFolderQuery).mockReturnValue({
+        folder,
+        path: [{}],
+      });
+
+      const source = new TimelineDataSource(
+        mock<CameraManager>(),
+        foldersManager,
+        mock<ConditionStateManagerReadonlyInterface>(),
+        folderTimelineKeys,
+        'clips',
+        false,
+      );
+
+      source.getTimelineFolderQuery();
+
+      expect(foldersManager.generateDefaultFolderQuery).toBeCalledWith(folder);
+    });
+  });
+
  describe('should get timeline recording queries', () => {
    const window: TimelineWindow = { start, end };

    it('should not recording queries without cameras', () => {
-      const timelineKeys: TimelineKey[] = [{ type: 'folder', folder: folder }];
      const source = new TimelineDataSource(
        createCameraManager(),
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        folderTimelineKeys,
        'all',
        true,
      );
@@ -731,15 +1057,25 @@ describe('TimelineDataSource', () => {
      const cameraManager = createCameraManager(
        createStore([
          {
-            cameraID: CAMERA_ID,
+            cameraID: 'camera-1',
+          },
+          {
+            cameraID: 'camera-2',
          },
        ]),
      );
-      const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', true);
+      const source = new TimelineDataSource(
+        cameraManager,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
+        'all',
+        true,
+      );
      source.getTimelineRecordingQueries(window);

      expect(cameraManager.generateDefaultRecordingQueries).toBeCalledWith(
-        new Set([CAMERA_ID]),
+        new Set(['camera-1', 'camera-2']),
        {
          start,
          end,
@@ -752,7 +1088,9 @@ describe('TimelineDataSource', () => {
    it('should not rewrite when item is not found', () => {
      const source = new TimelineDataSource(
        createTestCameraManager(),
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
        'all',
        true,
      );
@@ -764,7 +1102,9 @@ describe('TimelineDataSource', () => {
    it('should not rewrite when item is not found', () => {
      const source = new TimelineDataSource(
        createTestCameraManager(),
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
        'all',
        true,
      );
@@ -772,8 +1112,8 @@ describe('TimelineDataSource', () => {
        id: 'id',
        start: start.getTime(),
        end: end.getTime(),
-        media: testMedia,
-        group: 'camera/CAMERA_ID' as const,
+        media: testCameraMedia,
+        group: 'camera/camera-1' as const,
        content: '',
        type: 'range' as const,
      };
@@ -6,6 +6,7 @@ import {
  QueryType,
  RecordingQuery,
 } from '../../src/camera-manager/types';
+import { FolderQuery } from '../../src/card-controller/folders/types';
 import { setify } from '../../src/utils/basic';
 import {
  EventMediaQuery,
@@ -70,6 +71,28 @@ describe('EventMediaQuery', () => {
    expect(query.convertToClipsQueries().getQuery()).toBeNull();
  });

+  describe('should determine equality', () => {
+    it('should return true when query is equal', () => {
+      const rawQueries_1 = createRawEventQueries('office', { hasSnapshot: true });
+      const query_1 = new EventMediaQuery(rawQueries_1);
+
+      const rawQueries_2 = createRawEventQueries('office', { hasSnapshot: true });
+      const query_2 = new EventMediaQuery(rawQueries_2);
+
+      expect(query_1.isEqual(query_2)).toBeTruthy();
+    });
+
+    it('should return false when query is not equal', () => {
+      const rawQueries_1 = createRawEventQueries('office', { hasSnapshot: true });
+      const query_1 = new EventMediaQuery(rawQueries_1);
+
+      const rawQueries_2 = createRawEventQueries('office', { hasSnapshot: false });
+      const query_2 = new EventMediaQuery(rawQueries_2);
+
+      expect(query_1.isEqual(query_2)).toBeFalsy();
+    });
+  });
+
  it('should clone', () => {
    const rawQueries = createRawEventQueries('office', { hasSnapshot: true });
    const query = new EventMediaQuery(rawQueries);
@@ -288,9 +311,9 @@ describe('RecordingMediaQuery', () => {

 describe('FolderViewQuery', () => {
  it('should construct', () => {
-    const rawQuery = {
+    const rawQuery: FolderQuery = {
      folder: createFolder(),
-      path: 'path',
+      path: [{}],
    };

    const query = new FolderViewQuery(rawQuery);
@@ -1,52 +1,48 @@
 import { describe, expect, it, vi } from 'vitest';
-import { QueryType } from '../../src/camera-manager/types';
+import { mock } from 'vitest-mock-extended';
+import { FoldersManager } from '../../src/card-controller/folders/manager';
 import { AdvancedCameraCardView } from '../../src/config/schema/common/const';
 import { CapabilityKey } from '../../src/types';
-import { EventMediaQuery } from '../../src/view/query';
-import { QueryResults } from '../../src/view/query-results';
 import {
  getCameraIDsForViewName,
  isViewSupportedByCamera,
-  isViewSupportedByQueryOnly,
 } from '../../src/view/view-support';
 import {
  createCameraConfig,
  createCameraManager,
  createCapabilities,
+  createFolder,
  createStore,
-  generateViewMediaArray,
 } from '../test-utils';

 describe('getCameraIDsForViewName', () => {
  describe('views that are always supported', () => {
-    it.each([
-      ['diagnostics' as const],
-      ['folder' as const],
-      ['folders' as const],
-      ['image' as const],
-      ['media' as const],
-    ])('%s', (viewName: AdvancedCameraCardView) => {
-      const cameraManager = createCameraManager();
-      vi.mocked(cameraManager.getStore).mockReturnValue(
-        createStore([
-          {
-            cameraID: 'camera-1',
-            config: createCameraConfig({ dependencies: { cameras: ['camera-2'] } }),
-          },
-          { cameraID: 'camera-2' },
-        ]),
-      );
+    it.each([['diagnostics' as const], ['image' as const], ['media' as const]])(
+      '%s',
+      (viewName: AdvancedCameraCardView) => {
+        const cameraManager = createCameraManager();
+        vi.mocked(cameraManager.getStore).mockReturnValue(
+          createStore([
+            {
+              cameraID: 'camera-1',
+              config: createCameraConfig({ dependencies: { cameras: ['camera-2'] } }),
+            },
+            { cameraID: 'camera-2' },
+          ]),
+        );
+        const foldersManager = mock<FoldersManager>();

-      expect(getCameraIDsForViewName(viewName, cameraManager)).toEqual(
-        new Set(['camera-1', 'camera-2']),
-      );
-      expect(getCameraIDsForViewName(viewName, cameraManager, 'camera-1')).toEqual(
-        new Set(['camera-1', 'camera-2']),
-      );
-      expect(getCameraIDsForViewName(viewName, cameraManager, 'camera-2')).toEqual(
-        new Set(['camera-1', 'camera-2']),
-      );
-    });
+        expect(getCameraIDsForViewName(viewName, cameraManager, foldersManager)).toEqual(
+          new Set(['camera-1', 'camera-2']),
+        );
+        expect(
+          getCameraIDsForViewName(viewName, cameraManager, foldersManager, 'camera-1'),
+        ).toEqual(new Set(['camera-1', 'camera-2']));
+        expect(
+          getCameraIDsForViewName(viewName, cameraManager, foldersManager, 'camera-2'),
+        ).toEqual(new Set(['camera-1', 'camera-2']));
+      },
+    );
  });

  describe('views that respect dependencies and need a capability', () => {
@@ -69,8 +65,9 @@ describe('getCameraIDsForViewName', () => {
          },
        ]),
      );
+      const foldersManager = mock<FoldersManager>();

-      expect(getCameraIDsForViewName(viewName, cameraManager)).toEqual(
+      expect(getCameraIDsForViewName(viewName, cameraManager, foldersManager)).toEqual(
        new Set(['camera-2']),
      );
    });
@@ -96,15 +93,82 @@ describe('getCameraIDsForViewName', () => {
          },
        ]),
      );
+      const foldersManager = mock<FoldersManager>();

-      expect(getCameraIDsForViewName(viewName, cameraManager)).toEqual(
+      expect(getCameraIDsForViewName(viewName, cameraManager, foldersManager)).toEqual(
        new Set(['camera-1', 'camera-2']),
      );
-      expect(getCameraIDsForViewName(viewName, cameraManager, 'camera-1')).toEqual(
-        new Set(['camera-1', 'camera-2']),
+      expect(
+        getCameraIDsForViewName(viewName, cameraManager, foldersManager, 'camera-1'),
+      ).toEqual(new Set(['camera-1', 'camera-2']));
+      expect(
+        getCameraIDsForViewName(viewName, cameraManager, foldersManager, 'camera-2'),
+      ).toEqual(new Set(['camera-2']));
+    });
+  });
+
+  describe('views that respect a folder', () => {
+    describe('should return cameras when a folder is present', () => {
+      it.each([['folder' as const], ['folders' as const], ['timeline' as const]])(
+        '%s',
+        (viewName: AdvancedCameraCardView) => {
+          const cameraManager = createCameraManager();
+          vi.mocked(cameraManager.getStore).mockReturnValue(
+            createStore([
+              {
+                cameraID: 'camera-1',
+                config: createCameraConfig({ dependencies: { cameras: ['camera-2'] } }),
+              },
+              {
+                cameraID: 'camera-2',
+              },
+            ]),
+          );
+          const foldersManager = mock<FoldersManager>();
+          vi.mocked(foldersManager.getFolder).mockReturnValue(createFolder());
+
+          expect(
+            getCameraIDsForViewName(viewName, cameraManager, foldersManager),
+          ).toEqual(new Set(['camera-1', 'camera-2']));
+          expect(
+            getCameraIDsForViewName(viewName, cameraManager, foldersManager, 'camera-1'),
+          ).toEqual(new Set(['camera-1', 'camera-2']));
+          expect(
+            getCameraIDsForViewName(viewName, cameraManager, foldersManager, 'camera-2'),
+          ).toEqual(new Set(['camera-1', 'camera-2']));
+        },
      );
-      expect(getCameraIDsForViewName(viewName, cameraManager, 'camera-2')).toEqual(
-        new Set(['camera-2']),
+    });
+
+    describe('should not return cameras when a folder is absent', () => {
+      it.each([['folder' as const], ['folders' as const], ['timeline' as const]])(
+        '%s',
+        (viewName: AdvancedCameraCardView) => {
+          const cameraManager = createCameraManager();
+          vi.mocked(cameraManager.getStore).mockReturnValue(
+            createStore([
+              {
+                cameraID: 'camera-1',
+                config: createCameraConfig({ dependencies: { cameras: ['camera-2'] } }),
+              },
+              {
+                cameraID: 'camera-2',
+              },
+            ]),
+          );
+          const foldersManager = mock<FoldersManager>();
+          vi.mocked(foldersManager.getFolder).mockReturnValue(null);
+
+          expect(
+            getCameraIDsForViewName(viewName, cameraManager, foldersManager),
+          ).toEqual(new Set());
+          expect(
+            getCameraIDsForViewName(viewName, cameraManager, foldersManager, 'camera-1'),
+          ).toEqual(new Set());
+          expect(
+            getCameraIDsForViewName(viewName, cameraManager, foldersManager, 'camera-2'),
+          ).toEqual(new Set());
+        },
      );
    });
  });
@@ -121,8 +185,11 @@ describe('isViewSupportedByCamera', () => {
        },
      ]),
    );
+    const foldersManager = mock<FoldersManager>();

-    expect(isViewSupportedByCamera('live', cameraManager, 'camera-1')).toBe(true);
+    expect(
+      isViewSupportedByCamera('live', cameraManager, foldersManager, 'camera-1'),
+    ).toBe(true);
  });

  it('should return false for unsupported view', () => {
@@ -135,43 +202,10 @@ describe('isViewSupportedByCamera', () => {
        },
      ]),
    );
+    const foldersManager = mock<FoldersManager>();

-    expect(isViewSupportedByCamera('live', cameraManager, 'camera-1')).toBe(false);
-  });
-});
-
-describe('isViewSupportedByQueryOnly', () => {
-  it.each([
-    ['live' as const],
-    ['image' as const],
-    ['diagnostics' as const],
-    ['clip' as const],
-    ['clips' as const],
-    ['snapshot' as const],
-    ['snapshots' as const],
-    ['recording' as const],
-    ['recordings' as const],
-    ['media' as const],
-  ])('%s', (viewName: AdvancedCameraCardView) => {
-    expect(isViewSupportedByQueryOnly(viewName)).toBe(false);
-  });
-
-  it('should return false for timeline without query', () => {
-    expect(isViewSupportedByQueryOnly('timeline')).toBe(false);
-  });
-
-  it('should return true for timeline with query and query results', () => {
-    const query = new EventMediaQuery([
-      {
-        type: QueryType.Event,
-        cameraIDs: new Set(['camera-1']),
-      },
-    ]);
-    const queryResults = new QueryResults({
-      results: generateViewMediaArray({ count: 5 }),
-      selectedIndex: 0,
-    });
-
-    expect(isViewSupportedByQueryOnly('timeline', query, queryResults)).toBe(true);
+    expect(
+      isViewSupportedByCamera('live', cameraManager, foldersManager, 'camera-1'),
+    ).toBe(false);
  });
 });