9617917456

Committed 21 Jun 2024 06:07PM UTC coverage: 31.847% (+0.003%) from 31.844%

Build # 9617917456

Build Type

Pull #9436

github

Committed by

jimrandomh

Commit Message

Fix ability to resend confirmation emails

Broken by an incorrect refactor: https://github.com/ForumMagnum/ForumMagnum/commit/cd51ba60c#diff-abce36aaff3b4ad7e7c319859dc29b07cR590

Pull Request Pull Request #9436: Fix ability to resend confirmation emails

Run Details

4827 of 39553 branches covered (12.2%)

Branch coverage included in aggregate %.

28099 of 63836 relevant lines covered (44.02%)

179.44 hits per line

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

11.58

/packages/lesswrong/components/common/HashLink.tsx

// Modified From: https://github.com/rafrex/react-router-hash-link/blob/master/src/index.js

import React from 'react';
import PropTypes from 'prop-types';
// eslint-disable-next-line no-restricted-imports
import { Link } from 'react-router-dom';
// eslint-disable-next-line no-restricted-imports
import type { LinkProps } from 'react-router-dom';
import { useNavigate } from '@/lib/routeUtil';

type ScrollFunction = ((el: HTMLElement) => void);

export type HashLinkProps = {
  to: string
  id?: string,
  nofollow?: boolean,
  target?: string,
  doOnDown?: boolean
  onMouseDown?: React.MouseEventHandler<HTMLAnchorElement>
  onClick?: React.MouseEventHandler<HTMLAnchorElement>
  scroll?: ScrollFunction,
  smooth?: boolean
  children?: React.ReactNode,
};

let hashFragment = '';
let observer: null | MutationObserver = null;
let asyncTimerId: null | number = null;
let scrollFunction: null | ScrollFunction = null;

function reset() {
  hashFragment = '';
  if (observer) {observer.disconnect();}
  if (asyncTimerId !== null) {
    window.clearTimeout(asyncTimerId);
    asyncTimerId = null;
  }
}

function getElAndScroll() {
  const element = document.getElementById(hashFragment);
  if (element !== null && scrollFunction !== null) {
    scrollFunction(element);
    reset();
    return true;
  }
  return false;
}

function hashLinkScroll() {
  // Push onto callback queue so it runs after the DOM is updated
  window.setTimeout(() => {
    if (getElAndScroll() === false) {
      if (observer === null) {
        // We check for mutations of the DOM in order to scroll correctly to elements that are only rendered after a bit of a delay
        observer = new MutationObserver(getElAndScroll);
      }
      observer.observe(document, {
        attributes: true,
        childList: true,
        subtree: true,
      });
      // if the element doesn't show up in 10 seconds, stop checking
      asyncTimerId = window.setTimeout(() => {
        reset();
      }, 10000);
    }
  }, 0);
}

export function HashLink(props: HashLinkProps) {
  const navigate = useNavigate();

  function handleClick(e: React.MouseEvent<HTMLAnchorElement>) {
    reset();
    if (props.onClick) props.onClick(e);
    hashFragment = props.to
      .split('#')
      .slice(1)
      .join('#');
    if (hashFragment !== '') {
      scrollFunction =
        props.scroll ||
        (el =>
          props.smooth
            ? el.scrollIntoView({ behavior: "smooth" })
            : el.scrollIntoView());
      hashLinkScroll();
    }
  }
  const { scroll, smooth, children, doOnDown, to, ...filteredProps } = props;
  if (doOnDown && !filteredProps.target) {
    return <a
      {...filteredProps}
      href={to}
      onMouseDown={(ev) => {
        if (ev.metaKey || ev.altKey || ev.ctrlKey || ev.shiftKey || ev.button !== 0) {
          return;
        }
        filteredProps.onMouseDown?.(ev)
        navigate(to);
        ev.preventDefault();
      }}
    >
      {props.children}
    </a>
  } else {
    return <Link to={to} {...filteredProps} onClick={handleClick}>
      {props.children}
    </Link>
  }
}

export function getHashLinkOnClick(props: HashLinkProps) {
  function handleClick(e: React.MouseEvent<HTMLAnchorElement>) {
    reset();
    if (props.onClick) props.onClick(e);
    hashFragment = props.to
      .split('#')
      .slice(1)
      .join('#');
    if (hashFragment !== '') {
      scrollFunction =
        props.scroll ||
        (el =>
          props.smooth
            ? el.scrollIntoView({ behavior: "smooth" })
            : el.scrollIntoView());
      hashLinkScroll();
    }
  }
  return handleClick;
};

const propTypes = {
  onClick: PropTypes.func,
  children: PropTypes.any,
  scroll: PropTypes.func,
  to: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),
};

HashLink.propTypes = propTypes;

