@freighttech/ui 0.13.18

package/src/backend/messages/useMessageComposeOperations.ts

@@ -0,0 +1,259 @@
+import * as React from 'react'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import type {
+  MessageComposerContextObject,
+  MessageComposerProps,
+  MessageTypeItem,
+} from './message-composer.types'
+import type { MessagePriority } from './message-priority'
+
+type Translator = ReturnType<typeof useT>
+
+type MessageRecipient = {
+  userId: string
+  type: 'to'
+}
+
+type SubmitRequest = {
+  endpoint: string
+  payload: Record<string, unknown>
+}
+
+type BaseOperation = {
+  validate: () => string | null
+  buildRequest: (input: { attachmentIds: string[] }) => SubmitRequest
+  successMessage: string
+  requiresAttachmentRefresh: boolean
+}
+
+type ComposeOperationParams = {
+  t: Translator
+  messageType: string
+  createableMessageTypes: MessageTypeItem[]
+  priority: MessagePriority
+  visibility: 'public' | 'internal'
+  externalEmail: string
+  recipientIds: string[]
+  subject: string
+  body: string
+  bodyFormat: 'text' | 'markdown'
+  sendViaEmail: boolean
+  contextObject: MessageComposerContextObject | null
+  defaultValues: MessageComposerProps['defaultValues']
+  contextActionOptions: Array<{ id: string; label: string }>
+  normalizedRequiredActionMode: 'none' | 'optional' | 'required'
+  shouldShowContextActions: boolean
+  contextActionRequired: boolean
+  contextActionType: string
+}
+
+type ReplyOperationParams = {
+  t: Translator
+  messageId?: string
+  body: string
+  bodyFormat: 'text' | 'markdown'
+  replyAll: boolean
+  recipientIds: string[]
+  sendViaEmail: boolean
+}
+
+type ForwardOperationParams = {
+  t: Translator
+  messageId?: string
+  recipientIds: string[]
+  body: string
+  includeAttachments: boolean
+  sendViaEmail: boolean
+}
+
+type DraftOperationParams = Omit<ComposeOperationParams, 'createableMessageTypes'>
+
+function isValidEmailAddress(value: string): boolean {
+  const email = value.trim()
+  if (!email || email.length > 254) return false
+
+  const atIndex = email.indexOf('@')
+  if (atIndex <= 0 || atIndex !== email.lastIndexOf('@') || atIndex === email.length - 1) return false
+
+  for (const char of email) {
+    if (char === ' ' || char === '\t' || char === '\n' || char === '\r') return false
+  }
+
+  const localPart = email.slice(0, atIndex)
+  const domainPart = email.slice(atIndex + 1)
+  if (!localPart || !domainPart || localPart.length > 64) return false
+  if (domainPart.length > 253 || !domainPart.includes('.')) return false
+  if (domainPart.startsWith('.') || domainPart.endsWith('.') || domainPart.includes('..')) return false
+
+  const domainLabels = domainPart.split('.')
+  for (const label of domainLabels) {
+    if (!label) return false
+    if (label.startsWith('-') || label.endsWith('-')) return false
+  }
+
+  return true
+}
+
+function mapRecipients(recipientIds: string[]): MessageRecipient[] {
+  return recipientIds.map((userId) => ({ userId, type: 'to' }))
+}
+
+function buildComposePayload(
+  params: ComposeOperationParams | DraftOperationParams,
+  input: { attachmentIds: string[]; isDraft: boolean },
+): Record<string, unknown> {
+  const publicMessage = params.visibility === 'public'
+  const sourceEntityType = params.contextObject?.sourceEntityType ?? params.defaultValues?.sourceEntityType
+  const sourceEntityId = params.contextObject?.sourceEntityId ?? params.defaultValues?.sourceEntityId
+  const selectedContextActionOption = params.contextActionOptions.find((option) => option.id === params.contextActionType)
+  const resolvedContextActionRequired = params.shouldShowContextActions
+    ? (params.normalizedRequiredActionMode === 'required' ? true : params.contextActionRequired)
+    : (params.contextObject?.actionRequired ?? false)
+  const resolvedContextActionType = resolvedContextActionRequired
+    ? (params.shouldShowContextActions ? params.contextActionType : params.contextObject?.actionType)
+    : undefined
+  const resolvedContextActionLabel = resolvedContextActionRequired
+    ? (params.shouldShowContextActions ? selectedContextActionOption?.label : params.contextObject?.actionLabel)
+    : undefined
+  const contextObjects = params.contextObject
+    ? [{
+      entityModule: params.contextObject.entityModule,
+      entityType: params.contextObject.entityType,
+      entityId: params.contextObject.entityId,
+      actionRequired: resolvedContextActionRequired,
+      actionType: resolvedContextActionType,
+      actionLabel: resolvedContextActionLabel,
+    }]
+    : undefined
+
+  return {
+    type: params.messageType,
+    priority: params.priority,
+    visibility: params.visibility,
+    externalEmail: publicMessage ? params.externalEmail.trim() : undefined,
+    externalName: undefined,
+    recipients: publicMessage ? [] : mapRecipients(params.recipientIds),
+    subject: params.subject.trim(),
+    body: params.body,
+    bodyFormat: params.bodyFormat,
+    sourceEntityType: sourceEntityType ?? undefined,
+    sourceEntityId: sourceEntityId ?? undefined,
+    objects: contextObjects,
+    attachmentIds: input.attachmentIds.length > 0 ? input.attachmentIds : undefined,
+    sendViaEmail: publicMessage ? true : params.sendViaEmail,
+    isDraft: input.isDraft,
+  }
+}
+
+export function useComposeSendOperation(params: ComposeOperationParams): BaseOperation {
+  return React.useMemo(() => ({
+    validate: () => {
+      if (params.visibility !== 'public' && params.recipientIds.length === 0) {
+        return params.t('messages.errors.noRecipients', 'Please add at least one recipient.')
+      }
+      if (params.visibility === 'public' && !isValidEmailAddress(params.externalEmail.trim())) {
+        return params.t('messages.errors.noExternalEmail', 'Please enter a valid external email.')
+      }
+      if (!params.subject.trim()) {
+        return params.t('messages.errors.noSubject', 'Please enter a subject.')
+      }
+      if (!params.body.trim()) {
+        return params.t('messages.errors.noBody', 'Please enter a message.')
+      }
+      if (!params.createableMessageTypes.some((item) => item.type === params.messageType)) {
+        return params.t('messages.errors.sendFailed', 'Failed to send message.')
+      }
+      if (
+        params.shouldShowContextActions
+        && params.normalizedRequiredActionMode === 'required'
+        && !params.contextActionType
+      ) {
+        return params.t('messages.composer.objectPicker.errors.actionRequired', 'Select an action.')
+      }
+      if (
+        params.shouldShowContextActions
+        && params.normalizedRequiredActionMode === 'optional'
+        && params.contextActionRequired
+        && !params.contextActionType
+      ) {
+        return params.t('messages.composer.objectPicker.errors.actionRequired', 'Select an action.')
+      }
+      return null
+    },
+    buildRequest: ({ attachmentIds }) => ({
+      endpoint: '/api/messages',
+      payload: buildComposePayload(params, { attachmentIds, isDraft: false }),
+    }),
+    successMessage: params.t('messages.flash.sentSuccess', 'Message sent.'),
+    requiresAttachmentRefresh: true,
+  }), [params])
+}
+
+export function useComposeDraftOperation(params: DraftOperationParams): BaseOperation {
+  return React.useMemo(() => ({
+    validate: () => null,
+    buildRequest: ({ attachmentIds }) => ({
+      endpoint: '/api/messages',
+      payload: buildComposePayload(params, { attachmentIds, isDraft: true }),
+    }),
+    successMessage: params.t('messages.flash.draftSaved', 'Draft saved.'),
+    requiresAttachmentRefresh: true,
+  }), [params])
+}
+
+export function useReplySubmitOperation(params: ReplyOperationParams): BaseOperation {
+  return React.useMemo(() => ({
+    validate: () => {
+      if (!params.body.trim()) {
+        return params.t('messages.errors.noBody', 'Please enter a message.')
+      }
+      if (!params.messageId) {
+        return params.t('messages.errors.invalidContext', 'Message context is missing.')
+      }
+      return null
+    },
+    buildRequest: ({ attachmentIds }) => ({
+      endpoint: `/api/messages/${encodeURIComponent(params.messageId ?? '')}/reply`,
+      payload: {
+        body: params.body,
+        bodyFormat: params.bodyFormat,
+        replyAll: params.replyAll,
+        recipients: params.recipientIds.length > 0 ? mapRecipients(params.recipientIds) : undefined,
+        attachmentIds: attachmentIds.length > 0 ? attachmentIds : undefined,
+        sendViaEmail: params.sendViaEmail,
+      },
+    }),
+    successMessage: params.t('messages.flash.replySuccess', 'Reply sent.'),
+    requiresAttachmentRefresh: true,
+  }), [params])
+}
+
+export function useForwardSubmitOperation(params: ForwardOperationParams): BaseOperation {
+  return React.useMemo(() => ({
+    validate: () => {
+      if (params.recipientIds.length === 0) {
+        return params.t('messages.errors.noRecipients', 'Please add at least one recipient.')
+      }
+      if (!params.messageId) {
+        return params.t('messages.errors.invalidContext', 'Message context is missing.')
+      }
+      if (!params.body.trim()) {
+        return params.t('messages.errors.noBody', 'Please enter a message.')
+      }
+      return null
+    },
+    buildRequest: () => ({
+      endpoint: `/api/messages/${encodeURIComponent(params.messageId ?? '')}/forward`,
+      payload: {
+        recipients: mapRecipients(params.recipientIds),
+        body: params.body,
+        includeAttachments: params.includeAttachments,
+        sendViaEmail: params.sendViaEmail,
+      },
+    }),
+    successMessage: params.t('messages.flash.forwardSuccess', 'Message forwarded.'),
+    requiresAttachmentRefresh: false,
+  }), [params])
+}
+
+export type MessageComposeSubmitOperation = BaseOperation

