9647808362

Committed 24 Jun 2024 03:08PM UTC coverage: 14.885% (-0.01%) from 14.895%

Build # 9647808362

Build Type

Pull #8230

github

Committed by

web-flow

Commit Message

Merge 2b92ac0e0 into 3dc674aab

Pull Request Pull Request #8230: Contest tags

Run Details

3634 of 23045 branches covered (15.77%)

Branch coverage included in aggregate %.

0 of 29 new or added lines in 4 files covered. (0.0%)

2 existing lines in 2 files now uncovered.

4952 of 34637 relevant lines covered (14.3%)

4.74 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/packages/commonwealth/client/scripts/views/pages/discussions/ThreadCard/ThreadCard.tsx

import { useCommonNavigate } from 'client/scripts/navigation/helpers';
import { ViewThreadUpvotesDrawer } from 'client/scripts/views/components/UpvoteDrawer';
import { CWDivider } from 'client/scripts/views/components/component_kit/cw_divider';
import { QuillRenderer } from 'client/scripts/views/components/react_quill_editor/quill_renderer';
import clsx from 'clsx';
import { isDefaultStage, threadStageToLabel } from 'helpers';
import {
  GetThreadActionTooltipTextResponse,
  filterLinks,
} from 'helpers/threads';
import { useFlag } from 'hooks/useFlag';
import useUserLoggedIn from 'hooks/useUserLoggedIn';
import { LinkSource } from 'models/Thread';
import React, { useEffect, useState } from 'react';
import { Link } from 'react-router-dom';
import ThreadContestTag from 'views/components/ThreadContestTag';
import { getWinnersFromAssociatedContests } from 'views/components/ThreadContestTag/utils';
import { CWIcon } from 'views/components/component_kit/cw_icons/cw_icon';
import { CWText } from 'views/components/component_kit/cw_text';
import { getClasses } from 'views/components/component_kit/helpers';
import { CWTag } from 'views/components/component_kit/new_designs/CWTag';
import useBrowserWindow from '../../../../hooks/useBrowserWindow';
import { ThreadStage } from '../../../../models/types';
import Permissions from '../../../../utils/Permissions';
import { CommentCard } from '../CommentCard';
import { isHot } from '../helpers';
import { AuthorAndPublishInfo } from './AuthorAndPublishInfo';
import './ThreadCard.scss';
import { CardSkeleton } from './ThreadCardSkeleton';
import { ThreadOptions } from './ThreadOptions';
import { AdminActionsProps } from './ThreadOptions/AdminActions';
import { ReactionButton } from './ThreadOptions/ReactionButton';

type CardProps = AdminActionsProps & {
  onBodyClick?: () => any;
  onStageTagClick?: (stage: ThreadStage) => any;
  threadHref?: string;
  showSkeleton?: boolean;
  canReact?: boolean;
  canComment?: boolean;
  canUpdateThread?: boolean;
  disabledActionsTooltipText?: GetThreadActionTooltipTextResponse;
  onCommentBtnClick?: () => any;
  hideRecentComments?: boolean;
  hideReactionButton?: boolean;
  hideUpvotesDrawer?: boolean;
  maxRecentCommentsToDisplay?: number;
  layoutType?: 'author-first' | 'community-first';
  customStages?: string[];
  editingDisabled?: boolean;
};

