@luxexchange/notifications 1.0.0

package/src/index.ts

@@ -0,0 +1,41 @@
+export { getIsNotificationServiceLocalOverrideEnabled } from './getIsNotificationServiceLocalOverrideEnabled'
+export { getNotificationQueryOptions } from './notification-data-source/getNotificationQueryOptions'
+export { createIntervalNotificationDataSource } from './notification-data-source/implementations/createIntervalNotificationDataSource'
+export {
+  type CreateLocalTriggerDataSourceContext,
+  createLocalTriggerDataSource,
+  getTriggerById,
+  type TriggerCondition,
+} from './notification-data-source/implementations/createLocalTriggerDataSource'
+export { createNotificationDataSource } from './notification-data-source/implementations/createNotificationDataSource'
+export { createPollingNotificationDataSource } from './notification-data-source/implementations/createPollingNotificationDataSource'
+export {
+  type CreateReactiveDataSourceContext,
+  createReactiveDataSource,
+} from './notification-data-source/implementations/createReactiveDataSource'
+export { type NotificationDataSource } from './notification-data-source/NotificationDataSource'
+export { type ReactiveCondition } from './notification-data-source/types/ReactiveCondition'
+export { createBaseNotificationProcessor } from './notification-processor/implementations/createBaseNotificationProcessor'
+export { type NotificationProcessor } from './notification-processor/NotificationProcessor'
+export { BannerTemplate } from './notification-renderer/components/BannerTemplate'
+export { InlineBannerNotification } from './notification-renderer/components/InlineBannerNotification'
+export { createNotificationRenderer } from './notification-renderer/implementations/createNotificationRenderer'
+export { type NotificationRenderer } from './notification-renderer/NotificationRenderer'
+export { createNotificationService } from './notification-service/implementations/createNotificationService'
+export {
+  type NotificationClickTarget,
+  type NotificationService,
+  type NotificationServiceConfig,
+} from './notification-service/NotificationService'
+export { createNotificationTelemetry } from './notification-telemetry/implementations/createNotificationTelemetry'
+export {
+  createNoopNotificationTelemetry,
+  type NotificationTelemetry,
+} from './notification-telemetry/NotificationTelemetry'
+export {
+  type ApiNotificationTrackerContext,
+  createApiNotificationTracker,
+} from './notification-tracker/implementations/createApiNotificationTracker'
+export { createNoopNotificationTracker } from './notification-tracker/implementations/createNoopNotificationTracker'
+export { createNotificationTracker } from './notification-tracker/implementations/createNotificationTracker'
+export { type NotificationTracker } from './notification-tracker/NotificationTracker'

package/src/notification-data-source/NotificationDataSource.ts

@@ -0,0 +1,8 @@
+import { type InAppNotification } from '@luxfi/api'
+
+export interface NotificationDataSource {
+  // Start receiving notifications (implementation determines mechanism: fetch, websocket, polling, etc.)
+  start(onNotifications: (notifications: InAppNotification[], source: string) => void): void
+  // Stop receiving notifications and cleanup
+  stop(): Promise<void>
+}

package/src/notification-data-source/getNotificationQueryOptions.ts