package/src/backend/messages/useMessagesPoll.ts

@@ -0,0 +1,118 @@
+"use client"
+
+import * as React from 'react'
+import { apiCall } from '../utils/apiCall'
+
+export type MessagePollItem = {
+  id: string
+  type: string
+  subject: string
+  bodyPreview: string
+  senderUserId: string
+  senderName?: string | null
+  senderEmail?: string | null
+  priority: string
+  status: string
+  hasObjects: boolean
+  objectCount: number
+  hasAttachments: boolean
+  attachmentCount: number
+  hasActions: boolean
+  actionTaken?: string | null
+  sentAt?: string | null
+  readAt?: string | null
+  threadId?: string | null
+}
+
+export type UseMessagesPollResult = {
+  messages: MessagePollItem[]
+  unreadCount: number
+  hasNew: boolean
+  isLoading: boolean
+  error: string | null
+  refresh: () => Promise<void>
+}
+
+const POLL_INTERVAL = 5000
+
+export function useMessagesPoll(): UseMessagesPollResult {
+  const requestInit = React.useMemo(
+    () => ({
+      headers: {
+        'x-om-forbidden-redirect': '0',
+      },
+    }),
+    [],
+  )
+  const [messages, setMessages] = React.useState<MessagePollItem[]>([])
+  const [unreadCount, setUnreadCount] = React.useState(0)
+  const [hasNew, setHasNew] = React.useState(false)
+  const [isLoading, setIsLoading] = React.useState(true)
+  const [error, setError] = React.useState<string | null>(null)
+
+  const lastMessageIdRef = React.useRef<string | null>(null)
+  const pulseTimeoutRef = React.useRef<number | null>(null)
+
+  const fetchMessages = React.useCallback(async () => {
+    try {
+      const [listResult, countResult] = await Promise.all([
+        apiCall<{ items?: MessagePollItem[] }>('/api/messages?folder=inbox&page=1&pageSize=20', requestInit),
+        apiCall<{ unreadCount?: number }>('/api/messages/unread-count', requestInit),
+      ])
+
+      if (listResult.ok) {
+        const nextMessages = Array.isArray(listResult.result?.items) ? listResult.result?.items ?? [] : []
+        const firstId = nextMessages[0]?.id ?? null
+
+        if (lastMessageIdRef.current && firstId && firstId !== lastMessageIdRef.current) {
+          setHasNew(true)
+          if (pulseTimeoutRef.current) {
+            window.clearTimeout(pulseTimeoutRef.current)
+          }
+          pulseTimeoutRef.current = window.setTimeout(() => {
+            setHasNew(false)
+            pulseTimeoutRef.current = null
+          }, 3000)
+        }
+
+        lastMessageIdRef.current = firstId
+        setMessages(nextMessages)
+      }
+
+      if (countResult.ok) {
+        const nextCount = Number(countResult.result?.unreadCount ?? 0)
+        setUnreadCount(Number.isFinite(nextCount) ? Math.max(0, nextCount) : 0)
+      }
+
+      setError(null)
+    } catch (err) {
+      const message = err instanceof Error ? err.message : 'Failed to poll messages'
+      setError(message)
+    } finally {
+      setIsLoading(false)
+    }
+  }, [requestInit])
+
+  React.useEffect(() => {
+    void fetchMessages()
+    const interval = window.setInterval(() => {
+      void fetchMessages()
+    }, POLL_INTERVAL)
+
+    return () => {
+      window.clearInterval(interval)
+      if (pulseTimeoutRef.current) {
+        window.clearTimeout(pulseTimeoutRef.current)
+      }
+    }
+  }, [fetchMessages])
+
+  return {
+    messages,
+    unreadCount,
+    hasNew,
+    isLoading,
+    error,
+    refresh: fetchMessages,
+  }
+}

