9981748511

Committed 17 Jul 2024 09:28PM UTC coverage: 31.916% (+0.005%) from 31.911%

Build # 9981748511

Build Type

Pull #9517

github

Committed by

Will-Howard

Commit Message

change condition in SubscribeDialog

Pull Request Pull Request #9517: [Draft] Cleanup email verification logic so EAF never sends verification emails

Run Details

4907 of 40333 branches covered (12.17%)

Branch coverage included in aggregate %.

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

47 existing lines in 3 files now uncovered.

28711 of 65001 relevant lines covered (44.17%)

180.25 hits per line

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

23.26

/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;

    if (!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
NEW 177	if (!userEmailAddressIsVerified(currentUser)) {	×
178	// Combine mutations into a single update call.
179	// (This reduces the number of server-side callback
180	// invocations. In a past version this worked around
181	// a bug, now it's just a performance optimization.)
182	mutation = {...mutation, whenConfirmationEmailSent: new Date()};	×
183	}
184
185	void updateCurrentUser(mutation)	×
186
187	this.setState({ subscribedByEmail: true });	×
188	captureEvent("subscribedByEmail")	×
189	}
190
191	emailSubscriptionEnabled() {
192	return this.props.currentUser && getUserEmail(this.props.currentUser)	×
193	}
194
195	emailFeedExists(view: string) {
196	if (view === "curated") return true;	×
197	return false;	×
198	}
199
200	isAlreadySubscribed() {
201	if (this.state.view === "curated"	×
202	&& this.props.currentUser
203	&& this.props.currentUser.emailSubscribedToCurated)
204	return true;	×
205	return false;	×
206	}
207
208	selectMethod(method: string) {
209	this.setState({	×
210	copiedRSSLink: false,
211	subscribedByEmail: false,
212	method
213	})
214	}
215
216	selectThreshold(threshold: string) {
217	this.setState({	×
218	copiedRSSLink: false,
219	subscribedByEmail: false,
220	threshold
221	})
222	}
223
224
225	selectView(view: keyof typeof viewNames) {
226	this.setState({	×
227	copiedRSSLink: false,
228	subscribedByEmail: false,
229	view
230	})
231	}
232
233	render() {
234	const { classes, fullScreen, onClose, open, currentUser } = this.props;	×
235	const { view, threshold, method, copiedRSSLink, subscribedByEmail } = this.state;	×
236	const { LWDialog, MenuItem } = Components;	×
237
238	const viewSelector = <FormControl key="viewSelector" className={classes.viewSelector}>	×
239	<InputLabel htmlFor="subscribe-dialog-view">Feed</InputLabel>
240	<Select
241	value={view}
242	onChange={ event => this.selectView(event.target.value as keyof typeof viewNames) }	×
243	disabled={method === "email" && !currentUser}	×
244	inputProps={{ id: "subscribe-dialog-view" }}
245	>
246	{/* TODO: Forum digest */}
247	<MenuItem value="curated">Curated</MenuItem>
248	<MenuItem value="frontpage" disabled={method === "email"}>Frontpage</MenuItem>
249	<MenuItem value="community" disabled={method === "email"}>{preferredHeadingCase("All Posts")}</MenuItem>
250	</Select>
251	</FormControl>
252
253	return (	×
254	<LWDialog
255	fullScreen={fullScreen}
256	open={open}
257	onClose={onClose}
258	>
259	{isLWorAF && <Tabs	×
260	value={method}
261	indicatorColor="primary"
262	textColor="primary"
263	onChange={ (event, value) => this.selectMethod(value) }	×
264	className={classes.tabbar}
265	fullWidth
266	>
267	<Tab label="RSS" key="tabRSS" value="rss" />
268	<Tab label="Email" key="tabEmail" value="email" />
269	</Tabs>}
270
271	<DialogContent className={classes.content}>
272	{ method === "rss" && <React.Fragment>	×
273	{viewSelector}
274
275	{(view === "community" \|\| view === "frontpage") && <div>	×
276	<DialogContentText>Generate a RSS link to posts in {viewNames[view]} of this karma and above.</DialogContentText>
277	<RadioGroup
278	value={threshold}
279	onChange={ (event, value) => this.selectThreshold(value) }	×
280	className={classes.thresholdSelector}
281	>
282	{ thresholds.map((t: AnyBecauseTodo) => t.toString()).map((threshold: AnyBecauseTodo) =>	×
283	<FormControlLabel	×
284	control={<Radio />}
285	label={threshold}
286	value={threshold}
287	key={`labelKarmaThreshold${threshold}`}
288	className={classes.thresholdButton}
289	/>
290	) }
291	</RadioGroup>
292	<DialogContentText className={classes.estimate}>
293	That's roughly { postsPerWeek[threshold] } posts per week
294	({ timePerWeekFromPosts(postsPerWeek[threshold]) } of reading)
295	</DialogContentText>
296	</div>}
297
298	<TextField
299	className={classes.RSSLink}
300	label="RSS Link"
301	onFocus={this.autoselectRSSLink}
302	onClick={this.autoselectRSSLink}
303	value={rssTermsToUrl(this.rssTerms())}
304	key="rssLinkTextField"
305	fullWidth />
306	</React.Fragment> }
307
308	{ method === "email" && [	×
309	viewSelector,
310	!!currentUser ? (
311	[	×
312	!this.emailFeedExists(view) && <DialogContentText key="dialogNoFeed" className={classes.errorMsg}>	×
313	Sorry, there's currently no email feed for {viewNames[view]}.
314	</DialogContentText>,
315	subscribedByEmail && !userEmailAddressIsVerified(currentUser) && !isEAForum && <DialogContentText key="dialogCheckForVerification" className={classes.infoMsg}>	×
316	We need to confirm your email address. We sent a link to {getUserEmail(currentUser)}; click the link to activate your subscription.
317	</DialogContentText>
318	]
319	) : (
320	<DialogContentText key="dialogPleaseLogIn" className={classes.errorMsg}>
321	You need to <a className={classes.link} href="/login">log in</a> to subscribe via Email
322	</DialogContentText>
323	)
324	] }
325	</DialogContent>
326	<DialogActions>
327	{ method === "rss" &&	×
328	<CopyToClipboard
329	text={rssTermsToUrl(this.rssTerms())}
330	onCopy={ (text, result) => {
331	this.setState({ copiedRSSLink: result })	×
332	this.props.captureEvent("rssLinkCopied")	×
333	}}
334	>
335	<Button color="primary">{copiedRSSLink ? "Copied!" : "Copy Link"}</Button>	×
336	</CopyToClipboard> }
337	{ method === "email" &&	×
338	(this.isAlreadySubscribed()
339	? <Button color="primary" disabled={true}>	×
340	You are already subscribed to this feed.
341	</Button>
342	: <Button
343	color="primary"
344	onClick={ () => this.subscribeByEmail() }	×
345	disabled={!this.emailFeedExists(view) \|\| subscribedByEmail \|\| !currentUser}	×
346	>{subscribedByEmail ? "Subscribed!" : "Subscribe to Feed"}</Button>	×
347	)
348	}
349	<Button onClick={onClose}>Close</Button>
350	</DialogActions>
351	</LWDialog>
352	);
353	}
354	}
355
356	const SubscribeDialogComponent = registerComponent<ExternalProps>("SubscribeDialog", SubscribeDialog, {	1✔
357	styles,
358	hocs: [
359	withMobileDialog(),
360	withUser,
361	withUpdateCurrentUser,
362	withTracking,
363	]
364	});
365
366	declare global {
367	interface ComponentTypes {
368	SubscribeDialog: typeof SubscribeDialogComponent
369	}
370	}

ForumMagnum / ForumMagnum / 9981748511

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