stream-chat-react-native-core/lib/module/components/Accessibility/hooks/useIncomingMessageAnnouncements.js

The official React Native and Expo components for Stream Chat, a service for building chat applications

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.useIncomingMessageAnnouncements = void 0;
var _react = require("react");
var _AccessibilityContext = require("../../../contexts/accessibilityContext/AccessibilityContext");
var _TranslationContext = require("../../../contexts/translationContext/TranslationContext");
var _useAccessibilityAnnouncer = require("../useAccessibilityAnnouncer");
var MESSAGE_ANNOUNCEMENT_THROTTLE_MS = 1000;
var isAnnounceableIncomingMessage = (message, ownUserId) => {
  var messageUserId = message.user?.id;
  if (!message.id || !messageUserId || messageUserId === ownUserId) return false;
  return message.type !== 'deleted' && message.type !== 'ephemeral' && message.type !== 'error' && message.type !== 'system' && message.status !== 'failed' && message.status !== 'sending';
};
var getSenderName = (message, t) => message.user?.name?.trim() || message.user?.id || t('Anonymous');
var useIncomingMessageAnnouncements = ({
  activeThreadId,
  channel,
  ownUserId,
  threadList = false
}) => {
  var _useAccessibilityCont = (0, _AccessibilityContext.useAccessibilityContext)(),
    announceNewMessages = _useAccessibilityCont.announceNewMessages,
    enabled = _useAccessibilityCont.enabled;
  var announce = (0, _useAccessibilityAnnouncer.useAccessibilityAnnouncer)();
  var _useTranslationContex = (0, _TranslationContext.useTranslationContext)(),
    t = _useTranslationContex.t;
  var lastAnnouncementTimestampRef = (0, _react.useRef)(0);
  var flushTimeoutRef = (0, _react.useRef)(undefined);
  var announcedMessageIdsRef = (0, _react.useRef)(new Set());
  var pendingAnnouncementBatchRef = (0, _react.useRef)({
    count: 0,
    firstSender: null
  });
  var flushPendingAnnouncements = (0, _react.useCallback)(() => {
    var pending = pendingAnnouncementBatchRef.current;
    if (pending.count <= 0) return;
    if (pending.count === 1) {
      announce(t('a11y/New message from {{user}}', {
        user: pending.firstSender || t('Anonymous')
      }));
    } else {
      announce(t('a11y/{{count}} new messages', {
        count: pending.count
      }));
    }
    pending.count = 0;
    pending.firstSender = null;
    lastAnnouncementTimestampRef.current = Date.now();
  }, [announce, t]);
  var scheduleFlush = (0, _react.useCallback)(() => {
    if (flushTimeoutRef.current) return;
    var now = Date.now();
    var elapsed = now - lastAnnouncementTimestampRef.current;
    if (elapsed >= MESSAGE_ANNOUNCEMENT_THROTTLE_MS) {
      flushPendingAnnouncements();
      return;
    }
    flushTimeoutRef.current = setTimeout(() => {
      flushTimeoutRef.current = undefined;
      flushPendingAnnouncements();
    }, MESSAGE_ANNOUNCEMENT_THROTTLE_MS - elapsed);
  }, [flushPendingAnnouncements]);
  (0, _react.useEffect)(() => () => {
    if (flushTimeoutRef.current) clearTimeout(flushTimeoutRef.current);
  }, []);
  (0, _react.useEffect)(() => {
    if (!enabled || !announceNewMessages || !channel) return;
    var handleMessageNew = event => {
      var message = event.message;
      if (!message) return;
      if (event.cid && event.cid !== channel.cid || !isAnnounceableIncomingMessage(message, ownUserId)) {
        return;
      }
      var isReply = !!message.parent_id;
      var belongsToActiveThread = !!activeThreadId && message.parent_id === activeThreadId;
      var shouldAnnounceInThreadList = threadList && belongsToActiveThread;
      var shouldAnnounceInMainList = !threadList && !isReply;
      if (!shouldAnnounceInThreadList && !shouldAnnounceInMainList) return;
      if (announcedMessageIdsRef.current.has(message.id || '')) return;
      if (message.id) {
        if (announcedMessageIdsRef.current.size > 500) {
          announcedMessageIdsRef.current.clear();
        }
        announcedMessageIdsRef.current.add(message.id);
      }
      pendingAnnouncementBatchRef.current.count += 1;
      if (!pendingAnnouncementBatchRef.current.firstSender) {
        pendingAnnouncementBatchRef.current.firstSender = getSenderName(message, t);
      }
      scheduleFlush();
    };
    var subscription = channel.on('message.new', handleMessageNew);
    return () => {
      subscription.unsubscribe();
      if (flushTimeoutRef.current) {
        clearTimeout(flushTimeoutRef.current);
        flushTimeoutRef.current = undefined;
      }
    };
  }, [activeThreadId, announceNewMessages, channel, enabled, ownUserId, scheduleFlush, t, threadList]);
};
exports.useIncomingMessageAnnouncements = useIncomingMessageAnnouncements;
//# sourceMappingURL=useIncomingMessageAnnouncements.js.map