mute [nfc]: Rename getter to isTopicVisibleInStream, and flip sense

With the upcoming feature of unmuted topics in muted streams,
the question "is this topic muted?" will split into several
different questions that can have different answers.
To prepare for that, stop having a function asking that
less-specific question.

For several call sites, we can cleanly write a name and jsdoc
for a function that covers all of them.

In the topic action sheet, the question we'll end up wanting to ask
is different from those, and reflects a UI choice we're making
specifically about the action sheet.  So just put an explicit
switch statement there.

Author: gnprice

src/action-sheets/index.js

@@ -32,7 +32,7 @@ import {
 } from '../utils/narrow';
 import { pmUiRecipientsFromKeyRecipients } from '../utils/recipient';
 import type { PmKeyRecipients } from '../utils/recipient';
-import { isTopicMuted } from '../mute/muteModel';
+import { getTopicVisibilityPolicy } from '../mute/muteModel';
 import * as api from '../api';
 import { showConfirmationDialog, showErrorAlert, showToast } from '../utils/info';
 import { doNarrow, deleteOutboxMessage, fetchSomeMessageIdForConversation } from '../actions';
@@ -648,10 +648,13 @@ export const constructTopicActionButtons = (args: {|
   }
   if (sub && !streamMuted) {
     // Stream subscribed and not muted.
-    if (isTopicMuted(streamId, topic, mute)) {
-      buttons.push(unmuteTopic);
-    } else {
-      buttons.push(muteTopic);
+    switch (getTopicVisibilityPolicy(mute, streamId, topic)) {
+      case UserTopicVisibilityPolicy.Muted:
+        buttons.push(unmuteTopic);
+        break;
+      case UserTopicVisibilityPolicy.None:
+        buttons.push(muteTopic);
+        break;
     }
   } else if (sub && streamMuted) {
     // TODO(#5691): offer new "unmute topic" concept, when server supports it

src/chat/narrowsSelectors.js

@@ -23,7 +23,7 @@ import {
   caseNarrow,
   streamIdOfNarrow,
 } from '../utils/narrow';
-import { getMute, isTopicMuted } from '../mute/muteModel';
+import { getMute, isTopicVisibleInStream } from '../mute/muteModel';
 import { NULL_ARRAY, NULL_SUBSCRIPTION } from '../nullObjects';
 import * as logging from '../utils/logging';
 import { getStreamsById, getSubscriptionsById } from '../subscriptions/subscriptionSelectors';
@@ -121,7 +121,7 @@ export const getShownMessagesForNarrow: Selector<$ReadOnlyArray<Message | Outbox
             }
             return (
               sub.in_home_view
-              && !isTopicMuted(message.stream_id, message.subject, mute)
+              && isTopicVisibleInStream(message.stream_id, message.subject, mute)
             );
           }),
 
@@ -133,7 +133,7 @@ export const getShownMessagesForNarrow: Selector<$ReadOnlyArray<Message | Outbox
             if (flags.mentioned[message.id]) {
               return true;
             }
-            return !isTopicMuted(message.stream_id, message.subject, mute);
+            return isTopicVisibleInStream(message.stream_id, message.subject, mute);
           }),
 
         // In the starred-message view, ignore stream/topic mutes.

src/mute/__tests__/muteModel-test.js

@@ -2,7 +2,7 @@
 import deepFreeze from 'deep-freeze';
 
 import fullReducer from '../../boot/reducers';
-import { getMute, getTopicVisibilityPolicy, isTopicMuted, reducer } from '../muteModel';
+import { getMute, getTopicVisibilityPolicy, isTopicVisibleInStream, reducer } from '../muteModel';
 import { EVENT, EVENT_MUTED_TOPICS } from '../../actionConstants';
 import * as eg from '../../__tests__/lib/exampleData';
 import { makeMuteState, makeUserTopic } from './mute-testlib';
@@ -33,21 +33,21 @@ describe('getters', () => {
     });
   });
 
-  describe('isTopicMuted', () => {
+  describe('isTopicVisibleInStream', () => {
     function check(state, expected) {
-      expect(isTopicMuted(eg.stream.stream_id, 'topic', state)).toEqual(expected);
+      expect(isTopicVisibleInStream(eg.stream.stream_id, 'topic', state)).toEqual(expected);
     }
 
     test('with nothing for stream', () => {
-      check(makeMuteState([]), false);
+      check(makeMuteState([]), true);
     });
 
     test('with nothing for topic', () => {
-      check(makeMuteState([[eg.stream, 'other topic']]), false);
+      check(makeMuteState([[eg.stream, 'other topic']]), true);
     });
 
     test('with topic muted', () => {
-      check(makeMuteState([[eg.stream, 'topic']]), true);
+      check(makeMuteState([[eg.stream, 'topic']]), false);
     });
   });
 });