export const ThreadCard = ({
  thread,
  onDelete,
  onSpamToggle,
  onLockToggle,
  onPinToggle,
  onProposalStageChange,
  onSnapshotProposalFromThread,
  onCollaboratorsEdit,
  onEditStart,
  onEditCancel,
  onEditConfirm,
  hasPendingEdits,
  onBodyClick,
  onStageTagClick,
  threadHref,
  showSkeleton,
  canReact = true,
  canComment = true,
  canUpdateThread = true,
  disabledActionsTooltipText = '',
  onCommentBtnClick = () => null,
  hideRecentComments = false,
  hideReactionButton = false,
  hideUpvotesDrawer = false,
  maxRecentCommentsToDisplay = 2,
  layoutType = 'author-first',
  customStages,
  editingDisabled,
}: CardProps) => {
  const navigate = useCommonNavigate();
  const { isLoggedIn } = useUserLoggedIn();
  const { isWindowSmallInclusive } = useBrowserWindow({});
  const [isUpvoteDrawerOpen, setIsUpvoteDrawerOpen] = useState<boolean>(false);
  const contestsEnabled = useFlag('contest');

  useEffect(() => {
    if (localStorage.getItem('dark-mode-state') === 'on') {
      document.getElementsByTagName('html')[0].classList.add('invert');
    }
  }, []);

  if (showSkeleton)
    return (
      <CardSkeleton disabled={true} thread isWindowSmallInclusive={false} />
    );

  const hasAdminPermissions =
    Permissions.isSiteAdmin() ||
    // @ts-expect-error <StrictNullChecks/>
    Permissions.isCommunityAdmin(null, thread.communityId) ||
    // @ts-expect-error <StrictNullChecks/>
    Permissions.isCommunityModerator(null, thread.communityId);
  const isThreadAuthor = Permissions.isThreadAuthor(thread);
  const isThreadCollaborator = Permissions.isThreadCollaborator(thread);

  const linkedSnapshots = filterLinks(thread.links, LinkSource.Snapshot);
  const linkedProposals = filterLinks(thread.links, LinkSource.Proposal);

  const isStageDefault = isDefaultStage(thread.stage, customStages);
  const isTagsRowVisible =
    (thread.stage && !isStageDefault) || linkedProposals?.length > 0;
  const stageLabel = threadStageToLabel(thread.stage);

  const contestWinners = getWinnersFromAssociatedContests(
    thread.associatedContests,
  );

  const showContestWinnerTag = contestsEnabled && contestWinners.length > 0;

  return (
    <>
      <Link
        // @ts-expect-error <StrictNullChecks/>
        to={threadHref}
        className={getClasses<{ isPinned?: boolean }>(
          { isPinned: thread.pinned },
          'ThreadCard',
        )}
        onClick={() => onBodyClick && onBodyClick()}
        key={thread.id}
      >
        {!hideReactionButton && !isWindowSmallInclusive && (
          <ReactionButton
            thread={thread}
            size="big"
            disabled={!canReact}
            undoUpvoteDisabled={editingDisabled}
            tooltipText={
              typeof disabledActionsTooltipText === 'function'
                ? disabledActionsTooltipText?.('upvote')
                : disabledActionsTooltipText
            }
          />
        )}
        <div className="content-wrapper">
          <div className="content-header">
            <AuthorAndPublishInfo
              authorAddress={thread.author}
              authorCommunityId={thread.authorCommunity}
              publishDate={thread.createdAt}
              isHot={isHot(thread)}
              isLocked={thread.readOnly}
              {...(thread.lockedAt && {
                lockedAt: thread.lockedAt.toISOString(),
              })}
              {...(thread.updatedAt && {
                lastUpdated: (
                  thread?.lastEdited ||
                  thread.createdAt ||
                  thread.updatedAt
                ).toISOString(),
              })}
              discord_meta={thread.discord_meta}
              // @ts-expect-error <StrictNullChecks/>
              archivedAt={thread.archivedAt}
              profile={thread?.profile}
              layoutType={layoutType}
            />
            <div className="content-header-icons">
              {thread.pinned && <CWIcon iconName="pin" />}
            </div>
          </div>
          <div className="content-body-wrapper">
            {thread.markedAsSpamAt && <CWTag label="SPAM" type="disabled" />}
            <div className="content-title">
              <CWText type="h5" fontWeight="semiBold">
                {showContestWinnerTag &&
                  contestWinners.map((winner, index) => {
                    if (!winner) {
                      return null;
                    }

                    return (
                      <ThreadContestTag
                        date={winner.date}
                        round={winner.round}
                        title={winner.title}
                        prize={winner.prize}
                        key={index}
                      />
                    );
                  })}

                {thread.title}
              </CWText>
            </div>
            <div className="content-top-tags">
              {thread.hasPoll && <CWTag label="Poll" type="poll" />}

              {linkedSnapshots.length > 0 && (
                <CWTag
                  type="active"
                  label={`Snap ${(linkedSnapshots[0].identifier.includes('/')
                    ? linkedSnapshots[0].identifier.split('/')[1]
                    : linkedSnapshots[0].identifier
                  )
                    .toString()
                    .slice(0, 4)}…`}
                />
              )}
            </div>
            <CWText type="b1" className="content-body">
              <QuillRenderer
                doc={thread.plaintext}
                cutoffLines={4}
                customShowMoreButton={
                  <CWText type="b1" className="show-more-btn">
                    Show more
                  </CWText>
                }
              />
            </CWText>
          </div>
          {isTagsRowVisible && (
            <div className="content-tags">
              {thread.stage && !isStageDefault && (
                <CWTag
                  label={stageLabel}
                  classNames={stageLabel}
                  trimAt={20}
                  type="stage"
                  onClick={async (e) => {
                    // @ts-expect-error <StrictNullChecks/>
                    e.preventDefault();
                    // @ts-expect-error <StrictNullChecks/>
                    e.stopPropagation();
                    // @ts-expect-error <StrictNullChecks/>
                    await onStageTagClick(thread.stage);
                  }}
                />
              )}
              {linkedProposals
                .sort((a, b) => +a.identifier - +b.identifier)
                .map((link) => (
                  <CWTag
                    key={`${link.source}-${link.identifier}`}
                    type="proposal"
                    label={`Prop
                        ${
                          Number.isNaN(parseInt(link.identifier, 10))
                            ? ''
                            : ` #${link.identifier}`
                        }`}
                  />
                ))}
            </div>
          )}
          <div
            className="content-footer"
            onClick={(e) => {
              e.stopPropagation();
            }}
          >
            <ThreadOptions
              totalComments={thread.numberOfComments}
              shareEndpoint={`${window.location.origin}${threadHref}`}
              thread={thread}
              upvoteBtnVisible={!hideReactionButton && isWindowSmallInclusive}
              commentBtnVisible={!thread.readOnly}
              canUpdateThread={
                canUpdateThread &&
                isLoggedIn &&
                (isThreadAuthor || isThreadCollaborator || hasAdminPermissions)
              }
              canReact={canReact}
              canComment={canComment}
              onDelete={onDelete}
              onSpamToggle={onSpamToggle}
              onLockToggle={onLockToggle}
              onPinToggle={onPinToggle}
              onProposalStageChange={onProposalStageChange}
              onSnapshotProposalFromThread={onSnapshotProposalFromThread}
              onCollaboratorsEdit={onCollaboratorsEdit}
              onEditStart={onEditStart}
              onEditCancel={onEditCancel}
              onEditConfirm={onEditConfirm}
              hasPendingEdits={hasPendingEdits}
              onCommentBtnClick={onCommentBtnClick}
              disabledActionsTooltipText={disabledActionsTooltipText}
              setIsUpvoteDrawerOpen={setIsUpvoteDrawerOpen}
              hideUpvoteDrawerButton={hideUpvotesDrawer}
              editingDisabled={editingDisabled}
            />
          </div>
        </div>
      </Link>
      {!hideRecentComments &&
      maxRecentCommentsToDisplay &&
      // @ts-expect-error <StrictNullChecks/>
      thread?.recentComments?.length > 0 ? (
        <div className={clsx('RecentComments', { hideReactionButton })}>
          {[...(thread?.recentComments || [])]
            ?.filter((recentComment) => !recentComment.deleted)
            ?.slice?.(0, maxRecentCommentsToDisplay)
            ?.sort((a, b) => b.createdAt.unix() - a.createdAt.unix())
            ?.map((recentComment) => (
              <Link
                to={`${threadHref}?comment=${recentComment.id}`}
                key={recentComment.id}
                className="Comment"
                onClick={() => onBodyClick && onBodyClick()}
              >
                <CommentCard
                  disabledActionsTooltipText={disabledActionsTooltipText}
                  canReply={!disabledActionsTooltipText}
                  replyBtnVisible
                  hideReactButton
                  comment={recentComment}
                  isThreadArchived={!!thread.archivedAt}
                  isSpam={!!recentComment.markedAsSpamAt}
                  maxReplyLimitReached={false}
                  viewUpvotesButtonVisible={false}
                  shareURL={`${window.location.origin}${threadHref}?comment=${recentComment.id}`}
                  onReply={() =>
                    navigate(
                      `${threadHref}?comment=${recentComment.id}`,
                      {},
                      null,
                    )
                  }
                />
              </Link>
            ))}
        </div>
      ) : (
        <></>
      )}
      {!hideUpvotesDrawer && (
        <ViewThreadUpvotesDrawer
          thread={thread}
          isOpen={isUpvoteDrawerOpen}
          setIsOpen={setIsUpvoteDrawerOpen}
        />
      )}
      <CWDivider className="ThreadDivider" />
    </>
  );
};

1	import { useCommonNavigate } from 'client/scripts/navigation/helpers';
2	import { ViewThreadUpvotesDrawer } from 'client/scripts/views/components/UpvoteDrawer';
3	import { CWDivider } from 'client/scripts/views/components/component_kit/cw_divider';
4	import { QuillRenderer } from 'client/scripts/views/components/react_quill_editor/quill_renderer';
5	import clsx from 'clsx';
6	import { isDefaultStage, threadStageToLabel } from 'helpers';
7	import {
8	GetThreadActionTooltipTextResponse,
9	filterLinks,
10	} from 'helpers/threads';
11	import { useFlag } from 'hooks/useFlag';
12	import useUserLoggedIn from 'hooks/useUserLoggedIn';
13	import { LinkSource } from 'models/Thread';
14	import React, { useEffect, useState } from 'react';
15	import { Link } from 'react-router-dom';
16	import ThreadContestTag from 'views/components/ThreadContestTag';
17	import { getWinnersFromAssociatedContests } from 'views/components/ThreadContestTag/utils';
18	import { CWIcon } from 'views/components/component_kit/cw_icons/cw_icon';
19	import { CWText } from 'views/components/component_kit/cw_text';
20	import { getClasses } from 'views/components/component_kit/helpers';
21	import { CWTag } from 'views/components/component_kit/new_designs/CWTag';
22	import useBrowserWindow from '../../../../hooks/useBrowserWindow';
23	import { ThreadStage } from '../../../../models/types';
24	import Permissions from '../../../../utils/Permissions';
25	import { CommentCard } from '../CommentCard';
26	import { isHot } from '../helpers';
27	import { AuthorAndPublishInfo } from './AuthorAndPublishInfo';
28	import './ThreadCard.scss';
29	import { CardSkeleton } from './ThreadCardSkeleton';
30	import { ThreadOptions } from './ThreadOptions';
31	import { AdminActionsProps } from './ThreadOptions/AdminActions';
32	import { ReactionButton } from './ThreadOptions/ReactionButton';
33
34	type CardProps = AdminActionsProps & {
35	onBodyClick?: () => any;
36	onStageTagClick?: (stage: ThreadStage) => any;
37	threadHref?: string;
38	showSkeleton?: boolean;
39	canReact?: boolean;
40	canComment?: boolean;
41	canUpdateThread?: boolean;
42	disabledActionsTooltipText?: GetThreadActionTooltipTextResponse;
43	onCommentBtnClick?: () => any;
44	hideRecentComments?: boolean;
45	hideReactionButton?: boolean;
46	hideUpvotesDrawer?: boolean;
47	maxRecentCommentsToDisplay?: number;
48	layoutType?: 'author-first' \| 'community-first';
49	customStages?: string[];
50	editingDisabled?: boolean;
51	};
52
53	export const ThreadCard = ({	×
54	thread,
55	onDelete,
56	onSpamToggle,
57	onLockToggle,
58	onPinToggle,
59	onProposalStageChange,
60	onSnapshotProposalFromThread,
61	onCollaboratorsEdit,
62	onEditStart,
63	onEditCancel,
64	onEditConfirm,
65	hasPendingEdits,
66	onBodyClick,
67	onStageTagClick,
68	threadHref,
69	showSkeleton,
70	canReact = true,	×
71	canComment = true,	×
72	canUpdateThread = true,	×
73	disabledActionsTooltipText = '',	×
74	onCommentBtnClick = () => null,	×
75	hideRecentComments = false,	×
76	hideReactionButton = false,	×
77	hideUpvotesDrawer = false,	×
78	maxRecentCommentsToDisplay = 2,	×
79	layoutType = 'author-first',	×
80	customStages,
81	editingDisabled,
82	}: CardProps) => {
83	const navigate = useCommonNavigate();	×
84	const { isLoggedIn } = useUserLoggedIn();	×
85	const { isWindowSmallInclusive } = useBrowserWindow({});	×
86	const [isUpvoteDrawerOpen, setIsUpvoteDrawerOpen] = useState<boolean>(false);	×
NEW 87	const contestsEnabled = useFlag('contest');	×
88
89	useEffect(() => {	×
90	if (localStorage.getItem('dark-mode-state') === 'on') {	×
91	document.getElementsByTagName('html')[0].classList.add('invert');	×
92	}
93	}, []);
94
95	if (showSkeleton)	×
96	return (	×
97	<CardSkeleton disabled={true} thread isWindowSmallInclusive={false} />
98	);
99
100	const hasAdminPermissions =
101	Permissions.isSiteAdmin() \|\|	×
102	// @ts-expect-error <StrictNullChecks/>
103	Permissions.isCommunityAdmin(null, thread.communityId) \|\|
104	// @ts-expect-error <StrictNullChecks/>
105	Permissions.isCommunityModerator(null, thread.communityId);
106	const isThreadAuthor = Permissions.isThreadAuthor(thread);	×
107	const isThreadCollaborator = Permissions.isThreadCollaborator(thread);	×
108
109	const linkedSnapshots = filterLinks(thread.links, LinkSource.Snapshot);	×
110	const linkedProposals = filterLinks(thread.links, LinkSource.Proposal);	×
111
112	const isStageDefault = isDefaultStage(thread.stage, customStages);	×
113	const isTagsRowVisible =
114	(thread.stage && !isStageDefault) \|\| linkedProposals?.length > 0;	×
115	const stageLabel = threadStageToLabel(thread.stage);	×
116
NEW 117	const contestWinners = getWinnersFromAssociatedContests(	×
118	thread.associatedContests,
119	);
120
NEW 121	const showContestWinnerTag = contestsEnabled && contestWinners.length > 0;	×
122
123	return (	×
124	<>
125	<Link
126	// @ts-expect-error <StrictNullChecks/>
127	to={threadHref}
128	className={getClasses<{ isPinned?: boolean }>(
129	{ isPinned: thread.pinned },
130	'ThreadCard',
131	)}
132	onClick={() => onBodyClick && onBodyClick()}	×
133	key={thread.id}
134	>
135	{!hideReactionButton && !isWindowSmallInclusive && (	×
136	<ReactionButton
137	thread={thread}
138	size="big"
139	disabled={!canReact}
140	undoUpvoteDisabled={editingDisabled}
141	tooltipText={
142	typeof disabledActionsTooltipText === 'function'	×
143	? disabledActionsTooltipText?.('upvote')
144	: disabledActionsTooltipText
145	}
146	/>
147	)}
148	<div className="content-wrapper">
149	<div className="content-header">
150	<AuthorAndPublishInfo
151	authorAddress={thread.author}
152	authorCommunityId={thread.authorCommunity}
153	publishDate={thread.createdAt}
154	isHot={isHot(thread)}
155	isLocked={thread.readOnly}
156	{...(thread.lockedAt && {	×
157	lockedAt: thread.lockedAt.toISOString(),
158	})}
159	{...(thread.updatedAt && {	×
160	lastUpdated: (
161	thread?.lastEdited \|\|	×
162	thread.createdAt \|\|
163	thread.updatedAt
164	).toISOString(),
165	})}
166	discord_meta={thread.discord_meta}
167	// @ts-expect-error <StrictNullChecks/>
168	archivedAt={thread.archivedAt}
169	profile={thread?.profile}
170	layoutType={layoutType}
171	/>
172	<div className="content-header-icons">
173	{thread.pinned && <CWIcon iconName="pin" />}	×
174	</div>
175	</div>
176	<div className="content-body-wrapper">
177	{thread.markedAsSpamAt && <CWTag label="SPAM" type="disabled" />}	×
178	<div className="content-title">
179	<CWText type="h5" fontWeight="semiBold">
180	{showContestWinnerTag &&	×
181	contestWinners.map((winner, index) => {
NEW 182	if (!winner) {	×
NEW 183	return null;	×
184	}
185
NEW 186	return (	×
187	<ThreadContestTag
188	date={winner.date}
189	round={winner.round}
190	title={winner.title}
191	prize={winner.prize}
192	key={index}
193	/>
194	);
195	})}
196
197	{thread.title}
198	</CWText>
199	</div>
200	<div className="content-top-tags">
201	{thread.hasPoll && <CWTag label="Poll" type="poll" />}	×
202
203	{linkedSnapshots.length > 0 && (	×
204	<CWTag
205	type="active"
206	label={`Snap ${(linkedSnapshots[0].identifier.includes('/')	×
207	? linkedSnapshots[0].identifier.split('/')[1]
208	: linkedSnapshots[0].identifier
209	)
210	.toString()
211	.slice(0, 4)}…`}
212	/>
213	)}
214	</div>
215	<CWText type="b1" className="content-body">
216	<QuillRenderer
217	doc={thread.plaintext}
218	cutoffLines={4}
219	customShowMoreButton={
220	<CWText type="b1" className="show-more-btn">
221	Show more
222	</CWText>
223	}
224	/>
225	</CWText>
226	</div>
227	{isTagsRowVisible && (	×
228	<div className="content-tags">
229	{thread.stage && !isStageDefault && (	×
230	<CWTag
231	label={stageLabel}
232	classNames={stageLabel}
233	trimAt={20}
234	type="stage"
235	onClick={async (e) => {
236	// @ts-expect-error <StrictNullChecks/>
237	e.preventDefault();	×
238	// @ts-expect-error <StrictNullChecks/>
239	e.stopPropagation();	×
240	// @ts-expect-error <StrictNullChecks/>
241	await onStageTagClick(thread.stage);	×
242	}}
243	/>
244	)}
245	{linkedProposals
246	.sort((a, b) => +a.identifier - +b.identifier)	×
247	.map((link) => (
248	<CWTag	×
249	key={`${link.source}-${link.identifier}`}
250	type="proposal"
251	label={`Prop
252	${
253	Number.isNaN(parseInt(link.identifier, 10))	×
254	? ''
255	: ` #${link.identifier}`
256	}`}
257	/>
258	))}
259	</div>
260	)}
261	<div
262	className="content-footer"
263	onClick={(e) => {
264	e.stopPropagation();	×
265	}}
266	>
267	<ThreadOptions
268	totalComments={thread.numberOfComments}
269	shareEndpoint={`${window.location.origin}${threadHref}`}
270	thread={thread}
271	upvoteBtnVisible={!hideReactionButton && isWindowSmallInclusive}	×
272	commentBtnVisible={!thread.readOnly}
273	canUpdateThread={
274	canUpdateThread &&	×
275	isLoggedIn &&
276	(isThreadAuthor \|\| isThreadCollaborator \|\| hasAdminPermissions)
277	}
278	canReact={canReact}
279	canComment={canComment}
280	onDelete={onDelete}
281	onSpamToggle={onSpamToggle}
282	onLockToggle={onLockToggle}
283	onPinToggle={onPinToggle}
284	onProposalStageChange={onProposalStageChange}
285	onSnapshotProposalFromThread={onSnapshotProposalFromThread}
286	onCollaboratorsEdit={onCollaboratorsEdit}
287	onEditStart={onEditStart}
288	onEditCancel={onEditCancel}
289	onEditConfirm={onEditConfirm}
290	hasPendingEdits={hasPendingEdits}
291	onCommentBtnClick={onCommentBtnClick}
292	disabledActionsTooltipText={disabledActionsTooltipText}
293	setIsUpvoteDrawerOpen={setIsUpvoteDrawerOpen}
294	hideUpvoteDrawerButton={hideUpvotesDrawer}
295	editingDisabled={editingDisabled}
296	/>
297	</div>
298	</div>
299	</Link>
300	{!hideRecentComments &&	×
301	maxRecentCommentsToDisplay &&
302	// @ts-expect-error <StrictNullChecks/>
303	thread?.recentComments?.length > 0 ? (
304	<div className={clsx('RecentComments', { hideReactionButton })}>
305	{[...(thread?.recentComments \|\| [])]	×
306	?.filter((recentComment) => !recentComment.deleted)	×
307	?.slice?.(0, maxRecentCommentsToDisplay)
308	?.sort((a, b) => b.createdAt.unix() - a.createdAt.unix())	×
309	?.map((recentComment) => (
310	<Link	×
311	to={`${threadHref}?comment=${recentComment.id}`}
312	key={recentComment.id}
313	className="Comment"
314	onClick={() => onBodyClick && onBodyClick()}	×
315	>
316	<CommentCard
317	disabledActionsTooltipText={disabledActionsTooltipText}
318	canReply={!disabledActionsTooltipText}
319	replyBtnVisible
320	hideReactButton
321	comment={recentComment}
322	isThreadArchived={!!thread.archivedAt}
323	isSpam={!!recentComment.markedAsSpamAt}
324	maxReplyLimitReached={false}
325	viewUpvotesButtonVisible={false}
326	shareURL={`${window.location.origin}${threadHref}?comment=${recentComment.id}`}
327	onReply={() =>
328	navigate(	×
329	`${threadHref}?comment=${recentComment.id}`,
330	{},
331	null,
332	)
333	}
334	/>
335	</Link>
336	))}
337	</div>
338	) : (
339	<></>
340	)}
341	{!hideUpvotesDrawer && (	×
342	<ViewThreadUpvotesDrawer
343	thread={thread}
344	isOpen={isUpvoteDrawerOpen}
345	setIsOpen={setIsUpvoteDrawerOpen}
346	/>
347	)}
348	<CWDivider className="ThreadDivider" />
349	</>
350	);
351	};

hicommonwealth / commonwealth / 9647808362

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous