9981617333

Committed 17 Jul 2024 09:16PM UTC coverage: 31.913% (+0.002%) from 31.911%

Build # 9981617333

Build Type

push

github

Committed by

Will-Howard

Commit Message

added comments

Run Details

4907 of 40339 branches covered (12.16%)

Branch coverage included in aggregate %.

0 of 2 new or added lines in 1 file covered. (0.0%)

4 existing lines in 4 files now uncovered.

28712 of 65007 relevant lines covered (44.17%)

180.25 hits per line

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

22.9

/packages/lesswrong/components/common/SubscribeDialog.tsx

import React, { Component } from 'react';
import { registerComponent, Components } from '../../lib/vulcan-lib';
import { withUpdateCurrentUser, WithUpdateCurrentUserProps } from '../hooks/useUpdateCurrentUser';
import { getUserEmail, userEmailAddressIsVerified} from '../../lib/collections/users/helpers';
import { rssTermsToUrl } from "../../lib/rss_urls";
import { CopyToClipboard } from 'react-copy-to-clipboard';
import TextField from '@material-ui/core/TextField';
import Button from '@material-ui/core/Button';
import DialogActions from '@material-ui/core/DialogActions';
import DialogContent from '@material-ui/core/DialogContent';
import DialogContentText from '@material-ui/core/DialogContentText';
import Radio from '@material-ui/core/Radio';
import RadioGroup from '@material-ui/core/RadioGroup';
import FormControlLabel from '@material-ui/core/FormControlLabel';
import FormControl from '@material-ui/core/FormControl';
import InputLabel from '@material-ui/core/InputLabel';
import Select from '@material-ui/core/Select';
import withMobileDialog from '@material-ui/core/withMobileDialog';
import withUser from '../common/withUser';
import { withTracking } from "../../lib/analyticsEvents";
import { isEAForum, isLWorAF } from '../../lib/instanceSettings';
import Tabs from '@material-ui/core/Tabs';
import Tab from '@material-ui/core/Tab';
import { preferredHeadingCase } from '../../themes/forumTheme';
import { forumSelect } from '../../lib/forumTypeUtils';


const styles = (theme: ThemeType): JssStyles => ({
  thresholdSelector: {
    display: "flex",
    flexDirection: "row",
    justifyContent: "space-evenly"
  },
  estimate: {
    maxWidth: "500px"
  },
  content: {
    padding: `0 ${theme.spacing.unit * 3}px`,
    "& .MuiTypography-root": {
      color: theme.palette.text.normal,
    },
  },
  tabbar: {
    marginBottom: theme.spacing.unit * 3
  },
  viewSelector: {
    width: "100%",
    marginBottom: theme.spacing.unit * 2
  },
  RSSLink: {
    marginTop: theme.spacing.unit * 2
  },
  errorMsg: {
    color: theme.palette.text.error,
  },
  link: {
    textDecoration: "underline"
  },
});

const thresholds = forumSelect({
  LessWrong: [2, 30, 45, 75, 125],
  AlignmentForum: [2, 30, 45],
  EAForum: [2, 30, 75, 125, 200],
  // We default you off pretty low, you can add more once you get more high
  // karma posts
  default: [2, 30, 45, 75]
})

/**
 * Calculated based on the average number of words posted per post on LW2 as of
 * August 2018.
 */
function timePerWeekFromPosts(posts: number) {
  const minutes = posts * 11
  if (minutes < 60) {
    return `${minutes} minutes`
  }
  return `${Math.round(minutes / 60)} hours`
}

/** Posts per week as of May 2022 */
const postsPerWeek = forumSelect<Record<string, number>>({
  EAForum: {
    '2': 119,
    '30': 24,
    '45': 20,
    '75': 10,
    '125': 4,
    '200': 1,
  },
  // (JP) I eyeballed these, you could query your db for better numbers
  LessWrong: {
    '2': 80,
    '30': 16,
    '45': 13,
    '75': 7,
    '125': 2,
  },
  AlignmentForum: {
    '2': 10,
    '30': 2,
    '45': 1,
  },
  default: {
    '2': 40,
    '30': 7,
    '45': 2,
    '75': 1,
  }
});

const viewNames = {
  'frontpage': 'Frontpage',
  'curated': 'Curated Content',
  'community': 'All Posts',
  'pending': 'pending posts',
  'rejected': 'rejected posts',
  'scheduled': 'scheduled posts',
  'all_drafts': 'all drafts',
}