src/mute/muteModel.js

@@ -36,13 +36,19 @@ export function getTopicVisibilityPolicy(
   return mute.get(streamId)?.get(topic) ?? UserTopicVisibilityPolicy.None;
 }
 
-export function isTopicMuted(streamId: number, topic: string, mute: MuteState): boolean {
+/**
+ * Whether this topic should appear when already focusing on its stream.
+ *
+ * This is false if the user's visibility policy for the topic is Muted,
+ * and true if the policy is None.
+ */
+export function isTopicVisibleInStream(streamId: number, topic: string, mute: MuteState): boolean {
   const policy = getTopicVisibilityPolicy(mute, streamId, topic);
   switch (policy) {
     case UserTopicVisibilityPolicy.None:
-      return false;
-    case UserTopicVisibilityPolicy.Muted:
       return true;
+    case UserTopicVisibilityPolicy.Muted:
+      return false;
   }
 }
 

src/topics/topicSelectors.js

@@ -6,7 +6,7 @@ import { getTopics } from '../directSelectors';
 import { getUnread, getUnreadCountForTopic } from '../unread/unreadModel';
 import { NULL_ARRAY } from '../nullObjects';
 import { isStreamNarrow, streamIdOfNarrow } from '../utils/narrow';
-import { getMute, isTopicMuted } from '../mute/muteModel';
+import { getMute, isTopicVisibleInStream } from '../mute/muteModel';
 import { getSubscriptionsById } from '../subscriptions/subscriptionSelectors';
 
 export const getTopicsForNarrow: Selector<$ReadOnlyArray<string>, Narrow> = createSelector(
@@ -42,7 +42,7 @@ export const getTopicsForStream: Selector<?$ReadOnlyArray<TopicExtended>, number
     const streamMuted = subscription ? !subscription.in_home_view : true;
 
     return topicList.map(({ name, max_id }): TopicExtended => {
-      const isMuted = streamMuted || isTopicMuted(streamId, name, mute);
+      const isMuted = streamMuted || !isTopicVisibleInStream(streamId, name, mute);
       const unreadCount = getUnreadCountForTopic(unread, streamId, name);
       return { name, max_id, isMuted, unreadCount };
     });

src/unread/unreadSelectors.js

@@ -4,7 +4,7 @@ import { createSelector } from 'reselect';
 import type { Narrow, Selector } from '../types';
 import type { UnreadStreamItem } from './UnreadCards';
 import { caseInsensitiveCompareFunc } from '../utils/misc';
-import { getMute, isTopicMuted } from '../mute/muteModel';
+import { getMute, isTopicVisibleInStream } from '../mute/muteModel';
 import { getOwnUserId } from '../users/userSelectors';
 import { getSubscriptionsById, getStreamsById } from '../subscriptions/subscriptionSelectors';
 import { caseNarrow } from '../utils/narrow';
@@ -27,7 +27,7 @@ export const getUnreadByStream: Selector<{| [number]: number |}> = createSelecto
     for (const [streamId, streamData] of unreadStreams.entries()) {
       let total = 0;
       for (const [topic, msgIds] of streamData) {
-        if (!isTopicMuted(streamId, topic, mute)) {
+        if (isTopicVisibleInStream(streamId, topic, mute)) {
           total += msgIds.size;
         }
       }
@@ -167,7 +167,7 @@ export const getUnreadStreamsAndTopics: Selector<$ReadOnlyArray<UnreadStreamItem
       let totalUnread = 0;
       const topics = [];
       for (const [topic, msgIds] of streamData) {
-        if (isTopicMuted(streamId, topic, mute)) {
+        if (!isTopicVisibleInStream(streamId, topic, mute)) {
           continue;
         }
         totalUnread += msgIds.size;
@@ -228,7 +228,7 @@ export const getUnreadCountForNarrow: Selector<number, Narrow> = createSelector(
         unread.streams
           .get(streamId)
           ?.entrySeq()
-          .filterNot(([topic, _]) => isTopicMuted(streamId, topic, mute))
+          .filter(([topic, _]) => isTopicVisibleInStream(streamId, topic, mute))
           .map(([_, msgIds]) => msgIds.size)
           .reduce((s, x) => s + x, 0) ?? 0,