package/src/backend/notifications/NotificationBell.tsx

@@ -0,0 +1,91 @@
+"use client"
+import * as React from 'react'
+import { Bell } from 'lucide-react'
+import { usePathname, useSearchParams } from 'next/navigation'
+import { IconButton } from '../../primitives-v2/IconButton'
+import { cn } from '@open-mercato/shared/lib/utils'
+import { useNotifications } from './useNotifications'
+import { NotificationPanel } from './NotificationPanel'
+import { NotificationCountBadge } from './NotificationCountBadge'
+import type { TranslateFn } from '@open-mercato/shared/lib/i18n/context'
+import type { NotificationRenderers } from './NotificationPanel'
+
+export type NotificationBellProps = {
+  className?: string
+  t: TranslateFn
+  customRenderers?: NotificationRenderers
+}
+
+export function NotificationBell({ className, t, customRenderers }: NotificationBellProps) {
+  const [panelOpen, setPanelOpen] = React.useState(false)
+  const pathname = usePathname()
+  const searchParams = useSearchParams()
+  const {
+    unreadCount,
+    hasNew,
+    notifications,
+    markAsRead,
+    executeAction,
+    dismiss,
+    dismissUndo,
+    undoDismiss,
+    markAllRead,
+  } = useNotifications()
+  const prevCountRef = React.useRef(unreadCount)
+  const routeKey = React.useMemo(() => {
+    const query = searchParams.toString()
+    return query ? `${pathname}?${query}` : pathname
+  }, [pathname, searchParams])
+  const previousRouteKeyRef = React.useRef(routeKey)
+  const [pulse, setPulse] = React.useState(false)
+
+  React.useEffect(() => {
+    if (hasNew && unreadCount > prevCountRef.current) {
+      setPulse(true)
+      const timer = setTimeout(() => setPulse(false), 1000)
+      return () => clearTimeout(timer)
+    }
+    prevCountRef.current = unreadCount
+  }, [unreadCount, hasNew])
+
+  React.useEffect(() => {
+    if (panelOpen && routeKey !== previousRouteKeyRef.current) {
+      setPanelOpen(false)
+    }
+    previousRouteKeyRef.current = routeKey
+  }, [panelOpen, routeKey])
+
+  const ariaLabel = unreadCount > 0
+    ? t('notifications.badge.unread', '{count} unread notifications', { count: unreadCount })
+    : t('notifications.title', 'Notifications')
+
+  return (
+    <>
+      <IconButton asChild variant="ghost" size="sm" aria-label={ariaLabel}>
+        <button
+          type="button"
+          className={cn('relative', className)}
+          onClick={() => setPanelOpen(true)}
+        >
+          <Bell className={cn('h-4 w-4 text-topbar-v2-icon', pulse && 'animate-pulse')} />
+          <NotificationCountBadge count={unreadCount} />
+        </button>
+      </IconButton>
+
+      <NotificationPanel
+        open={panelOpen}
+        onOpenChange={setPanelOpen}
+        notifications={notifications}
+        unreadCount={unreadCount}
+        onMarkAsRead={markAsRead}
+        onExecuteAction={executeAction}
+        onDismiss={dismiss}
+        dismissUndo={dismissUndo}
+        onUndoDismiss={undoDismiss}
+        onMarkAllRead={markAllRead}
+        t={t}
+        customRenderers={customRenderers}
+      />
+    </>
+  )
+}

package/src/backend/notifications/NotificationCountBadge.tsx

@@ -0,0 +1,14 @@
+import * as React from 'react'
+
+export type NotificationCountBadgeProps = {
+  count: number
+}
+
+export function NotificationCountBadge({ count }: NotificationCountBadgeProps) {
+  if (count <= 0) return null
+  return (
+    <span className="absolute -top-1 -right-1 flex h-5 w-5 items-center justify-center rounded-full bg-destructive text-[10px] font-medium text-destructive-foreground">
+      {count > 99 ? '99+' : count}
+    </span>
+  )
+}

package/src/backend/notifications/NotificationDispatcher.ts

@@ -0,0 +1,213 @@
+import { flash, type FlashKind } from '@freighttech/ui/backend/FlashMessages'
+import {
+  getNotificationHandlerEntries,
+} from '@open-mercato/shared/lib/notifications/handler-registry'
+import { hasAllFeatures } from '@open-mercato/shared/security/features'
+import type {
+  NotificationHandler,
+  NotificationHandlerContext,
+  NotificationHandlerPopupOptions,
+  NotificationHandlerToastOptions,
+} from '@open-mercato/shared/modules/notifications/handler'
+import type { NotificationDto } from '@open-mercato/shared/modules/notifications/types'
+
+type RuntimeContext = {
+  userId?: string
+  features: string[]
+  currentPath: string
+  refreshNotifications: () => void
+  navigate: (href: string) => void
+  markAsRead: (notificationId: string) => Promise<void>
+  dismiss: (notificationId: string) => Promise<void>
+}
+
+type NotificationEffectListener = {
+  id: number
+  pattern: string | string[]
+  effect: (notification: NotificationDto) => void
+}
+
+const DEFAULT_PRIORITY = 50
+const MAX_TRACKED_IDS = 500
+const RETAINED_IDS_AFTER_PRUNE = 200
+const POPUP_EVENT_NAME = 'om:notifications:popup'
+
+function toFlashKind(value: NotificationHandlerToastOptions['severity'] | NotificationHandlerPopupOptions['severity']): FlashKind {
+  if (value === 'success') return 'success'
+  if (value === 'warning') return 'warning'
+  if (value === 'error') return 'error'
+  return 'info'
+}
+
+function matchesType(pattern: string | string[], type: string): boolean {
+  const patterns = Array.isArray(pattern) ? pattern : [pattern]
+  return patterns.some((current) => {
+    if (current === '*') return true
+    if (current.endsWith('.*')) return type.startsWith(current.slice(0, -1))
+    return current === type
+  })
+}
+
+function matchesFeatures(required: string[] | undefined, current: string[]): boolean {
+  return hasAllFeatures(current, required)
+}
+
+function buildHandlerContext(runtime: RuntimeContext): NotificationHandlerContext {
+  return {
+    userId: runtime.userId,
+    features: runtime.features,
+    currentPath: runtime.currentPath,
+    toast(options) {
+      const text = options.body ? `${options.title}: ${options.body}` : options.title
+      flash(text, toFlashKind(options.severity))
+    },
+    popup(options) {
+      if (typeof window !== 'undefined' && typeof CustomEvent !== 'undefined') {
+        window.dispatchEvent(new CustomEvent(POPUP_EVENT_NAME, { detail: options }))
+      }
+      const text = options.body ? `${options.title}: ${options.body}` : options.title
+      flash(text, toFlashKind(options.severity))
+    },
+    emitEvent(eventName, detail) {
+      if (typeof window === 'undefined' || typeof CustomEvent === 'undefined') return
+      window.dispatchEvent(new CustomEvent(eventName, { detail }))
+    },
+    refreshNotifications: runtime.refreshNotifications,
+    navigate(href) {
+      runtime.navigate(href)
+    },
+    markAsRead: runtime.markAsRead,
+    dismiss: runtime.dismiss,
+  }
+}
+
+class NotificationDispatcher {
+  private handledIds = new Set<string>()
+  private handledOrder: string[] = []
+  private listeners = new Map<number, NotificationEffectListener>()
+  private listenerIdSeq = 1
+  private debounceByHandler = new Map<string, number>()
+
+  dispatch(notifications: NotificationDto[], runtime: RuntimeContext) {
+    const entries = getNotificationHandlerEntries()
+    if (notifications.length === 0 && this.listeners.size === 0) return
+    const context = buildHandlerContext(runtime)
+    const sortedEntries = entries
+      .slice()
+      .sort((a, b) => (b.handler.priority ?? DEFAULT_PRIORITY) - (a.handler.priority ?? DEFAULT_PRIORITY))
+
+    for (const notification of notifications) {
+      if (this.handledIds.has(notification.id)) continue
+
+      let handlerRan = false
+      let hadFeatureBlockedHandler = false
+
+      for (const entry of sortedEntries) {
+        const handler = entry.handler
+        if (!matchesType(handler.notificationType, notification.type)) continue
+        if (!matchesFeatures(handler.features, runtime.features)) {
+          hadFeatureBlockedHandler = true
+          continue
+        }
+        if (this.shouldDebounce(handler, notification.id)) continue
+        handlerRan = true
+        try {
+          void Promise.resolve(handler.handle(notification, context))
+        } catch (error) {
+          console.error(`[notifications] handler failed: ${handler.id}`, error)
+        }
+      }
+
+      for (const listener of this.listeners.values()) {
+        if (!matchesType(listener.pattern, notification.type)) continue
+        handlerRan = true
+        try {
+          listener.effect(notification)
+        } catch (error) {
+          console.error('[notifications] effect listener failed', error)
+        }
+      }
+
+      // Only mark as permanently handled when something actually ran, or when no handler
+      // was blocked by missing features. This prevents a race where the initial notification
+      // fetch completes before the feature-check API resolves (features: []), causing all
+      // feature-gated handlers to be skipped — but the notification gets permanently
+      // deduped so it never fires when features are available on the next dispatch.
+      if (handlerRan || !hadFeatureBlockedHandler) {
+        this.markHandled(notification.id)
+      }
+    }
+  }
+
+  subscribe(pattern: string | string[], effect: (notification: NotificationDto) => void): () => void {
+    const id = this.listenerIdSeq++
+    this.listeners.set(id, { id, pattern, effect })
+    return () => {
+      this.listeners.delete(id)
+    }
+  }
+
+  resetForTests() {
+    this.handledIds.clear()
+    this.handledOrder = []
+    this.listeners.clear()
+    this.listenerIdSeq = 1
+    this.debounceByHandler.clear()
+  }
+
+  private shouldDebounce(handler: NotificationHandler, notificationId: string): boolean {
+    if (!handler.debounceMs || handler.debounceMs <= 0) return false
+    const key = `${handler.id}:${notificationId}`
+    const now = Date.now()
+    const previous = this.debounceByHandler.get(key)
+    if (typeof previous === 'number' && now - previous < handler.debounceMs) {
+      return true
+    }
+    this.debounceByHandler.set(key, now)
+    return false
+  }
+
+  private markHandled(notificationId: string) {
+    this.handledIds.add(notificationId)
+    this.handledOrder.push(notificationId)
+    if (this.handledOrder.length <= MAX_TRACKED_IDS) return
+    const removeCount = this.handledOrder.length - RETAINED_IDS_AFTER_PRUNE
+    const removed = this.handledOrder.splice(0, removeCount)
+    for (const id of removed) {
+      this.handledIds.delete(id)
+    }
+  }
+}
+
+const dispatcher = new NotificationDispatcher()
+
+export function dispatchNotificationHandlers(
+  notifications: NotificationDto[],
+  runtime: RuntimeContext,
+) {
+  dispatcher.dispatch(notifications, runtime)
+}
+
+export function subscribeNotificationEffects(
+  pattern: string | string[],
+  effect: (notification: NotificationDto) => void,
+): () => void {
+  return dispatcher.subscribe(pattern, effect)
+}
+
+export function getRequiredNotificationHandlerFeatures(): string[] {
+  const required = new Set<string>()
+  const entries = getNotificationHandlerEntries()
+  for (const entry of entries) {
+    for (const feature of entry.handler.features ?? []) {
+      if (feature && feature.trim().length > 0) {
+        required.add(feature)
+      }
+    }
+  }
+  return Array.from(required)
+}
+
+export function __resetNotificationDispatcherForTests() {
+  dispatcher.resetForTests()
+}