interface ExternalProps {
  method: any,
  view: any,
  fullScreen?: boolean,
  onClose: any,
  open: boolean,
}
interface SubscribeDialogProps extends ExternalProps, WithUserProps, WithStylesProps, WithTrackingProps, WithUpdateCurrentUserProps {
}

interface SubscribeDialogState {
  view:  keyof typeof viewNames,
  method:  string,
  threshold: string,
  copiedRSSLink: boolean,
  subscribedByEmail: boolean,
}

type EventWithSelectTarget = {
  target: {
    select: Function
  }
};

class SubscribeDialog extends Component<SubscribeDialogProps,SubscribeDialogState> {
  constructor(props: SubscribeDialogProps) {
    super(props);
    this.state = {
      threshold: "30",
      method: this.props.method,
      copiedRSSLink: false,
      subscribedByEmail: false,
      
      view: (this.props.method === "email" && !this.emailFeedExists(this.props.view)) ? "curated" : this.props.view,
    };
  }

  rssTerms() {
    const view = this.state.view;
    let terms: any = { view: `${view}-rss` };
    if (view === "community" || view === "frontpage") terms.karmaThreshold = this.state.threshold;
    return terms;
  }

  // FIXME: Not clear that this actually works for both onClick and onFocus!
  autoselectRSSLink(event: any) {
    event.target && 'select' in event.target && event.target.select();
  }

  subscribeByEmail() {
    let mutation: Partial<DbUser> = { emailSubscribedToCurated: true }
    const { currentUser, updateCurrentUser, captureEvent } = this.props;
    if (!currentUser) return;

    // TODO !userEmailAddressIsVerified will always be false for EAF (via assumeUserEmailVerifiedSetting). !isLWorAF will always be false for LW or AF, so this
    // path can only be hit on other instances. Ask Vlad if he is using it and cut it if not
    if (!isLWorAF && !userEmailAddressIsVerified(currentUser)) {
      // Combine mutations into a single update call.
      // (This reduces the number of server-side callback
      // invocations. In a past version this worked around
      // a bug, now it's just a performance optimization.)
      mutation = {...mutation, whenConfirmationEmailSent: new Date()};
    }

    void updateCurrentUser(mutation)

    this.setState({ subscribedByEmail: true });
    captureEvent("subscribedByEmail")
  }

  emailSubscriptionEnabled() {
    return this.props.currentUser && getUserEmail(this.props.currentUser) 
  }

  emailFeedExists(view: string) {
    if (view === "curated") return true;
    return false;
  }

  isAlreadySubscribed() {
    if (this.state.view === "curated"
        && this.props.currentUser
        && this.props.currentUser.emailSubscribedToCurated)
      return true;
    return false;
  }

  selectMethod(method: string) {
    this.setState({
      copiedRSSLink: false,
      subscribedByEmail: false,
      method
    })
  }

  selectThreshold(threshold: string) {
    this.setState({
      copiedRSSLink: false,
      subscribedByEmail: false,
      threshold
    })
  }


  selectView(view: keyof typeof viewNames) {
    this.setState({
      copiedRSSLink: false,
      subscribedByEmail: false,
      view
    })
  }

  render() {
    const { classes, fullScreen, onClose, open, currentUser } = this.props;
    const { view, threshold, method, copiedRSSLink, subscribedByEmail } = this.state;
    const { LWDialog, MenuItem } = Components;

    const viewSelector = <FormControl key="viewSelector" className={classes.viewSelector}>
      <InputLabel htmlFor="subscribe-dialog-view">Feed</InputLabel>
      <Select
        value={view}
        onChange={ event => this.selectView(event.target.value as keyof typeof viewNames) }
        disabled={method === "email" && !currentUser}
        inputProps={{ id: "subscribe-dialog-view" }}
      >
        {/* TODO: Forum digest */}
        <MenuItem value="curated">Curated</MenuItem>
        <MenuItem value="frontpage" disabled={method === "email"}>Frontpage</MenuItem>
        <MenuItem value="community" disabled={method === "email"}>{preferredHeadingCase("All Posts")}</MenuItem>
      </Select>
    </FormControl>

    return (
      <LWDialog
        fullScreen={fullScreen}
        open={open}
        onClose={onClose}
      >
        {isLWorAF && <Tabs
          value={method}
          indicatorColor="primary"
          textColor="primary"
          onChange={ (event, value) => this.selectMethod(value) }
          className={classes.tabbar}
          fullWidth
        >
          <Tab label="RSS" key="tabRSS" value="rss" />
          <Tab label="Email" key="tabEmail" value="email" />
        </Tabs>}

        <DialogContent className={classes.content}>
          { method === "rss" && <React.Fragment>
            {viewSelector}

            {(view === "community" || view === "frontpage") && <div>
              <DialogContentText>Generate a RSS link to posts in {viewNames[view]} of this karma and above.</DialogContentText>
              <RadioGroup
                value={threshold}
                onChange={ (event, value) => this.selectThreshold(value) }
                className={classes.thresholdSelector}
              >
                { thresholds.map((t: AnyBecauseTodo) => t.toString()).map((threshold: AnyBecauseTodo) =>
                  <FormControlLabel
                    control={<Radio />}
                    label={threshold}
                    value={threshold}
                    key={`labelKarmaThreshold${threshold}`}
                    className={classes.thresholdButton}
                  />
                ) }
              </RadioGroup>
              <DialogContentText className={classes.estimate}>
                That's roughly { postsPerWeek[threshold] } posts per week
                ({ timePerWeekFromPosts(postsPerWeek[threshold]) } of reading)
              </DialogContentText>
            </div>}

            <TextField
              className={classes.RSSLink}
              label="RSS Link"
              onFocus={this.autoselectRSSLink}
              onClick={this.autoselectRSSLink}
              value={rssTermsToUrl(this.rssTerms())}
              key="rssLinkTextField"
              fullWidth />
          </React.Fragment> }

          { method === "email" && [
            viewSelector,
            !!currentUser ? (
              [
                !this.emailFeedExists(view) && <DialogContentText key="dialogNoFeed" className={classes.errorMsg}>
                  Sorry, there's currently no email feed for {viewNames[view]}.
                </DialogContentText>,
                subscribedByEmail && !userEmailAddressIsVerified(currentUser) && !isEAForum && <DialogContentText key="dialogCheckForVerification" className={classes.infoMsg}>
                  We need to confirm your email address. We sent a link to {getUserEmail(currentUser)}; click the link to activate your subscription.
                </DialogContentText>
              ]
            ) : (
              <DialogContentText key="dialogPleaseLogIn" className={classes.errorMsg}>
                You need to <a className={classes.link} href="/login">log in</a> to subscribe via Email
              </DialogContentText>
            )
          ] }
        </DialogContent>
        <DialogActions>
          { method === "rss" &&
            <CopyToClipboard
              text={rssTermsToUrl(this.rssTerms())}
              onCopy={ (text, result) => {
                this.setState({ copiedRSSLink: result })
                this.props.captureEvent("rssLinkCopied")
              }}
            >
              <Button color="primary">{copiedRSSLink ? "Copied!" : "Copy Link"}</Button>
            </CopyToClipboard> }
          { method === "email" &&
            (this.isAlreadySubscribed()
              ? <Button color="primary" disabled={true}>
                  You are already subscribed to this feed.
                </Button>
              : <Button
                  color="primary"
                  onClick={ () => this.subscribeByEmail() }
                  disabled={!this.emailFeedExists(view) || subscribedByEmail || !currentUser}
                >{subscribedByEmail ? "Subscribed!" : "Subscribe to Feed"}</Button>
            )
          }
          <Button onClick={onClose}>Close</Button>
        </DialogActions>
      </LWDialog>
    );
  }
}

const SubscribeDialogComponent = registerComponent<ExternalProps>("SubscribeDialog", SubscribeDialog, {
  styles,
  hocs: [
    withMobileDialog(),
    withUser,
    withUpdateCurrentUser,
    withTracking,
  ]
});

declare global {
  interface ComponentTypes {
    SubscribeDialog: typeof SubscribeDialogComponent
  }
}