@@ -0,0 +1,85 @@
+import { toPlainMessage } from '@bufbuild/protobuf'
+import { queryOptions } from '@tanstack/react-query'
+import { PlatformType } from '@uniswap/client-notification-service/dist/uniswap/notificationservice/v1/api_pb'
+import type { InAppNotification, NotificationsApiClient } from '@luxexchange/api'
+import { getLogger } from '@luxfi/utilities/src/logger/logger'
+import { ReactQueryCacheKey } from '@luxfi/utilities/src/reactQuery/cache'
+import { type QueryOptionsResult } from '@luxfi/utilities/src/reactQuery/queryOptions'
+import { ONE_MINUTE_MS } from '@luxfi/utilities/src/time/time'
+
+const DEFAULT_POLL_INTERVAL_MS = 2 * ONE_MINUTE_MS
+
+interface GetNotificationQueryOptionsContext {
+  apiClient: NotificationsApiClient
+  getPlatformType: () => PlatformType
+  pollIntervalMs?: number
+  getIsSessionInitialized?: () => boolean
+}
+
+/**
+ * Creates query options for polling notifications.
+ * This can be used directly in hooks or injected into the notification data source.
+ *
+ * @example
+ * ```typescript
+ * import { getNotificationQueryOptions } from '@luxexchange/notifications'
+ * import { useQuery } from '@tanstack/react-query'
+ *
+ * // Use in a hook
+ * const queryOptions = getNotificationQueryOptions({ apiClient })
+ * const { data } = useQuery(queryOptions)
+ *
+ * // Or inject into data source
+ * const dataSource = createFetchNotificationDataSource({
+ *   queryClient,
+ *   queryOptions,
+ * })
+ * ```
+ */
+export function getNotificationQueryOptions(
+  ctx: GetNotificationQueryOptionsContext,
+): QueryOptionsResult<InAppNotification[], Error, InAppNotification[], [ReactQueryCacheKey.Notifications]> {
+  const { apiClient, getPlatformType, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS, getIsSessionInitialized } = ctx
+
+  return queryOptions({
+    queryKey: [ReactQueryCacheKey.Notifications],
+    queryFn: async (): Promise<InAppNotification[]> => {
+      const isSessionInitialized = getIsSessionInitialized?.() ?? true
+
+      if (getIsSessionInitialized && !isSessionInitialized) {
+        return []
+      }
+
+      try {
+        const platformType = getPlatformType()
+        const response = await apiClient.getNotifications({ platform_type: platformType })
+        // Convert protobuf Messages to plain objects for React Query caching
+        // toPlainMessage strips the Message prototype chain and preserves numeric enum values
+        // It's schema-aware and automatically handles nested messages, making it resilient to schema changes
+        const serialized: InAppNotification[] = response.notifications.map((notification) =>
+          toPlainMessage(notification),
+        )
+        return serialized
+      } catch (error) {
+        getLogger().error(error, {
+          tags: { file: 'notificationQueryOptions', function: 'queryFn' },
+        })
+        throw error
+      }
+    },
+    refetchInterval: getIsSessionInitialized
+      ? (): number => {
+          const isInit = getIsSessionInitialized()
+          // Poll faster (2s) when waiting for session, normal interval once initialized
+          return isInit ? pollIntervalMs : 2000
+        }
+      : (): number => pollIntervalMs,
+    refetchIntervalInBackground: true,
+    refetchOnWindowFocus: false,
+    // Use short staleTime when session check is enabled - allows faster refetches when session becomes ready
+    // Without this, empty results from pre-session fetches would be cached too long
+    staleTime: getIsSessionInitialized ? 1000 : pollIntervalMs - 1000,
+    retry: 2,
+    retryDelay: (attemptIndex: number): number => Math.min(1000 * 2 ** attemptIndex, 30000),
+  })
+}

package/src/notification-data-source/implementations/createIntervalNotificationDataSource.ts

@@ -0,0 +1,73 @@
+import { type InAppNotification } from '@luxexchange/api'
+import { createNotificationDataSource } from '@luxexchange/notifications/src/notification-data-source/implementations/createNotificationDataSource'
+import { type NotificationDataSource } from '@luxexchange/notifications/src/notification-data-source/NotificationDataSource'
+import { getLogger } from '@luxfi/utilities/src/logger/logger'
+
+interface CreateIntervalNotificationDataSourceContext {
+  pollIntervalMs: number
+  source: string
+  logFileTag: string
+  getNotifications: () => Promise<InAppNotification[]>
+}
+
+/**
+ * Helper for building interval-based notification data sources.
+ * Handles start/stop lifecycle, immediate initial poll, and consistent error logging.
+ */
+export function createIntervalNotificationDataSource(
+  ctx: CreateIntervalNotificationDataSourceContext,
+): NotificationDataSource {
+  const { pollIntervalMs, source, logFileTag, getNotifications } = ctx
+
+  let intervalId: ReturnType<typeof setInterval> | null = null
+  let currentCallback: ((notifications: InAppNotification[], source: string) => void) | null = null
+
+  const pollAndEmit = async (logFunctionTag: string): Promise<void> => {
+    if (!currentCallback) {
+      return
+    }
+
+    try {
+      const notifications = await getNotifications()
+      currentCallback(notifications, source)
+    } catch (error) {
+      getLogger().error(error, {
+        tags: { file: logFileTag, function: logFunctionTag },
+      })
+    }
+  }
+
+  const start = (onNotifications: (notifications: InAppNotification[], source: string) => void): void => {
+    if (intervalId) {
+      return
+    }
+
+    currentCallback = onNotifications
+
+    // Check immediately on start
+    pollAndEmit('start').catch((error) => {
+      getLogger().error(error, {
+        tags: { file: logFileTag, function: 'start' },
+      })
+    })
+
+    // Then poll at interval
+    intervalId = setInterval(() => {
+      pollAndEmit('setInterval').catch((error) => {
+        getLogger().error(error, {
+          tags: { file: logFileTag, function: 'setInterval' },
+        })
+      })
+    }, pollIntervalMs)
+  }
+
+  const stop = async (): Promise<void> => {
+    if (intervalId) {
+      clearInterval(intervalId)
+      intervalId = null
+    }
+    currentCallback = null
+  }
+
+  return createNotificationDataSource({ start, stop })
+}

package/src/notification-data-source/implementations/createLocalTriggerDataSource.test.ts

@@ -0,0 +1,492 @@
+import {
+  Content,
+  Metadata,
+  Notification,
+} from '@uniswap/client-notification-service/dist/uniswap/notificationservice/v1/api_pb'
+import type { InAppNotification } from '@luxexchange/api'
+import { ContentStyle } from '@luxexchange/api'
+import {
+  createLocalTriggerDataSource,
+  getTriggerById,
+  type TriggerCondition,
+} from '@luxexchange/notifications/src/notification-data-source/implementations/createLocalTriggerDataSource'
+import { type NotificationTracker } from '@luxexchange/notifications/src/notification-tracker/NotificationTracker'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+function createMockNotification(id: string): InAppNotification {
+  return new Notification({
+    id,
+    metadata: new Metadata({ owner: 'test', business: 'test' }),
+    content: new Content({ style: ContentStyle.MODAL, title: 'Test Notification' }),
+  })
+}
+
+function createMockTracker(processedIds: Set<string> = new Set()): NotificationTracker {
+  return {
+    isProcessed: vi.fn().mockImplementation((id: string) => Promise.resolve(processedIds.has(id))),
+    getProcessedIds: vi.fn().mockResolvedValue(processedIds),
+    track: vi.fn().mockResolvedValue(undefined),
+    cleanup: vi.fn().mockResolvedValue(undefined),
+  }
+}
+
+describe('createLocalTriggerDataSource', () => {
+  let mockTracker: NotificationTracker
+
+  beforeEach(() => {
+    vi.useFakeTimers()
+    mockTracker = createMockTracker()
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+    vi.clearAllMocks()
+  })
+
+  it('creates a notification data source with start and stop methods', () => {
+    const dataSource = createLocalTriggerDataSource({
+      triggers: [],
+      tracker: mockTracker,
+    })
+
+    expect(dataSource).toBeDefined()
+    expect(typeof dataSource.start).toBe('function')
+    expect(typeof dataSource.stop).toBe('function')
+  })
+
+  it('checks triggers immediately on start', async () => {
+    const mockNotification = createMockNotification('local:test')
+    const trigger: TriggerCondition = {
+      id: 'local:test',
+      shouldShow: vi.fn().mockReturnValue(true),
+      createNotification: vi.fn().mockReturnValue(mockNotification),
+    }
+
+    const dataSource = createLocalTriggerDataSource({
+      triggers: [trigger],
+      tracker: mockTracker,
+    })
+
+    const onNotifications = vi.fn()
+    dataSource.start(onNotifications)
+
+    // Allow the initial async poll to complete
+    await vi.advanceTimersByTimeAsync(0)
+
+    expect(trigger.shouldShow).toHaveBeenCalled()
+    expect(onNotifications).toHaveBeenCalledWith([mockNotification], 'local_triggers')
+
+    await dataSource.stop()
+  })
+
+  it('polls triggers at the specified interval', async () => {
+    const trigger: TriggerCondition = {
+      id: 'local:test',
+      shouldShow: vi.fn().mockReturnValue(false),
+      createNotification: vi.fn(),
+    }
+
+    const dataSource = createLocalTriggerDataSource({
+      triggers: [trigger],
+      tracker: mockTracker,
+      pollIntervalMs: 1000,
+    })
+
+    const onNotifications = vi.fn()
+    dataSource.start(onNotifications)
+
+    // Initial check (immediate poll on start)
+    await vi.advanceTimersByTimeAsync(0)
+    expect(trigger.shouldShow).toHaveBeenCalledTimes(1)
+
+    // Advance by poll interval
+    await vi.advanceTimersByTimeAsync(1000)
+    expect(trigger.shouldShow).toHaveBeenCalledTimes(2)
+
+    // Advance again
+    await vi.advanceTimersByTimeAsync(1000)
+    expect(trigger.shouldShow).toHaveBeenCalledTimes(3)
+
+    await dataSource.stop()
+  })
+
+  it('skips triggers that are already processed', async () => {
+    const processedTracker = createMockTracker(new Set(['local:processed']))
+
+    const processedTrigger: TriggerCondition = {
+      id: 'local:processed',
+      shouldShow: vi.fn().mockReturnValue(true),
+      createNotification: vi.fn(),
+    }
+
+    const unprocessedTrigger: TriggerCondition = {
+      id: 'local:unprocessed',
+      shouldShow: vi.fn().mockReturnValue(true),
+      createNotification: vi.fn().mockReturnValue(createMockNotification('local:unprocessed')),
+    }
+
+    const dataSource = createLocalTriggerDataSource({
+      triggers: [processedTrigger, unprocessedTrigger],
+      tracker: processedTracker,
+    })
+
+    const onNotifications = vi.fn()
+    dataSource.start(onNotifications)
+
+    await vi.advanceTimersByTimeAsync(0)
+
+    // Processed trigger should not have shouldShow called
+    expect(processedTrigger.shouldShow).not.toHaveBeenCalled()
+    // Unprocessed trigger should be evaluated
+    expect(unprocessedTrigger.shouldShow).toHaveBeenCalled()
+    expect(unprocessedTrigger.createNotification).toHaveBeenCalled()
+
+    await dataSource.stop()
+  })
+
+  it('does not create notification when shouldShow returns false', async () => {
+    const trigger: TriggerCondition = {
+      id: 'local:test',
+      shouldShow: vi.fn().mockReturnValue(false),
+      createNotification: vi.fn(),
+    }
+
+    const dataSource = createLocalTriggerDataSource({
+      triggers: [trigger],
+      tracker: mockTracker,
+    })
+
+    const onNotifications = vi.fn()
+    dataSource.start(onNotifications)
+
+    await vi.advanceTimersByTimeAsync(0)
+
+    expect(trigger.shouldShow).toHaveBeenCalled()
+    expect(trigger.createNotification).not.toHaveBeenCalled()
+    expect(onNotifications).toHaveBeenCalledWith([], 'local_triggers')
+
+    await dataSource.stop()
+  })
+
+  it('handles async shouldShow functions', async () => {
+    const mockNotification = createMockNotification('local:async')
+    const trigger: TriggerCondition = {
+      id: 'local:async',
+      shouldShow: vi.fn().mockResolvedValue(true),
+      createNotification: vi.fn().mockReturnValue(mockNotification),
+    }
+
+    const dataSource = createLocalTriggerDataSource({
+      triggers: [trigger],
+      tracker: mockTracker,
+    })
+
+    const onNotifications = vi.fn()
+    dataSource.start(onNotifications)
+
+    await vi.advanceTimersByTimeAsync(0)
+
+    expect(trigger.shouldShow).toHaveBeenCalled()
+    expect(onNotifications).toHaveBeenCalledWith([mockNotification], 'local_triggers')
+
+    await dataSource.stop()
+  })
+
+  it('handles multiple triggers', async () => {
+    const notification1 = createMockNotification('local:trigger1')
+    const notification2 = createMockNotification('local:trigger2')
+
+    const trigger1: TriggerCondition = {
+      id: 'local:trigger1',
+      shouldShow: vi.fn().mockReturnValue(true),
+      createNotification: vi.fn().mockReturnValue(notification1),
+    }
+
+    const trigger2: TriggerCondition = {
+      id: 'local:trigger2',
+      shouldShow: vi.fn().mockReturnValue(true),
+      createNotification: vi.fn().mockReturnValue(notification2),
+    }
+
+    const trigger3: TriggerCondition = {
+      id: 'local:trigger3',
+      shouldShow: vi.fn().mockReturnValue(false),
+      createNotification: vi.fn(),
+    }
+
+    const dataSource = createLocalTriggerDataSource({
+      triggers: [trigger1, trigger2, trigger3],
+      tracker: mockTracker,
+    })
+
+    const onNotifications = vi.fn()
+    dataSource.start(onNotifications)
+
+    await vi.advanceTimersByTimeAsync(0)
+
+    expect(onNotifications).toHaveBeenCalledWith([notification1, notification2], 'local_triggers')
+
+    await dataSource.stop()
+  })
+
+  it('handles errors in individual triggers gracefully', async () => {
+    const goodNotification = createMockNotification('local:good')
+
+    const errorTrigger: TriggerCondition = {
+      id: 'local:error',
+      shouldShow: vi.fn().mockImplementation(() => {
+        throw new Error('Trigger error')
+      }),
+      createNotification: vi.fn(),
+    }
+
+    const goodTrigger: TriggerCondition = {
+      id: 'local:good',
+      shouldShow: vi.fn().mockReturnValue(true),
+      createNotification: vi.fn().mockReturnValue(goodNotification),
+    }
+
+    const dataSource = createLocalTriggerDataSource({
+      triggers: [errorTrigger, goodTrigger],
+      tracker: mockTracker,
+    })
+
+    const onNotifications = vi.fn()
+    dataSource.start(onNotifications)
+
+    await vi.advanceTimersByTimeAsync(0)
+
+    // Should still emit good notification despite error in first trigger
+    expect(onNotifications).toHaveBeenCalledWith([goodNotification], 'local_triggers')
+
+    await dataSource.stop()
+  })
+
+  it('handles errors in tracker.isProcessed gracefully', async () => {
+    const errorTracker = createMockTracker()
+    errorTracker.isProcessed = vi.fn().mockRejectedValue(new Error('Tracker error'))
+
+    const trigger: TriggerCondition = {
+      id: 'local:test',
+      shouldShow: vi.fn().mockReturnValue(true),
+      createNotification: vi.fn(),
+    }
+
+    const dataSource = createLocalTriggerDataSource({
+      triggers: [trigger],
+      tracker: errorTracker,
+    })
+
+    const onNotifications = vi.fn()
+    dataSource.start(onNotifications)
+
+    await vi.advanceTimersByTimeAsync(0)
+
+    // Should emit empty array on error
+    expect(onNotifications).toHaveBeenCalledWith([], 'local_triggers')
+
+    await dataSource.stop()
+  })
+
+  it('does not start twice if already active', async () => {
+    const trigger: TriggerCondition = {
+      id: 'local:test',
+      shouldShow: vi.fn().mockReturnValue(false),
+      createNotification: vi.fn(),
+    }
+
+    const dataSource = createLocalTriggerDataSource({
+      triggers: [trigger],
+      tracker: mockTracker,
+    })
+
+    const onNotifications = vi.fn()
+    dataSource.start(onNotifications)
+
+    // Try to start again
+    dataSource.start(onNotifications)
+
+    await vi.advanceTimersByTimeAsync(0)
+
+    // Should only call shouldShow once from the initial start
+    expect(trigger.shouldShow).toHaveBeenCalledTimes(1)
+
+    await dataSource.stop()
+  })
+
+  it('stops polling when stop is called', async () => {
+    const trigger: TriggerCondition = {
+      id: 'local:test',
+      shouldShow: vi.fn().mockReturnValue(false),
+      createNotification: vi.fn(),
+    }
+
+    const dataSource = createLocalTriggerDataSource({
+      triggers: [trigger],
+      tracker: mockTracker,
+      pollIntervalMs: 100,
+    })
+
+    const onNotifications = vi.fn()
+    dataSource.start(onNotifications)
+
+    await vi.advanceTimersByTimeAsync(0)
+    const callCountBeforeStop = (trigger.shouldShow as ReturnType<typeof vi.fn>).mock.calls.length
+
+    await dataSource.stop()
+
+    // Advance timers after stop
+    await vi.advanceTimersByTimeAsync(500)
+
+    // Should not have additional calls
+    expect(trigger.shouldShow).toHaveBeenCalledTimes(callCountBeforeStop)
+  })
+
+  it('can be started again after stopping', async () => {
+    const trigger: TriggerCondition = {
+      id: 'local:test',
+      shouldShow: vi.fn().mockReturnValue(false),
+      createNotification: vi.fn(),
+    }
+
+    const dataSource = createLocalTriggerDataSource({
+      triggers: [trigger],
+      tracker: mockTracker,
+    })
+
+    const onNotifications = vi.fn()
+
+    // Start, check, stop
+    dataSource.start(onNotifications)
+    await vi.advanceTimersByTimeAsync(0)
+    await dataSource.stop()
+
+    vi.clearAllMocks()
+
+    // Start again
+    dataSource.start(onNotifications)
+    await vi.advanceTimersByTimeAsync(0)
+
+    expect(trigger.shouldShow).toHaveBeenCalled()
+
+    await dataSource.stop()
+  })
+
+  it('uses custom source name', async () => {
+    const trigger: TriggerCondition = {
+      id: 'local:test',
+      shouldShow: vi.fn().mockReturnValue(false),
+      createNotification: vi.fn(),
+    }
+
+    const dataSource = createLocalTriggerDataSource({
+      triggers: [trigger],
+      tracker: mockTracker,
+      source: 'custom_source',
+    })
+
+    const onNotifications = vi.fn()
+    dataSource.start(onNotifications)
+
+    await vi.advanceTimersByTimeAsync(0)
+
+    expect(onNotifications).toHaveBeenCalledWith([], 'custom_source')
+
+    await dataSource.stop()
+  })
+
+  it('uses default poll interval of 5000ms', async () => {
+    const trigger: TriggerCondition = {
+      id: 'local:test',
+      shouldShow: vi.fn().mockReturnValue(false),
+      createNotification: vi.fn(),
+    }
+
+    const dataSource = createLocalTriggerDataSource({
+      triggers: [trigger],
+      tracker: mockTracker,
+    })
+
+    const onNotifications = vi.fn()
+    dataSource.start(onNotifications)
+
+    // Initial check
+    await vi.advanceTimersByTimeAsync(0)
+    expect(trigger.shouldShow).toHaveBeenCalledTimes(1)
+
+    // Advance less than default interval
+    await vi.advanceTimersByTimeAsync(4000)
+    expect(trigger.shouldShow).toHaveBeenCalledTimes(1)
+
+    // Advance to complete the default interval
+    await vi.advanceTimersByTimeAsync(1000)
+    expect(trigger.shouldShow).toHaveBeenCalledTimes(2)
+
+    await dataSource.stop()
+  })
+
+  it('does not call onNotifications after stop even if polling was in progress', async () => {
+    const trigger: TriggerCondition = {
+      id: 'local:test',
+      shouldShow: vi.fn().mockReturnValue(true),
+      createNotification: vi.fn().mockReturnValue(createMockNotification('local:test')),
+    }
+
+    const dataSource = createLocalTriggerDataSource({
+      triggers: [trigger],
+      tracker: mockTracker,
+    })
+
+    const onNotifications = vi.fn()
+    dataSource.start(onNotifications)
+
+    // Stop immediately before any async operations complete
+    await dataSource.stop()
+
+    // Clear any pending timers
+    await vi.runAllTimersAsync()
+
+    // The callback should not be set after stop, so no additional calls
+    // (Initial call may or may not have happened depending on timing)
+    const callCount = onNotifications.mock.calls.length
+    await vi.advanceTimersByTimeAsync(10000)
+    expect(onNotifications).toHaveBeenCalledTimes(callCount)
+  })
+})
+
+describe('getTriggerById', () => {
+  it('returns the trigger with matching ID', () => {
+    const trigger1: TriggerCondition = {
+      id: 'local:trigger1',
+      shouldShow: () => true,
+      createNotification: () => createMockNotification('local:trigger1'),
+    }
+
+    const trigger2: TriggerCondition = {
+      id: 'local:trigger2',
+      shouldShow: () => false,
+      createNotification: () => createMockNotification('local:trigger2'),
+    }
+
+    const triggers = [trigger1, trigger2]
+
+    expect(getTriggerById(triggers, 'local:trigger1')).toBe(trigger1)
+    expect(getTriggerById(triggers, 'local:trigger2')).toBe(trigger2)
+  })
+
+  it('returns undefined when no trigger matches', () => {
+    const triggers: TriggerCondition[] = [
+      {
+        id: 'local:trigger1',
+        shouldShow: () => true,
+        createNotification: () => createMockNotification('local:trigger1'),
+      },
+    ]
+
+    expect(getTriggerById(triggers, 'local:nonexistent')).toBeUndefined()
+  })
+
+  it('returns undefined for empty triggers array', () => {
+    expect(getTriggerById([], 'local:any')).toBeUndefined()
+  })
+})