Remove unnecessary error handling parameter.

src/components/media-filter.ts

@@ -13,7 +13,7 @@ import { createRef, ref, Ref } from 'lit/directives/ref.js';
 import { DateRange } from '../camera-manager/range';
 import { localize } from '../localize/localize';
 import mediaFilterStyle from '../scss/media-filter.scss';
-import { executeMediaQueryForView } from '../utils/media-to-view.js';
+import { executeMediaQueryForViewWithErrorDispatching } from '../utils/media-to-view.js';
 import { errorToConsole, formatDate, prettifyTitle } from '../utils/basic';
 import { ScopedRegistryHost } from '@lit-labs/scoped-registry-mixin';
 import './select';
@@ -228,7 +228,7 @@ class FrigateCardMediaFilter extends ScopedRegistryHost(LitElement) {
       ]);
 
       (
-        await executeMediaQueryForView(
+        await executeMediaQueryForViewWithErrorDispatching(
           this,
           this.cameraManager,
           this.view,
@@ -251,7 +251,7 @@ class FrigateCardMediaFilter extends ScopedRegistryHost(LitElement) {
       ]);
 
       (
-        await executeMediaQueryForView(
+        await executeMediaQueryForViewWithErrorDispatching(
           this,
           this.cameraManager,
           this.view,
@@ -404,7 +404,7 @@ class FrigateCardMediaFilter extends ScopedRegistryHost(LitElement) {
       ...(what && { what: what }),
       ...(where && { where: where }),
       ...(favorite !== undefined && { favorite: favorite }),
-      ...(tags && { tags: tags })
+      ...(tags && { tags: tags }),
     };
   }
 
@@ -472,18 +472,18 @@ class FrigateCardMediaFilter extends ScopedRegistryHost(LitElement) {
           </frigate-card-select>`
         : ''}
       ${areEvents && this._mediaMetadataController.tagsOptions.length
-          ? html` <frigate-card-select
+        ? html` <frigate-card-select
-              ${ref(this._refTags)}
+            ${ref(this._refTags)}
-              label=${localize('media_filter.tag')}
+            label=${localize('media_filter.tag')}
-              placeholder=${localize('media_filter.select_tag')}
+            placeholder=${localize('media_filter.select_tag')}
-              clearable
+            clearable
-              multiple
+            multiple
-              .options=${this._mediaMetadataController.tagsOptions}
+            .options=${this._mediaMetadataController.tagsOptions}
-              .value=${this._defaults?.tags}
+            .value=${this._defaults?.tags}
-              @frigate-card:select:change=${this._valueChangedHandler.bind(this)}
+            @frigate-card:select:change=${this._valueChangedHandler.bind(this)}
-            >
+          >
-            </frigate-card-select>`
+          </frigate-card-select>`
-          : ''}
+        : ''}
       ${areEvents && this._mediaMetadataController.whereOptions.length
         ? html` <frigate-card-select
             ${ref(this._refWhere)}
@@ -527,10 +527,7 @@ export class MediaMetadataController implements ReactiveController {
   public whatOptions: SelectOption[] = [];
   public whereOptions: SelectOption[] = [];
 
-  constructor(
+  constructor(host: ReactiveControllerHost, cameraManager: CameraManager) {
-    host: ReactiveControllerHost,
-    cameraManager: CameraManager,
-  ) {
     this._host = host;
     this._cameraManager = cameraManager;
     host.addController(this);

src/components/timeline-core.ts

@@ -50,7 +50,10 @@ import {
   isTruthy,
   setOrRemoveAttribute,
 } from '../utils/basic';
-import { executeMediaQueryForView, findBestMediaIndex } from '../utils/media-to-view';
+import {
+  executeMediaQueryForViewWithErrorDispatching,
+  findBestMediaIndex,
+} from '../utils/media-to-view';
 import { FrigateCardTimelineItem, TimelineDataSource } from '../utils/timeline-source';
 import { ViewMedia } from '../view/media';
 import { ViewMediaClassifier } from '../view/media-classifier';
@@ -580,7 +583,7 @@ export class FrigateCardTimelineCore extends LitElement {
     ) {
       const query = this._createMediaQueries('recording');
       if (query) {
-        view = await executeMediaQueryForView(
+        view = await executeMediaQueryForViewWithErrorDispatching(
           this,
           this.cameraManager,
           this.view,
@@ -734,7 +737,7 @@ export class FrigateCardTimelineCore extends LitElement {
     if (!this.hass || !this.cameraManager || !this.view || !query) {
       return null;
     }
-    const view = await executeMediaQueryForView(
+    const view = await executeMediaQueryForViewWithErrorDispatching(
       this,
       this.cameraManager,
       this.view,
@@ -971,12 +974,7 @@ export class FrigateCardTimelineCore extends LitElement {
    * Update the timeline from the view object.
    */
   protected async _updateTimelineFromView(): Promise<void> {
-    if (
+    if (!this.view || !this.timelineConfig || !this._timelineSource || !this._timeline) {
-      !this.view ||
-      !this.timelineConfig ||
-      !this._timelineSource ||
-      !this._timeline
-    ) {
       return;
     }
 

src/utils/card-controller/view-manager.ts

@@ -101,7 +101,6 @@ export class ViewManager {
   }
 
   public async setViewWithNewDisplayMode(displayMode: ViewDisplayMode): Promise<void> {
-    const host = this._api.getCardElementManager().getElement();
     const hass = this._api.getHASSManager().getHASS();
 
     if (this._view && hass) {
@@ -125,18 +124,22 @@ export class ViewManager {
         // query for more than one camera, reset the query results, change the
         // existing query to refer to all cameras and execute it to fetch new
         // results.
-        const viewWithNewQuery = await executeMediaQueryForView(
+        let viewWithNewQuery: View | null = null;
-          host,
+        try {
-          this._api.getCameraManager(),
+          viewWithNewQuery = await executeMediaQueryForView(
-          view,
+            this._api.getCameraManager(),
-          view.query
+            view,
-            .clone()
+            view.query
-            .setQueryCameraIDs(
+              .clone()
-              view.isGrid()
+              .setQueryCameraIDs(
-                ? this._api.getCameraManager().getStore().getVisibleCameraIDs()
+                view.isGrid()
-                : view.camera,
+                  ? this._api.getCameraManager().getStore().getVisibleCameraIDs()
-            ),
+                  : view.camera,
-        );
+              ),
+          );
+        } catch (e: unknown) {
+          this._api.getMessageManager().setErrorIfHigherPriority(e);
+        }
 
         if (viewWithNewQuery) {
           return this._setView(viewWithNewQuery);

src/utils/media-to-view.ts

@@ -44,10 +44,16 @@ export const changeViewToRecentEventsForCameraAndDependents = async (
   }
 
   (
-    await executeMediaQueryForView(element, cameraManager, view, queries, {
+    await executeMediaQueryForViewWithErrorDispatching(
-      targetView: options?.targetView,
+      element,
-      select: options?.select,
+      cameraManager,
-    })
+      view,
+      queries,
+      {
+        targetView: options?.targetView,
+        select: options?.select,
+      },
+    )
   )?.dispatchChangeEvent(element);
 };
 
@@ -106,10 +112,16 @@ export const changeViewToRecentRecordingForCameraAndDependents = async (
   }
 
   (
-    await executeMediaQueryForView(element, cameraManager, view, queries, {
+    await executeMediaQueryForViewWithErrorDispatching(
-      targetView: options?.targetView,
+      element,
-      select: options?.select,
+      cameraManager,
-    })
+      view,
+      queries,
+      {
+        targetView: options?.targetView,
+        select: options?.select,
+      },
+    )
   )?.dispatchChangeEvent(element);
 };
 
@@ -127,7 +139,6 @@ const createQueriesForRecordingsView = (
 };
 
 export const executeMediaQueryForView = async (
-  element: HTMLElement,
   cameraManager: CameraManager,
   view: View,
   query: MediaQueries,
@@ -138,21 +149,12 @@ export const executeMediaQueryForView = async (
     select?: ResultSelectType;
   },
 ): Promise<View | null> => {
-  let mediaArray: ViewMedia[] | null;
-
   const queries = query.getQueries();
   if (!queries) {
     return null;
   }
 
-  try {
+  const mediaArray = await cameraManager.executeMediaQueries<MediaQuery>(queries);
-    mediaArray = await cameraManager.executeMediaQueries<MediaQuery>(queries);
-  } catch (e) {
-    errorToConsole(e as Error);
-    dispatchFrigateCardErrorEvent(element, e as Error);
-    return null;
-  }
-
   if (!mediaArray) {
     return null;
   }
@@ -182,6 +184,32 @@ export const executeMediaQueryForView = async (
     .mergeInContext(viewerContext);
 };
 
+export const executeMediaQueryForViewWithErrorDispatching = async (
+  element: HTMLElement,
+  cameraManager: CameraManager,
+  view: View,
+  query: MediaQueries,
+  options?: {
+    targetCameraID?: string;
+    targetView?: FrigateCardView;
+    targetTime?: Date;
+    select?: ResultSelectType;
+  },
+): Promise<View | null> => {
+  try {
+    return await executeMediaQueryForView(cameraManager, view, query, {
+      targetCameraID: options?.targetCameraID,
+      targetView: options?.targetView,
+      targetTime: options?.targetTime,
+      select: options?.select,
+    });
+  } catch (e: unknown) {
+    errorToConsole(e as Error);
+    dispatchFrigateCardErrorEvent(element, e as Error);
+  }
+  return null;
+};
+
 /**
  * Find the longest matching media object that contains a given targetTime.
  * Longest is chosen to give the most stability to the media viewer.

tests/utils/card-controller/view-manager.test.ts

@@ -496,7 +496,7 @@ describe('ViewManager.setViewWithNewDisplayMode', () => {
     manager.setView(originalView);
 
     // Query execution fails / returns null.
-    vi.mocked(cameraManager.executeMediaQueries).mockResolvedValue(null);
+    vi.mocked(cameraManager.executeMediaQueries).mockRejectedValue(null);
 
     await manager.setViewWithNewDisplayMode('single');
 

tests/utils/media-to-view.test.ts

@@ -6,6 +6,7 @@ import {
   changeViewToRecentEventsForCameraAndDependents,
   changeViewToRecentRecordingForCameraAndDependents,
   executeMediaQueryForView,
+  executeMediaQueryForViewWithErrorDispatching,
   findBestMediaIndex,
 } from '../../src/utils/media-to-view';
 import { ViewMedia } from '../../src/view/media';
@@ -205,13 +206,11 @@ describe('executeMediaQueryForView', () => {
   });
 
   it('should not execute empty queries', async () => {
-    const elementHandler = createElementListenForView();
     const cameraConfigs: CameraConfigs = new Map();
     const cameraManager = createCameraManager({ configs: cameraConfigs });
 
     expect(
       await executeMediaQueryForView(
-        elementHandler.element,
         cameraManager,
         createView(),
         new EventMediaQueries(),
@@ -219,8 +218,23 @@ describe('executeMediaQueryForView', () => {
     ).toBeNull();
   });
 
+  it('should throw on failure', async () => {
+    const cameraConfigs: CameraConfigs = new Map();
+    const cameraManager = createCameraManager({ configs: cameraConfigs });
+    vi.mocked(cameraManager.executeMediaQueries).mockRejectedValue(new Error());
+
+    await expect(
+      executeMediaQueryForView(
+        cameraManager,
+        createView(),
+        new EventMediaQueries(
+          cameraManager.generateDefaultEventQueries('camera') ?? undefined,
+        ),
+      ),
+    ).rejects.toThrowError();
+  });
+
   it('should select time-based result', async () => {
-    const elementHandler = createElementListenForView();
     const cameraConfigs: CameraConfigs = new Map();
     const cameraManager = createCameraManager({ configs: cameraConfigs });
 
@@ -233,7 +247,6 @@ describe('executeMediaQueryForView', () => {
     vi.mocked(cameraManager.executeMediaQueries).mockResolvedValue(mediaArray);
 
     const view = await executeMediaQueryForView(
-      elementHandler.element,
       cameraManager,
       createView(),
       new EventMediaQueries(
@@ -251,7 +264,6 @@ describe('executeMediaQueryForView', () => {
   });
 
   it('should select nothing when time-based selection does not match', async () => {
-    const elementHandler = createElementListenForView();
     const cameraConfigs: CameraConfigs = new Map();
     const cameraManager = createCameraManager({ configs: cameraConfigs });
 
@@ -265,7 +277,6 @@ describe('executeMediaQueryForView', () => {
     vi.mocked(cameraManager.executeMediaQueries).mockResolvedValue(mediaArray);
 
     const view = await executeMediaQueryForView(
-      elementHandler.element,
       cameraManager,
       createView(),
       new EventMediaQueries(
@@ -378,6 +389,29 @@ describe('changeViewToRecentRecordingForCameraAndDependents', () => {
   });
 });
 
+// @vitest-environment jsdom
+describe('executeMediaQueryForViewWithErrorDispatching', () => {
+  it('should dispatch error message on fail', async () => {
+    vi.spyOn(global.console, 'warn').mockImplementation(() => true);
+
+    const elementHandler = createElementListenForView();
+    const cameraManager = createCameraManager();
+    vi.mocked(cameraManager.executeMediaQueries).mockRejectedValue(new Error());
+
+    await executeMediaQueryForViewWithErrorDispatching(
+      elementHandler.element,
+      cameraManager,
+      createView(),
+      new EventMediaQueries(
+        cameraManager.generateDefaultEventQueries('camera') ?? undefined,
+      ),
+    );
+
+    expect(elementHandler.viewHandler).not.toBeCalled();
+    expect(elementHandler.messageHandler).toBeCalled();
+  });
+});
+
 // @vitest-environment jsdom
 describe('findBestMediaIndex', () => {
   it('should find best media index', async () => {