1	// Modified From: https://github.com/rafrex/react-router-hash-link/blob/master/src/index.js	60✔
2
3	import React from 'react';	20✔
4	import PropTypes from 'prop-types';	20✔
5	// eslint-disable-next-line no-restricted-imports
6	import { Link } from 'react-router-dom';	20✔
7	// eslint-disable-next-line no-restricted-imports
8	import type { LinkProps } from 'react-router-dom';
9	import { useNavigate } from '@/lib/routeUtil';	20✔
10
11	type ScrollFunction = ((el: HTMLElement) => void);
12
13	export type HashLinkProps = {
14	to: string
15	id?: string,
16	nofollow?: boolean,
17	target?: string,
18	doOnDown?: boolean
19	onMouseDown?: React.MouseEventHandler<HTMLAnchorElement>
20	onClick?: React.MouseEventHandler<HTMLAnchorElement>
21	scroll?: ScrollFunction,
22	smooth?: boolean
23	children?: React.ReactNode,
24	};
25
26	let hashFragment = '';	20✔
27	let observer: null \| MutationObserver = null;	20✔
28	let asyncTimerId: null \| number = null;	20✔
29	let scrollFunction: null \| ScrollFunction = null;	20✔
30
31	function reset() {
32	hashFragment = '';	×
33	if (observer) {observer.disconnect();}	×
34	if (asyncTimerId !== null) {	×
35	window.clearTimeout(asyncTimerId);	×
36	asyncTimerId = null;	×
37	}
38	}
39
40	function getElAndScroll() {
41	const element = document.getElementById(hashFragment);	×
42	if (element !== null && scrollFunction !== null) {	×
43	scrollFunction(element);	×
44	reset();	×
45	return true;	×
46	}
47	return false;	×
48	}
49
50	function hashLinkScroll() {
51	// Push onto callback queue so it runs after the DOM is updated
52	window.setTimeout(() => {	×
53	if (getElAndScroll() === false) {	×
54	if (observer === null) {	×
55	// We check for mutations of the DOM in order to scroll correctly to elements that are only rendered after a bit of a delay
56	observer = new MutationObserver(getElAndScroll);	×
57	}
58	observer.observe(document, {	×
59	attributes: true,
60	childList: true,
61	subtree: true,
62	});
63	// if the element doesn't show up in 10 seconds, stop checking
64	asyncTimerId = window.setTimeout(() => {	×
65	reset();	×
66	}, 10000);
67	}
68	}, 0);
69	}
70
71	export function HashLink(props: HashLinkProps) {
72	const navigate = useNavigate();	×
73
74	function handleClick(e: React.MouseEvent<HTMLAnchorElement>) {
75	reset();	×
76	if (props.onClick) props.onClick(e);	×
77	hashFragment = props.to	×
78	.split('#')
79	.slice(1)
80	.join('#');
81	if (hashFragment !== '') {	×
82	scrollFunction =	×
83	props.scroll \|\|	×
84	(el =>
85	props.smooth	×
86	? el.scrollIntoView({ behavior: "smooth" })	×
87	: el.scrollIntoView());
88	hashLinkScroll();	×
89	}
90	}
91	const { scroll, smooth, children, doOnDown, to, ...filteredProps } = props;	×
92	if (doOnDown && !filteredProps.target) {	×
93	return <a	×
94	{...filteredProps}
95	href={to}
96	onMouseDown={(ev) => {
97	if (ev.metaKey \|\| ev.altKey \|\| ev.ctrlKey \|\| ev.shiftKey \|\| ev.button !== 0) {	×
98	return;	×
99	}
100	filteredProps.onMouseDown?.(ev)	×
101	navigate(to);	×
102	ev.preventDefault();	×
103	}}
104	>
105	{props.children}
106	</a>
107	} else {
108	return <Link to={to} {...filteredProps} onClick={handleClick}>	×
109	{props.children}
110	</Link>
111	}
112	}
113
114	export function getHashLinkOnClick(props: HashLinkProps) {
115	function handleClick(e: React.MouseEvent<HTMLAnchorElement>) {
116	reset();	×
117	if (props.onClick) props.onClick(e);	×
118	hashFragment = props.to	×
119	.split('#')
120	.slice(1)
121	.join('#');
122	if (hashFragment !== '') {	×
123	scrollFunction =	×
124	props.scroll \|\|	×
125	(el =>
126	props.smooth	×
127	? el.scrollIntoView({ behavior: "smooth" })	×
128	: el.scrollIntoView());
129	hashLinkScroll();	×
130	}
131	}
132	return handleClick;	×
133	};
134
135	const propTypes = {	20✔
136	onClick: PropTypes.func,
137	children: PropTypes.any,
138	scroll: PropTypes.func,
139	to: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),
140	};
141
142	HashLink.propTypes = propTypes;	20✔

ForumMagnum / ForumMagnum / 9617917456

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