1	import React, { Component } from 'react';	1✔
2	import { registerComponent, Components } from '../../lib/vulcan-lib';	1✔
3	import { withUpdateCurrentUser, WithUpdateCurrentUserProps } from '../hooks/useUpdateCurrentUser';	1✔
4	import { getUserEmail, userEmailAddressIsVerified} from '../../lib/collections/users/helpers';	1✔
5	import { rssTermsToUrl } from "../../lib/rss_urls";	1✔
6	import { CopyToClipboard } from 'react-copy-to-clipboard';	1✔
7	import TextField from '@material-ui/core/TextField';	1✔
8	import Button from '@material-ui/core/Button';	1✔
9	import DialogActions from '@material-ui/core/DialogActions';	1✔
10	import DialogContent from '@material-ui/core/DialogContent';	1✔
11	import DialogContentText from '@material-ui/core/DialogContentText';	1✔
12	import Radio from '@material-ui/core/Radio';	1✔
13	import RadioGroup from '@material-ui/core/RadioGroup';	1✔
14	import FormControlLabel from '@material-ui/core/FormControlLabel';	1✔
15	import FormControl from '@material-ui/core/FormControl';	1✔
16	import InputLabel from '@material-ui/core/InputLabel';	1✔
17	import Select from '@material-ui/core/Select';	1✔
18	import withMobileDialog from '@material-ui/core/withMobileDialog';	1✔
19	import withUser from '../common/withUser';	1✔
20	import { withTracking } from "../../lib/analyticsEvents";	1✔
21	import { isEAForum, isLWorAF } from '../../lib/instanceSettings';	1✔
22	import Tabs from '@material-ui/core/Tabs';	1✔
23	import Tab from '@material-ui/core/Tab';	1✔
24	import { preferredHeadingCase } from '../../themes/forumTheme';	1✔
25	import { forumSelect } from '../../lib/forumTypeUtils';	1✔
26
27
28	const styles = (theme: ThemeType): JssStyles => ({	1✔
29	thresholdSelector: {
30	display: "flex",
31	flexDirection: "row",
32	justifyContent: "space-evenly"
33	},
34	estimate: {
35	maxWidth: "500px"
36	},
37	content: {
38	padding: `0 ${theme.spacing.unit * 3}px`,
39	"& .MuiTypography-root": {
40	color: theme.palette.text.normal,
41	},
42	},
43	tabbar: {
44	marginBottom: theme.spacing.unit * 3
45	},
46	viewSelector: {
47	width: "100%",
48	marginBottom: theme.spacing.unit * 2
49	},
50	RSSLink: {
51	marginTop: theme.spacing.unit * 2
52	},
53	errorMsg: {
54	color: theme.palette.text.error,
55	},
56	link: {
57	textDecoration: "underline"
58	},
59	});
60
61	const thresholds = forumSelect({	1✔
62	LessWrong: [2, 30, 45, 75, 125],
63	AlignmentForum: [2, 30, 45],
64	EAForum: [2, 30, 75, 125, 200],
65	// We default you off pretty low, you can add more once you get more high
66	// karma posts
67	default: [2, 30, 45, 75]
68	})
69
70	/**
71	* Calculated based on the average number of words posted per post on LW2 as of
72	* August 2018.
73	*/
74	function timePerWeekFromPosts(posts: number) {
75	const minutes = posts * 11	×
76	if (minutes < 60) {	×
77	return `${minutes} minutes`	×
78	}
79	return `${Math.round(minutes / 60)} hours`	×
80	}
81
82	/** Posts per week as of May 2022 */
83	const postsPerWeek = forumSelect<Record<string, number>>({	1✔
84	EAForum: {
85	'2': 119,
86	'30': 24,
87	'45': 20,
88	'75': 10,
89	'125': 4,
90	'200': 1,
91	},
92	// (JP) I eyeballed these, you could query your db for better numbers
93	LessWrong: {
94	'2': 80,
95	'30': 16,
96	'45': 13,
97	'75': 7,
98	'125': 2,
99	},
100	AlignmentForum: {
101	'2': 10,
102	'30': 2,
103	'45': 1,
104	},
105	default: {
106	'2': 40,
107	'30': 7,
108	'45': 2,
109	'75': 1,
110	}
111	});
112
113	const viewNames = {	1✔
114	'frontpage': 'Frontpage',
115	'curated': 'Curated Content',
116	'community': 'All Posts',
117	'pending': 'pending posts',
118	'rejected': 'rejected posts',
119	'scheduled': 'scheduled posts',
120	'all_drafts': 'all drafts',
121	}
122
123	interface ExternalProps {
124	method: any,
125	view: any,
126	fullScreen?: boolean,
127	onClose: any,
128	open: boolean,
129	}
130	interface SubscribeDialogProps extends ExternalProps, WithUserProps, WithStylesProps, WithTrackingProps, WithUpdateCurrentUserProps {
131	}
132
133	interface SubscribeDialogState {
134	view: keyof typeof viewNames,
135	method: string,
136	threshold: string,
137	copiedRSSLink: boolean,
138	subscribedByEmail: boolean,
139	}
140
141	type EventWithSelectTarget = {
142	target: {
143	select: Function
144	}
145	};
146
147	class SubscribeDialog extends Component<SubscribeDialogProps,SubscribeDialogState> {
148	constructor(props: SubscribeDialogProps) {
149	super(props);	×
150	this.state = {	×
151	threshold: "30",
152	method: this.props.method,
153	copiedRSSLink: false,
154	subscribedByEmail: false,
155
156	view: (this.props.method === "email" && !this.emailFeedExists(this.props.view)) ? "curated" : this.props.view,	×
157	};
158	}
159
160	rssTerms() {
161	const view = this.state.view;	×
162	let terms: any = { view: `${view}-rss` };	×
163	if (view === "community" \|\| view === "frontpage") terms.karmaThreshold = this.state.threshold;	×
164	return terms;	×
165	}
166
167	// FIXME: Not clear that this actually works for both onClick and onFocus!
168	autoselectRSSLink(event: any) {
169	event.target && 'select' in event.target && event.target.select();	×
170	}
171
172	subscribeByEmail() {
173	let mutation: Partial<DbUser> = { emailSubscribedToCurated: true }	×
174	const { currentUser, updateCurrentUser, captureEvent } = this.props;	×
175	if (!currentUser) return;	×
176
177	// TODO !userEmailAddressIsVerified will always be false for EAF (via assumeUserEmailVerifiedSetting). !isLWorAF will always be false for LW or AF, so this
178	// path can only be hit on other instances. Ask Vlad if he is using it and cut it if not
UNCOV 179	if (!isLWorAF && !userEmailAddressIsVerified(currentUser)) {	×
180	// Combine mutations into a single update call.
181	// (This reduces the number of server-side callback
182	// invocations. In a past version this worked around
183	// a bug, now it's just a performance optimization.)
184	mutation = {...mutation, whenConfirmationEmailSent: new Date()};	×
185	}
186
187	void updateCurrentUser(mutation)	×
188
189	this.setState({ subscribedByEmail: true });	×
190	captureEvent("subscribedByEmail")	×
191	}
192
193	emailSubscriptionEnabled() {
194	return this.props.currentUser && getUserEmail(this.props.currentUser)	×
195	}
196
197	emailFeedExists(view: string) {
198	if (view === "curated") return true;	×
199	return false;	×
200	}
201
202	isAlreadySubscribed() {
203	if (this.state.view === "curated"	×
204	&& this.props.currentUser
205	&& this.props.currentUser.emailSubscribedToCurated)
206	return true;	×
207	return false;	×
208	}
209
210	selectMethod(method: string) {
211	this.setState({	×
212	copiedRSSLink: false,
213	subscribedByEmail: false,
214	method
215	})
216	}
217
218	selectThreshold(threshold: string) {
219	this.setState({	×
220	copiedRSSLink: false,
221	subscribedByEmail: false,
222	threshold
223	})
224	}
225
226
227	selectView(view: keyof typeof viewNames) {
228	this.setState({	×
229	copiedRSSLink: false,
230	subscribedByEmail: false,
231	view
232	})
233	}
234
235	render() {
236	const { classes, fullScreen, onClose, open, currentUser } = this.props;	×
237	const { view, threshold, method, copiedRSSLink, subscribedByEmail } = this.state;	×
238	const { LWDialog, MenuItem } = Components;	×
239
240	const viewSelector = <FormControl key="viewSelector" className={classes.viewSelector}>	×
241	<InputLabel htmlFor="subscribe-dialog-view">Feed</InputLabel>
242	<Select
243	value={view}
244	onChange={ event => this.selectView(event.target.value as keyof typeof viewNames) }	×
245	disabled={method === "email" && !currentUser}	×
246	inputProps={{ id: "subscribe-dialog-view" }}
247	>
248	{/* TODO: Forum digest */}
249	<MenuItem value="curated">Curated</MenuItem>
250	<MenuItem value="frontpage" disabled={method === "email"}>Frontpage</MenuItem>
251	<MenuItem value="community" disabled={method === "email"}>{preferredHeadingCase("All Posts")}</MenuItem>
252	</Select>
253	</FormControl>
254
255	return (	×
256	<LWDialog
257	fullScreen={fullScreen}
258	open={open}
259	onClose={onClose}
260	>
261	{isLWorAF && <Tabs	×
262	value={method}
263	indicatorColor="primary"
264	textColor="primary"
265	onChange={ (event, value) => this.selectMethod(value) }	×
266	className={classes.tabbar}
267	fullWidth
268	>
269	<Tab label="RSS" key="tabRSS" value="rss" />
270	<Tab label="Email" key="tabEmail" value="email" />
271	</Tabs>}
272
273	<DialogContent className={classes.content}>
274	{ method === "rss" && <React.Fragment>	×
275	{viewSelector}
276
277	{(view === "community" \|\| view === "frontpage") && <div>	×
278	<DialogContentText>Generate a RSS link to posts in {viewNames[view]} of this karma and above.</DialogContentText>
279	<RadioGroup
280	value={threshold}
281	onChange={ (event, value) => this.selectThreshold(value) }	×
282	className={classes.thresholdSelector}
283	>
284	{ thresholds.map((t: AnyBecauseTodo) => t.toString()).map((threshold: AnyBecauseTodo) =>	×
285	<FormControlLabel	×
286	control={<Radio />}
287	label={threshold}
288	value={threshold}
289	key={`labelKarmaThreshold${threshold}`}
290	className={classes.thresholdButton}
291	/>
292	) }
293	</RadioGroup>
294	<DialogContentText className={classes.estimate}>
295	That's roughly { postsPerWeek[threshold] } posts per week
296	({ timePerWeekFromPosts(postsPerWeek[threshold]) } of reading)
297	</DialogContentText>
298	</div>}
299
300	<TextField
301	className={classes.RSSLink}
302	label="RSS Link"
303	onFocus={this.autoselectRSSLink}
304	onClick={this.autoselectRSSLink}
305	value={rssTermsToUrl(this.rssTerms())}
306	key="rssLinkTextField"
307	fullWidth />
308	</React.Fragment> }
309
310	{ method === "email" && [	×
311	viewSelector,
312	!!currentUser ? (
313	[	×
314	!this.emailFeedExists(view) && <DialogContentText key="dialogNoFeed" className={classes.errorMsg}>	×
315	Sorry, there's currently no email feed for {viewNames[view]}.
316	</DialogContentText>,
317	subscribedByEmail && !userEmailAddressIsVerified(currentUser) && !isEAForum && <DialogContentText key="dialogCheckForVerification" className={classes.infoMsg}>	×
318	We need to confirm your email address. We sent a link to {getUserEmail(currentUser)}; click the link to activate your subscription.
319	</DialogContentText>
320	]
321	) : (
322	<DialogContentText key="dialogPleaseLogIn" className={classes.errorMsg}>
323	You need to <a className={classes.link} href="/login">log in</a> to subscribe via Email
324	</DialogContentText>
325	)
326	] }
327	</DialogContent>
328	<DialogActions>
329	{ method === "rss" &&	×
330	<CopyToClipboard
331	text={rssTermsToUrl(this.rssTerms())}
332	onCopy={ (text, result) => {
333	this.setState({ copiedRSSLink: result })	×
334	this.props.captureEvent("rssLinkCopied")	×
335	}}
336	>
337	<Button color="primary">{copiedRSSLink ? "Copied!" : "Copy Link"}</Button>	×
338	</CopyToClipboard> }
339	{ method === "email" &&	×
340	(this.isAlreadySubscribed()
341	? <Button color="primary" disabled={true}>	×
342	You are already subscribed to this feed.
343	</Button>
344	: <Button
345	color="primary"
346	onClick={ () => this.subscribeByEmail() }	×
347	disabled={!this.emailFeedExists(view) \|\| subscribedByEmail \|\| !currentUser}	×
348	>{subscribedByEmail ? "Subscribed!" : "Subscribe to Feed"}</Button>	×
349	)
350	}
351	<Button onClick={onClose}>Close</Button>
352	</DialogActions>
353	</LWDialog>
354	);
355	}
356	}
357
358	const SubscribeDialogComponent = registerComponent<ExternalProps>("SubscribeDialog", SubscribeDialog, {	1✔
359	styles,
360	hocs: [
361	withMobileDialog(),
362	withUser,
363	withUpdateCurrentUser,
364	withTracking,
365	]
366	});
367
368	declare global {
369	interface ComponentTypes {
370	SubscribeDialog: typeof SubscribeDialogComponent
371	}
372	}

ForumMagnum / ForumMagnum / 9981617333

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