index
int64 0
0
| repo_id
stringlengths 16
181
| file_path
stringlengths 28
270
| content
stringlengths 1
11.6M
| __index_level_0__
int64 0
10k
|
|---|---|---|---|---|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/sidebar/SidebarListItemContent.tsx
|
import { HTMLAttributes, ReactNode } from 'react';
import { IconName } from '../icon';
interface Props extends HTMLAttributes<HTMLSpanElement> {
icon?: IconName;
iconColor?: string;
children?: ReactNode;
title?: string;
left?: ReactNode;
right?: ReactNode;
}
const SidebarListItemContent = ({ left, right, children, ...rest }: Props) => {
return (
<span className="flex flex-nowrap w-full flex-align-items-center gap-2" {...rest}>
{left}
<span className="flex-item-fluid max-w-full flex flex-align-items-center flex-nowrap gap-2">{children}</span>
{right && <span className="flex-no-min-children flex-align-items-center">{right}</span>}
</span>
);
};
export default SidebarListItemContent;
| 5,600
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/sidebar/SidebarListItemContentIcon.tsx
|
import clsx from '@proton/utils/clsx';
import Icon, { IconProps } from '../icon/Icon';
const SidebarListItemContentIcon = ({ className, ...rest }: IconProps) => {
return (
<Icon className={clsx(['navigation-icon flex-item-noshrink flex-item-centered-vert', className])} {...rest} />
);
};
export default SidebarListItemContentIcon;
| 5,601
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/sidebar/SidebarListItemDiv.tsx
|
import { HTMLAttributes, ReactNode } from 'react';
import clsx from '@proton/utils/clsx';
export interface Props extends HTMLAttributes<HTMLDivElement> {
children: ReactNode;
}
const SidebarListItemDiv = ({ children, className = '', ...rest }: Props) => {
return (
<div className={clsx(['navigation-link', className])} {...rest}>
{children}
</div>
);
};
export default SidebarListItemDiv;
| 5,602
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/sidebar/SidebarListItemHeaderButton.tsx
|
import { ButtonHTMLAttributes } from 'react';
import Icon, { IconName } from '../icon/Icon';
interface Props extends ButtonHTMLAttributes<HTMLButtonElement> {
icon: IconName;
info: string;
}
export const SidebarListItemHeaderLinkButton = ({ info, icon, ...rest }: Props) => {
return (
<button className="navigation-link-header-group-control flex-item-noshrink" type="button" {...rest}>
<Icon name={icon} className="navigation-icon" />
<span className="sr-only">{info}</span>
</button>
);
};
export default SidebarListItemHeaderLinkButton;
| 5,603
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/sidebar/SidebarListItemHeaderLink.tsx
|
import { Ref, forwardRef } from 'react';
import Icon, { IconName } from '../icon/Icon';
import AppLink, { AppLinkProps } from '../link/AppLink';
interface Props extends AppLinkProps {
icon: IconName;
alt: string;
}
export const SidebarListItemHeaderLinkButton = ({ alt, icon, ...rest }: Props, ref: Ref<HTMLAnchorElement>) => {
return (
<AppLink
className="flex navigation-link-header-group-control flex-item-noshrink"
type="button"
ref={ref}
{...rest}
>
<Icon name={icon} className="navigation-icon" alt={alt} />
</AppLink>
);
};
export default forwardRef<HTMLAnchorElement, Props>(SidebarListItemHeaderLinkButton);
| 5,604
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/sidebar/SidebarListItemLabel.tsx
|
import { HTMLAttributes, ReactNode } from 'react';
import clsx from '@proton/utils/clsx';
export interface Props extends HTMLAttributes<HTMLLabelElement> {
children: ReactNode;
htmlFor: string;
}
const SidebarListItemLabel = ({ children, className = '', htmlFor, ...rest }: Props) => {
return (
<label htmlFor={htmlFor} className={clsx(['navigation-link', className])} {...rest}>
{children}
</label>
);
};
export default SidebarListItemLabel;
| 5,605
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/sidebar/SidebarListItemLink.tsx
|
import { ReactNode, Ref, forwardRef } from 'react';
import { NavLink, NavLinkProps } from 'react-router-dom';
import clsx from '@proton/utils/clsx';
export interface Props extends Omit<NavLinkProps, 'className'> {
children: ReactNode;
itemClassName?: string;
className?: string;
}
const SidebarListItemLink = forwardRef<HTMLAnchorElement, Props>(
({ children, itemClassName = 'navigation-link', className, ...rest }: Props, ref: Ref<HTMLAnchorElement>) => {
return (
<NavLink ref={ref} className={clsx([itemClassName, className])} {...rest}>
{children}
</NavLink>
);
}
);
export const SubSidebarListItemLink = ({ children, ...rest }: Props) => {
return (
<SidebarListItemLink itemClassName="navigation-sublink" {...rest}>
{children}
</SidebarListItemLink>
);
};
SidebarListItemLink.displayName = 'SidebarListItemLink';
export default SidebarListItemLink;
| 5,606
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/sidebar/SidebarNav.tsx
|
import { HTMLAttributes, ReactNode } from 'react';
import { c } from 'ttag';
import clsx from '@proton/utils/clsx';
interface Props extends HTMLAttributes<HTMLDivElement> {
children: ReactNode;
className?: string;
}
const SidebarNav = ({ children, className, ...rest }: Props) => {
return (
<nav
className={clsx(['navigation max-w-full flex-item-fluid-auto', className])}
{...rest}
// translator: Label for the primary navigation for screen readers. Omit the word "navigation" as it's announced in the landmarks menu as "Main navigation" automatically.
aria-label={c('Label').t`Main`}
>
<h2 className="sr-only">
{
// translator: This is a hidden headline for users with screen readers to highlight the main navigation
c('Label').t`Navigation`
}
</h2>
{children}
</nav>
);
};
export default SidebarNav;
| 5,607
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/sidebar/SidebarPrimaryButton.tsx
|
import { Ref, forwardRef } from 'react';
import { Button, ButtonProps } from '@proton/atoms';
import clsx from '@proton/utils/clsx';
const SidebarPrimaryButton = ({ children, className = '', ...rest }: ButtonProps, ref: Ref<HTMLButtonElement>) => {
return (
<Button color="norm" size="large" className={clsx(['w-full', className])} ref={ref} {...rest}>
{children}
</Button>
);
};
export default forwardRef<HTMLButtonElement, ButtonProps>(SidebarPrimaryButton);
| 5,608
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/sidebar/SidebarStorageMeter.scss
|
.sidebar-meter-storage {
--meter-bar-thumb-color-success: var(--text-weak);
--meter-bar-background-color: var(--border-weak);
}
| 5,609
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/sidebar/SidebarStorageMeter.tsx
|
import clsx from '@proton/utils/clsx';
import { Meter } from '../progress';
import './SidebarStorageMeter.scss';
interface Props {
label: string;
value: number;
className?: string;
}
const SidebarStorageMeter = ({ label, value, className }: Props) => {
return <Meter thin label={label} value={value} className={clsx('sidebar-meter-storage', className)} />;
};
export default SidebarStorageMeter;
| 5,610
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/sidebar/SimpleSidebarListItemHeader.tsx
|
import { ReactNode, Ref, useRef } from 'react';
import clsx from '@proton/utils/clsx';
import noop from '@proton/utils/noop';
import { HotkeyTuple, useHotkeys } from '../../hooks';
import Icon from '../icon/Icon';
import SidebarListItem from './SidebarListItem';
interface Props {
toggle: boolean;
onToggle: (display: boolean) => void;
hasCaret?: boolean;
right?: ReactNode;
text: string;
title?: string;
onFocus?: (id: string) => void;
id?: string;
testId?: string;
headerRef?: Ref<HTMLDivElement>;
spaceAbove?: boolean;
}
const SimpleSidebarListItemHeader = ({
toggle,
onToggle,
hasCaret = true,
right,
text,
id,
testId,
headerRef,
title,
onFocus = noop,
spaceAbove = false,
}: Props) => {
const buttonRef = useRef<HTMLButtonElement>(null);
const shortcutHandlers: HotkeyTuple[] = [
[
'ArrowRight',
(e) => {
e.stopPropagation();
onToggle(true);
},
],
[
'ArrowLeft',
() => {
onToggle(false);
},
],
];
useHotkeys(buttonRef, shortcutHandlers);
return (
<SidebarListItem
className={clsx([
'navigation-link-header-group',
hasCaret && 'navigation-link-header-group--expandable',
spaceAbove && 'mt-4',
])}
>
<div className="flex flex-nowrap w-full" ref={headerRef}>
<h3 className="sr-only">{text}</h3>
<button
ref={buttonRef}
className="flex flex-align-items-center flex-item-fluid flex-nowrap text-left ml-0 navigation-link-header-group-link"
type="button"
onClick={() => onToggle(!toggle)}
title={title}
aria-expanded={toggle}
onFocus={() => onFocus(id || '')}
data-shortcut-target={id}
data-testid={testId}
>
{hasCaret && (
<span className="flex-item-noshrink">
<Icon
name="chevron-down-filled"
className={clsx(['navigation-icon--expand', !toggle && 'rotateZ-270'])}
/>
</span>
)}
<span className="ml-2 mt-0.5 text-ellipsis">{text}</span>
</button>
{right}
</div>
</SidebarListItem>
);
};
export default SimpleSidebarListItemHeader;
| 5,611
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/sidebar/SimpleSidebarListItemLink.tsx
|
import { ReactNode } from 'react';
import { IconName, IconSize } from '../icon/Icon';
import SidebarListItem from './SidebarListItem';
import SidebarListItemContent from './SidebarListItemContent';
import SidebarListItemContentIcon from './SidebarListItemContentIcon';
import SidebarListItemLink, { Props as SidebarListItemProps } from './SidebarListItemLink';
interface Props extends SidebarListItemProps {
to: string;
icon?: IconName;
iconSize?: IconSize;
iconColor?: string;
children: ReactNode;
}
const SimpleSidebarListItemLink = ({ to, children, icon, iconSize, iconColor, ...rest }: Props) => {
const left = icon ? <SidebarListItemContentIcon name={icon} size={iconSize} color={iconColor} /> : null;
return (
<SidebarListItem>
<SidebarListItemLink to={to} {...rest}>
<SidebarListItemContent left={left}>{children}</SidebarListItemContent>
</SidebarListItemLink>
</SidebarListItem>
);
};
export default SimpleSidebarListItemLink;
| 5,612
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/sidebar/index.tsx
|
export { default as Hamburger } from './Hamburger';
export { default as Sidebar } from './Sidebar';
export { default as SidebarList, SubSidebarList } from './SidebarList';
export { default as SidebarBackButton } from './SidebarBackButton';
export { default as SidebarListItem, SubSidebarListItem } from './SidebarListItem';
export { default as SimpleSidebarListItemLink } from './SimpleSidebarListItemLink';
export { default as SimpleSidebarListItemHeader } from './SimpleSidebarListItemHeader';
export { default as SidebarListItemHeaderButton } from './SidebarListItemHeaderButton';
export { default as SidebarListItemHeaderLink } from './SidebarListItemHeaderLink';
export { default as SidebarListItemContent } from './SidebarListItemContent';
export { default as SidebarListItemContentIcon } from './SidebarListItemContentIcon';
export { default as SidebarListItemDiv } from './SidebarListItemDiv';
export { default as SidebarListItemLabel } from './SidebarListItemLabel';
export { default as SidebarListItemLink } from './SidebarListItemLink';
export { default as SidebarListItemButton } from './SidebarListItemButton';
export { default as SidebarNav } from './SidebarNav';
export { default as SidebarPrimaryButton } from './SidebarPrimaryButton';
export { default as SidebarContactItem } from './SidebarContactItem';
export { default as SettingsListItem } from './SettingsListItem';
| 5,613
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/skeletonLoader/SkeletonLoader.scss
|
@import '~@proton/styles/scss/lib';
.skeleton-loader {
display: inline-block;
border-radius: var(--border-radius-sm);
background-color: currentcolor;
line-height: 1.2;
opacity: 0;
animation: anime-skeleton-loader 0.5s calc(var(--index, 0) * 40ms) easing(ease-out-sine) infinite alternate both;
&::before {
content: '\00a0';
}
}
@keyframes anime-skeleton-loader {
from {
opacity: 0.05;
}
to {
opacity: 0.15;
}
}
| 5,614
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/skeletonLoader/SkeletonLoader.tsx
|
import { CSSProperties } from 'react';
import clsx from '@proton/utils/clsx';
import './SkeletonLoader.scss';
interface Props {
width?: string | number;
className?: string;
style?: CSSProperties;
index?: number;
}
const SkeletonLoader = ({ width, className, style, index }: Props) => {
return (
<div aria-hidden="true">
<div
className={clsx('skeleton-loader w-custom', className)}
style={{
'--w-custom': width,
'--index': index,
style,
}}
/>
</div>
);
};
export default SkeletonLoader;
| 5,615
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/skeletonLoader/index.ts
|
export { default as SkeletonLoader } from './SkeletonLoader';
| 5,616
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/spinner/ReloadSpinner.scss
|
@keyframes rotating {
from {
transform: rotate(0deg);
}
to {
transform: rotate(360deg);
}
}
.location-refresh-rotate {
animation: rotating 0.5s linear infinite;
}
| 5,617
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/spinner/ReloadSpinner.tsx
|
import { Icon, IconProps } from '@proton/components';
import clsx from '@proton/utils/clsx';
import './ReloadSpinner.scss';
interface Props extends Omit<IconProps, 'name'> {
refreshing?: boolean;
onRefresh?: () => void;
}
const ReloadSpinner = ({ className, refreshing = false, onRefresh, ...rest }: Props) => {
const handleClick = (event: React.MouseEvent<SVGSVGElement>) => {
if (refreshing) {
return;
}
event.preventDefault();
onRefresh?.();
};
return (
<Icon
onClick={handleClick}
name="arrow-rotate-right"
className={clsx([className, refreshing && 'location-refresh-rotate'])}
{...rest}
/>
);
};
export default ReloadSpinner;
| 5,618
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/spinner/index.ts
|
export { default as ReloadSpinner } from './ReloadSpinner';
| 5,619
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/spotlight/Provider.tsx
|
import { ReactNode, createContext, useState } from 'react';
import noop from '@proton/utils/noop';
interface Props {
children: ReactNode;
}
export const SpotlightContext = createContext<{
spotlight?: string;
addSpotlight: Function;
}>({ addSpotlight: noop });
const SpotlightProvider = ({ children }: Props) => {
const [spotlight, setSpotlight] = useState<string>();
const addSpotlight = (value: string) => {
setSpotlight((prevValue) => prevValue || value);
};
return <SpotlightContext.Provider value={{ spotlight, addSpotlight }}>{children}</SpotlightContext.Provider>;
};
export default SpotlightProvider;
| 5,620
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/spotlight/Spotlight.tsx
|
import {
AnimationEvent,
CSSProperties,
Children,
MouseEventHandler,
PropsWithChildren,
ReactElement,
ReactNode,
RefObject,
cloneElement,
useEffect,
useRef,
useState,
} from 'react';
import { c } from 'ttag';
import { Button } from '@proton/atoms';
import { useCombinedRefs } from '@proton/hooks';
import discoverIllustration from '@proton/styles/assets/img/illustrations/spotlight-binoculars.svg';
import newIllustration from '@proton/styles/assets/img/illustrations/spotlight-stars.svg';
import clsx from '@proton/utils/clsx';
import { generateUID } from '../../helpers';
import { useIsClosing } from '../../hooks';
import { Icon } from '../icon';
import { PopperPlacement, usePopper, usePopperState } from '../popper';
import { shouldShowSideRadius } from '../popper/utils';
import Portal from '../portal/Portal';
type SpotlightType = 'discover' | 'new';
export interface SpotlightProps {
show: boolean;
content: ReactNode;
type?: SpotlightType;
onDisplayed?: () => void;
onClose?: MouseEventHandler;
originalPlacement?: PopperPlacement;
hasClose?: boolean;
/**
* Setting the anchor is optional, it will default on the root child
*/
anchorRef?: RefObject<HTMLElement>;
style?: CSSProperties;
className?: string;
size?: 'large';
}
const Spotlight = ({
children,
show,
content,
type,
onDisplayed,
onClose,
originalPlacement = 'top',
hasClose = true,
anchorRef: inputAnchorRef,
style = {},
className,
size,
}: PropsWithChildren<SpotlightProps>) => {
const [uid] = useState(generateUID('spotlight'));
const popperAnchorRef = useRef<HTMLDivElement>(null);
const { open, close, isOpen } = usePopperState();
const anchorRef = inputAnchorRef || popperAnchorRef;
const { floating, position, arrow, placement } = usePopper({
// Spotlights open automatically and often targets elements which might have layout shifts,
// so it's updated more aggressively than dropdowns and tooltips which are user triggered.
updateAnimationFrame: true,
reference: {
mode: 'element',
value: anchorRef?.current,
},
isOpen,
originalPlacement,
});
const showSideRadius = shouldShowSideRadius(arrow['--arrow-offset'], placement, 8);
const [isClosing, isClosed, setIsClosed] = useIsClosing(isOpen);
const child = Children.only(children) as ReactElement;
// Types are wrong? Not sure why ref doesn't exist on a ReactElement
// @ts-ignore
const mergedRef = useCombinedRefs(popperAnchorRef, child?.ref);
useEffect(() => {
if (show) {
open();
onDisplayed?.();
}
}, [show]);
if (isClosed || !show) {
return cloneElement(child, { ref: mergedRef });
}
const handleAnimationEnd = ({ animationName }: AnimationEvent) => {
if (animationName.includes('anime-spotlight-out') && isClosing) {
setIsClosed();
}
};
const handleClose: MouseEventHandler = (event) => {
onClose?.(event);
close();
};
const closeText = c('Action').t`Close`;
const illustrationURL = type
? {
discover: discoverIllustration as string,
new: newIllustration as string,
}[type]
: null;
return (
<>
{cloneElement(child, {
ref: mergedRef,
'aria-describedby': uid,
})}
<Portal>
<div
ref={floating}
id={uid}
style={{ ...position, ...arrow, ...style }}
className={clsx([
'spotlight',
size && `spotlight--${size}`,
`spotlight--${placement}`,
isClosing && 'is-spotlight-out',
type && 'spotlight--with-illustration',
!showSideRadius && 'spotlight--no-side-radius',
className,
])}
onAnimationEnd={handleAnimationEnd}
>
<div className={clsx(['spotlight-inner', type && 'flex flex-nowrap flex-align-items-start'])}>
{illustrationURL && <img className="flex-item-noshrink mr-6" src={illustrationURL} alt="" />}
<div>{content}</div>
</div>
{hasClose && (
<Button
icon
shape="ghost"
size="small"
className="spotlight-close"
title={closeText}
onClick={handleClose}
>
<Icon name="cross" alt={closeText} />
</Button>
)}
</div>
</Portal>
</>
);
};
export default Spotlight;
| 5,621
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/spotlight/index.ts
|
export { default as Spotlight } from './Spotlight';
export type { SpotlightProps } from './Spotlight';
export { default as useSpotlightShow } from './useSpotlightShow';
| 5,622
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/spotlight/useSpotlightShow.ts
|
import { useContext, useEffect } from 'react';
import useInstance from '@proton/hooks/useInstance';
import { generateUID } from '../../helpers';
import { SpotlightContext } from './Provider';
const useSpotlightShow = (show: boolean) => {
const uid = useInstance(() => generateUID());
const { spotlight, addSpotlight } = useContext(SpotlightContext);
useEffect(() => {
if (show) {
addSpotlight(uid);
}
}, [show]);
return spotlight === uid && show;
};
export default useSpotlightShow;
| 5,623
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/stepDot/StepDot.tsx
|
import { HTMLProps } from 'react';
import { c } from 'ttag';
import clsx from '@proton/utils/clsx';
/*
* 'type' is string in HTMLButtonElement but the button React elements wants a union between
* the possible values for types, omitting for now due to incompatibility
*/
export interface Props extends Omit<HTMLProps<HTMLButtonElement>, 'onChange' | 'type'> {
onChange?: (index: number) => void;
index?: number;
active?: boolean;
}
const StepDot = ({ index, className, onChange, active, role = 'presentation', ...rest }: Props) => {
function handleClick() {
if (index !== undefined) {
onChange?.(index);
}
}
return (
<li className="step-dots-item" role={role}>
<button
type="button"
role="tab"
aria-selected={active}
className={clsx([className, 'step-dots-dot', 'rounded-50', !onChange && 'no-pointer-events'])}
title={onChange ? c('Action').t`Go to panel ${index}` : undefined}
onClick={handleClick}
{...rest}
>
<span className="sr-only">{c('Action').t`Go to panel ${index}`}</span>
</button>
</li>
);
};
export default StepDot;
| 5,624
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/stepDot/index.ts
|
export { default as StepDot } from './StepDot';
| 5,625
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/stepDots/StepDots.tsx
|
import { Children, HTMLProps, ReactElement, cloneElement } from 'react';
import clsx from '@proton/utils/clsx';
import { Props as StepDotProps } from '../stepDot/StepDot';
export interface Props extends Omit<HTMLProps<HTMLDivElement>, 'onChange'> {
value: number;
onChange?: (index: number) => void;
ulClassName?: string;
children: ReactElement<StepDotProps>[];
}
const StepDots = ({ value, onChange, children, className, ulClassName, ...rest }: Props) => {
const clonedChildren = Children.map(children, (child, index) =>
cloneElement(child, {
active: index === value,
index,
onChange,
})
);
return (
<nav {...rest} className={clsx([className, 'step-dots-container'])}>
<ul className={clsx(['step-dots-list unstyled inline-flex flex-row', ulClassName])} role="tablist">
{clonedChildren}
</ul>
</nav>
);
};
export default StepDots;
| 5,626
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/stepDots/index.ts
|
export { default as StepDots } from './StepDots';
| 5,627
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/stripedList/StripedItem.tsx
|
import { ComponentPropsWithoutRef, ReactNode } from 'react';
import clsx from '@proton/utils/clsx';
import Info from '../link/Info';
interface StripedItemProps extends ComponentPropsWithoutRef<'li'> {
left: ReactNode;
tooltip?: ReactNode;
}
const StripedItem = ({ left, tooltip, children, className, ...rest }: StripedItemProps) => {
return (
<li className={clsx('px-3 py-2 rounded', className)} {...rest}>
<div className="flex flex-nowrap flex-align-items-baseline">
<div className="flex-item-noshrink mr-2">{left}</div>
<div className="flex-item-fluid">
<span className="align-middle">{children}</span>
{tooltip ? <Info buttonClass="ml-2 align-middle" title={tooltip} /> : null}
</div>
</div>
</li>
);
};
export default StripedItem;
| 5,628
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/stripedList/StripedList.tsx
|
import { Children, ReactNode, isValidElement } from 'react';
import clsx from '@proton/utils/clsx';
interface StripedListProps {
children: ReactNode;
alternate?: 'odd' | 'even';
className?: string;
}
const StripedList = ({ children, alternate = 'even', className }: StripedListProps) => (
<ul className={clsx(alternate === 'even' ? 'bg-weak-even' : 'bg-weak-odd', 'unstyled', className)}>
{Children.map(children, (child) => {
if (isValidElement(child)) {
return child;
}
return null;
})}
</ul>
);
export default StripedList;
| 5,629
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/stripedList/index.ts
|
export { default as StripedList } from './StripedList';
export { default as StripedItem } from './StripedItem';
| 5,630
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/table/Cell.ts
|
import { ReactNode } from 'react';
/**
* Allow to use colSpan and rowSpan in <TableRow>
* <TableRow cells={[new Cell('double-height', rowSpan: 2), 'normal', 'normal', 'normal']} />
* <TableRow cells={['normal', new Cell('double-width', colSpan: 2)]} />
*/
export class Cell {
readonly content: ReactNode;
readonly colSpan: number | undefined;
readonly rowSpan: number | undefined;
constructor(content: ReactNode, colSpan?: number, rowSpan?: number) {
this.content = content;
this.colSpan = colSpan;
this.rowSpan = rowSpan;
}
}
export default Cell;
| 5,631
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/table/SortingTableHeader.tsx
|
import { HTMLAttributes, ReactNode, ThHTMLAttributes } from 'react';
import { Icon, TableCell } from '@proton/components/components';
import { SORT_DIRECTION } from '@proton/shared/lib/constants';
import noop from '@proton/utils/noop';
const { ASC, DESC } = SORT_DIRECTION;
interface SortingTableCellHeaderProps {
content: ReactNode;
onClick: () => void;
direction?: SORT_DIRECTION;
}
export const SortingTableCellHeader = ({ content, onClick = noop, direction }: SortingTableCellHeaderProps) => {
return (
<div className="flex-nowrap inline-flex-vcenter">
<span
tabIndex={0}
role="button"
className="link mr-2"
onClick={onClick}
onKeyDown={(e) => {
if (e.key === 'Enter') {
onClick();
}
}}
>
{content}
</span>
{direction === ASC || direction === DESC ? (
<Icon name="chevron-down" className={`flex-item-noshrink ${direction === DESC ? '' : 'rotateX-180'}`} />
) : null}
</div>
);
};
interface CellUnsortableProps extends Omit<ThHTMLAttributes<HTMLTableCellElement>, 'content'> {
content: ReactNode;
key?: undefined | null | never;
sorting?: undefined | null | false;
}
interface CellSortableProps<T> extends Omit<ThHTMLAttributes<HTMLTableCellElement>, 'content'> {
content: ReactNode;
key: keyof T;
sorting: true;
}
type CellProps<T = any> = CellUnsortableProps | CellSortableProps<T>;
interface SortingTableHeaderProps<T> extends HTMLAttributes<HTMLTableSectionElement> {
cells: CellProps<T>[];
config: {
key: keyof T;
direction: SORT_DIRECTION;
};
onToggleSort: (key: keyof T) => void;
}
const getCellKey = (key: symbol | string | number | null | undefined, index: number) =>
typeof key === 'string' || typeof key === 'number' ? `key-${key}` : `index-${index}`;
export const SortingTableHeader = <T extends unknown>({
cells = [],
config,
onToggleSort,
...rest
}: SortingTableHeaderProps<T>) => {
return (
<thead {...rest}>
<tr>
{cells.map(({ content, key, sorting, ...rest }, index) => (
<TableCell key={getCellKey(key, index)} type="header" {...rest}>
{sorting ? (
<SortingTableCellHeader
content={content}
onClick={() => onToggleSort(key)}
direction={config && config.key === key ? config.direction : undefined}
/>
) : (
content
)}
</TableCell>
))}
</tr>
</thead>
);
};
| 5,632
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/table/Table.tsx
|
import { DetailedHTMLProps, ReactNode, TableHTMLAttributes } from 'react';
import clsx from '@proton/utils/clsx';
interface Props extends DetailedHTMLProps<TableHTMLAttributes<HTMLTableElement>, HTMLTableElement> {
children: ReactNode;
className?: string;
caption?: string;
responsive?: 'cards' | 'stacked';
hasActions?: boolean;
borderWeak?: boolean;
}
const Table = ({ children, responsive, className, hasActions, caption, borderWeak, ...props }: Props) => {
return (
<table
className={clsx([
'simple-table',
responsive === 'cards' && 'simple-table--responsive simple-table--responsive-cards',
responsive === 'stacked' && 'simple-table--responsive simple-table--responsive-stacked',
hasActions && 'simple-table--has-actions',
borderWeak && 'simple-table--border-weak',
className,
])}
{...props}
>
{caption ? <caption className="sr-only">{caption}</caption> : null}
{children}
</table>
);
};
export default Table;
| 5,633
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/table/TableBody.tsx
|
import { ReactNode } from 'react';
import TableRowBusy from './TableRowBusy';
interface Props {
children: ReactNode;
colSpan?: number;
loading?: boolean;
}
const TableBody = ({ children, loading = false, colSpan, ...rest }: Props) => {
return <tbody {...rest}>{loading ? <TableRowBusy colSpan={colSpan} /> : children}</tbody>;
};
export default TableBody;
| 5,634
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/table/TableCell.tsx
|
import { ReactNode, ThHTMLAttributes } from 'react';
interface Props extends ThHTMLAttributes<HTMLTableCellElement> {
children: ReactNode;
label?: ReactNode | string;
type?: 'body' | 'header' | 'footer';
'data-testid'?: string;
}
/**
* TableCell with type 'header' is deprecated. Please use TableHeaderCell component for header cells.
*/
const TableCell = ({ children, label, type = 'body', 'data-testid': dataTestId, ...rest }: Props) => {
if (type === 'header' || type === 'footer') {
return (
<th scope="col" {...rest}>
{children}
</th>
);
}
return (
<td role="cell" {...rest} data-testid={dataTestId}>
{label && <p className="simple-table__th-small">{label}</p>}
{children}
</td>
);
};
export default TableCell;
| 5,635
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/table/TableCellBusy.tsx
|
import { ComponentPropsWithoutRef } from 'react';
import { CircleLoader } from '@proton/atoms';
import clsx from '@proton/utils/clsx';
interface Props extends ComponentPropsWithoutRef<'td'> {
colSpan?: number;
}
const TableCellBusy = ({ colSpan, className }: Props) => (
<td colSpan={colSpan} className={clsx([className, 'text-center'])} aria-busy="true">
<CircleLoader />
</td>
);
export default TableCellBusy;
| 5,636
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/table/TableFooter.tsx
|
import { HTMLAttributes, ReactNode } from 'react';
import TableCell from './TableCell';
interface Props extends HTMLAttributes<HTMLTableSectionElement> {
cells: ReactNode[];
}
const TableFooter = ({ cells = [], ...rest }: Props) => {
return (
<tfoot {...rest}>
<tr>
{cells.map((cell, index) => (
<TableCell key={index.toString()}>{cell}</TableCell>
))}
</tr>
</tfoot>
);
};
export default TableFooter;
| 5,637
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/table/TableHeader.tsx
|
import { HTMLAttributes, ReactNode } from 'react';
import Cell from './Cell';
import TableCell from './TableCell';
interface Props extends HTMLAttributes<HTMLTableSectionElement> {
cells?: (Cell | ReactNode)[];
children?: ReactNode;
}
const TableHeader = ({ cells = [], children, ...rest }: Props) => {
return (
<thead {...rest}>
{children || (
<tr>
{cells.map((cell, index) => (
<TableCell key={index.toString()} type="header">
{cell}
</TableCell>
))}
</tr>
)}
</thead>
);
};
export default TableHeader;
| 5,638
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/table/TableHeaderCell.scss
|
.table-header-cell-hover {
// Make the background hover fill the header row nicely.
padding: 0.5em;
margin: -0.5em;
&:hover {
background-color: var(--interaction-default-hover);
border-radius: var(--border-radius-md);
}
}
| 5,639
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/table/TableHeaderCell.tsx
|
import { ReactNode, ThHTMLAttributes } from 'react';
import { SORT_DIRECTION } from '@proton/shared/lib/constants';
import { Icon } from '../icon';
import { Loader } from '../loader';
import './TableHeaderCell.scss';
interface Props extends ThHTMLAttributes<HTMLTableCellElement> {
children?: ReactNode;
direction?: SORT_DIRECTION;
isLoading?: boolean;
onSort?: () => void;
}
const TableHeaderCell = ({ children, direction, isLoading, onSort, ...rest }: Props) => {
const content = onSort ? (
<div className="flex-nowrap inline-flex-vcenter cursor-pointer table-header-cell-hover" onClick={onSort}>
<span className="mr-1">{children}</span>
{direction && (
<Icon
name="arrow-up"
size={16}
className={`mr-1 flex-item-noshrink ${direction === SORT_DIRECTION.ASC ? '' : 'rotateX-180'}`}
/>
)}
{isLoading && <Loader className="flex flex-item-noshrink" />}
</div>
) : (
children
);
return (
<th scope="col" {...rest}>
{content}
</th>
);
};
export default TableHeaderCell;
| 5,640
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/table/TableRow.tsx
|
import { HTMLAttributes, ReactNode, forwardRef } from 'react';
import Cell from './Cell';
import TableCell from './TableCell';
interface Props extends HTMLAttributes<HTMLTableRowElement> {
labels?: ReactNode[];
cells?: (Cell | ReactNode)[];
children?: ReactNode;
}
const TableRow = forwardRef<HTMLTableRowElement, Props>(({ labels = [], cells = [], children, ...rest }, ref) => {
return (
<tr ref={ref} {...rest} role="row">
{children ||
cells.map((cell, index) => (
<TableCell
key={index.toString()}
label={labels[index]}
colSpan={cell instanceof Cell ? cell.colSpan : undefined}
rowSpan={cell instanceof Cell ? cell.rowSpan : undefined}
>
{cell instanceof Cell ? cell.content : cell}
</TableCell>
))}
</tr>
);
});
export default TableRow;
TableRow.displayName = 'TableRow';
| 5,641
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/table/TableRowBusy.tsx
|
import { ComponentPropsWithoutRef } from 'react';
import { CircleLoader } from '@proton/atoms';
interface Props extends ComponentPropsWithoutRef<'tr'> {
colSpan?: number;
}
const TableRowBusy = ({ colSpan, ...rest }: Props) => (
<tr aria-busy="true" {...rest}>
<td colSpan={colSpan}>
<div className="w-full text-center">
<CircleLoader />
</div>
</td>
</tr>
);
export default TableRowBusy;
| 5,642
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/table/TableRowSticky.tsx
|
import { DetailedHTMLProps, HTMLAttributes, ReactNode, RefObject, useEffect, useState } from 'react';
import clsx from '@proton/utils/clsx';
interface Props<T> extends DetailedHTMLProps<HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement> {
scrollAreaRef: RefObject<T>;
children: ReactNode;
}
function TableRowSticky<T extends HTMLElement>({ children, scrollAreaRef, className, ...rest }: Props<T>) {
const [isScrollTop, setScrollTop] = useState(true);
useEffect(() => {
const el = scrollAreaRef.current;
if (!el) {
return;
}
const onScroll = () => {
const isTopReached = el.scrollTop === 0;
if (isTopReached !== isScrollTop) {
setScrollTop(isTopReached);
}
};
onScroll();
el.addEventListener('scroll', onScroll);
return () => {
el.removeEventListener('scroll', onScroll);
};
}, [scrollAreaRef.current, isScrollTop]);
return (
<tr
{...rest}
className={clsx([
'simple-table-sticky-row',
isScrollTop && 'simple-table-sticky-row--is-on-top',
className,
])}
>
{children}
</tr>
);
}
export default TableRowSticky;
| 5,643
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/table/index.ts
|
export { default as Cell } from './Cell';
export { default as Table } from './Table';
export { default as TableCell } from './TableCell';
export { default as TableHeader } from './TableHeader';
export { default as TableFooter } from './TableFooter';
export { default as TableRow } from './TableRow';
export { default as TableBody } from './TableBody';
export { default as TableRowSticky } from './TableRowSticky';
export { default as TableRowBusy } from './TableRowBusy';
export { default as TableHeaderCell } from './TableHeaderCell';
export { default as TableCellBusy } from './TableCellBusy';
export * from './SortingTableHeader';
| 5,644
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/tabs/Tabs.tsx
|
import { ReactNode, useEffect, useRef, useState } from 'react';
import { equivalentReducer } from '@proton/components/hooks/useElementRect';
import clsx from '@proton/utils/clsx';
import debounce from '@proton/utils/debounce';
import useRightToLeft from '../../containers/rightToLeft/useRightToLeft';
import { Tab } from './index.d';
const toKey = (index: number, prefix = '') => `${prefix}${index}`;
interface Props {
tabs?: Tab[];
gap?: ReactNode;
children?: Tab[];
value: number;
onChange: (index: number) => void;
/**
* Will make tabs stick to the top of the container when overflowing
*/
stickyTabs?: boolean;
/**
* Tabs will take the maximum width and divide equally
*/
fullWidth?: boolean;
className?: string;
containerClassName?: string;
navContainerClassName?: string;
contentClassName?: string;
}
export const Tabs = ({
value,
onChange,
tabs,
gap,
children,
stickyTabs = false,
fullWidth = false,
className,
containerClassName,
navContainerClassName,
contentClassName,
}: Props) => {
const key = toKey(value, 'key_');
const label = toKey(value, 'label_');
const tabList = tabs || children || [];
const content = tabList[value]?.content;
const containerRef = useRef<HTMLUListElement>(null);
const [selectedTabEl, setSelectedTabEl] = useState<HTMLLIElement | null>(null);
const [selectedTabRect, setSelectedTabRect] = useState<DOMRect | undefined>(undefined);
const [containerTabRect, setContainerTabRect] = useState<DOMRect | undefined>(undefined);
const [isRTL] = useRightToLeft();
const scale = (selectedTabRect?.width || 0) / (containerTabRect?.width || 1);
const offset = (isRTL ? -1 : 1) * Math.abs((selectedTabRect?.x || 0) - (containerTabRect?.x || 0));
const translate = `${offset}px`;
useEffect(() => {
const containerTabEl = containerRef.current;
if (!containerTabEl || !selectedTabEl) {
return;
}
const handleResize = () => {
const selectedTabRect = selectedTabEl.getBoundingClientRect();
const containerTabRect = containerTabEl.getBoundingClientRect();
setSelectedTabRect((old) => equivalentReducer(old, selectedTabRect));
setContainerTabRect((old) => equivalentReducer(old, containerTabRect));
};
const debouncedHandleResize = debounce(handleResize, 100);
const resizeObserver = new ResizeObserver(debouncedHandleResize);
resizeObserver.observe(containerTabEl, { box: 'border-box' });
resizeObserver.observe(selectedTabEl, { box: 'border-box' });
// Resize event listener is meant to update for if the left coordinate changes (without size changing)
window.addEventListener('resize', debouncedHandleResize);
handleResize();
return () => {
debouncedHandleResize.cancel();
window.removeEventListener('resize', debouncedHandleResize);
resizeObserver.disconnect();
};
// tabs.title.join is meant to cover if the tabs would dynamically change
}, [containerRef.current, selectedTabEl, tabs?.map((tab) => tab.title).join('')]);
if (tabs?.length === 1) {
return <>{content}</>;
}
return (
<div className={clsx(['tabs', className])}>
<div className={clsx([navContainerClassName, stickyTabs && 'sticky-top bg-norm'])}>
<nav className={clsx(['tabs-container border-bottom border-weak', containerClassName])}>
<ul
className={clsx([
'tabs-list unstyled flex relative m-0 p-0',
fullWidth && 'tabs-list--fullWidth',
'flex-align-items-end',
])}
role="tablist"
ref={containerRef}
style={{ '--translate': translate, '--scale': scale }}
>
{tabList.map(({ title }, index) => {
const key = toKey(index, 'key_');
const label = toKey(index, 'label_');
const selected = value === index;
return (
<li
key={key}
className="tabs-list-item"
role="presentation"
ref={selected ? setSelectedTabEl : undefined}
>
<button
onClick={(event) => {
event.stopPropagation();
event.preventDefault();
onChange(index);
}}
type="button"
className="tabs-list-link flex flex-justify-center relative text-semibold"
id={label}
role="tab"
aria-controls={key}
tabIndex={0}
aria-selected={selected}
data-testid={`tab-header-${title}-button`}
>
{title}
</button>
</li>
);
})}
<li className="tabs-indicator" aria-hidden />
</ul>
</nav>
</div>
{gap}
<div
id={key}
className={clsx(['tabs-tabcontent pt-4', contentClassName])}
role="tabpanel"
aria-labelledby={label}
>
{content}
</div>
</div>
);
};
export default Tabs;
| 5,645
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/tabs/index.d.ts
|
import { ReactNode } from 'react';
export interface Tab {
title: string;
content?: ReactNode;
}
| 5,646
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/tabs/index.ts
|
export { default as Tabs } from './Tabs';
| 5,647
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/text/EnDash.tsx
|
const EnDash = () => <span className="mx-2">–</span>;
export default EnDash;
| 5,648
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/text/ErrorZone.tsx
|
import { ReactNode } from 'react';
import clsx from '@proton/utils/clsx';
interface Props {
children: ReactNode;
id?: string;
className?: string;
}
const ErrorZone = ({ children, id, className }: Props) => {
return (
<div className={clsx(['color-danger error-zone', className])} id={id}>
{children}
</div>
);
};
export default ErrorZone;
| 5,649
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/text/Mark.test.tsx
|
import { render } from '@testing-library/react';
import Mark from './Mark';
describe('Mark component', () => {
const input = `Eh, toi, l'ours mal léché`;
it('should highlight several matches', () => {
const result = render(<Mark value="e">{input}</Mark>);
const container = result.container;
const nodes = container.querySelectorAll('mark');
expect(nodes.length).toBe(3);
});
it('should highlight accent and capitalized matches', () => {
const result = render(<Mark value="e">{input}</Mark>);
const container = result.container;
const nodes = container.querySelectorAll('mark');
expect(nodes[0].textContent).toBe('E');
expect(nodes[1].textContent).toBe('é');
expect(nodes[2].textContent).toBe('é');
});
it('should highlight print result properly', () => {
const result = render(<Mark value="e">{input}</Mark>);
const container = result.container;
expect(container.innerHTML).toBe(
`<mark class="is-light">E</mark><span>h, toi, l'ours mal l</span><mark class="is-light">é</mark><span>ch</span><mark class="is-light">é</mark>`
);
});
it('should return original children if no match', () => {
const { container } = render(<Mark value="orage">{input}</Mark>);
expect(container.innerHTML).toBe(input);
});
it('should return original children if value empty', () => {
const { container } = render(<Mark value="">{input}</Mark>);
expect(container.innerHTML).toBe(input);
});
it('should return original children if children not a string', () => {
const { container } = render(
<Mark value="orage">
<input />
</Mark>
);
expect(container.innerHTML).toBe('<input>');
});
it('should preserve spacing between highlighted matches', () => {
const text = 'Créer un nouveau dossier';
const { container } = render(<Mark value="n">{text}</Mark>);
expect(container.innerHTML).toBe(
`<span>Créer u</span><mark class="is-light">n</mark><span> </span><mark class="is-light">n</mark><span>ouveau dossier</span>`
);
});
});
| 5,650
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/text/Mark.tsx
|
import { ReactNode, memo } from 'react';
import { escapeRegex, getMatches } from '@proton/shared/lib/helpers/regex';
import { normalize } from '@proton/shared/lib/helpers/string';
import Marks from './Marks';
interface Props {
children?: ReactNode;
value?: string;
}
const Mark = ({ children: text, value: search }: Props) => {
if (!search || typeof text !== 'string') {
return <>{text}</>;
}
const normalizedSearchText = normalize(search, true);
const normalizedText = normalize(text, true);
const regex = new RegExp(escapeRegex(normalizedSearchText), 'gi');
const chunks = getMatches(regex, normalizedText);
return <Marks chunks={chunks}>{text}</Marks>;
};
export default memo(Mark);
| 5,651
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/text/Marks.tsx
|
import { MatchChunk } from '@proton/shared/lib/helpers/regex';
interface Chunk {
start: number;
end: number;
highlight: boolean;
}
const fillInChunks = (chunksToHighlight: Chunk[], totalLength: number) => {
const allChunks: Chunk[] = [];
const append = (start: number, end: number, highlight: boolean) => {
if (end - start > 0) {
allChunks.push({
start,
end,
highlight,
});
}
};
if (chunksToHighlight.length === 0) {
append(0, totalLength, false);
} else {
let lastIndex = 0;
chunksToHighlight.forEach((chunk) => {
append(lastIndex, chunk.start, false);
append(chunk.start, chunk.end, true);
lastIndex = chunk.end;
});
append(lastIndex, totalLength, false);
}
return allChunks;
};
const combineChunks = (chunks: MatchChunk[]) => {
return chunks
.sort((first, second) => first.start - second.start)
.reduce<Chunk[]>((processedChunks, nextChunk) => {
// First chunk just goes straight in the array
if (processedChunks.length === 0) {
return [{ ...nextChunk, highlight: false }];
}
// Subsequent chunks get checked to see if they overlap
const prevChunk = processedChunks.pop();
if (!prevChunk) {
return processedChunks;
}
if (nextChunk.start <= prevChunk.end) {
// It may be the case that prevChunk completely surrounds nextChunk, so take the largest of the end indeces.
const endIndex = Math.max(prevChunk.end, nextChunk.end);
processedChunks.push({ start: prevChunk.start, end: endIndex, highlight: false });
} else {
processedChunks.push(prevChunk, { ...nextChunk, highlight: false });
}
return processedChunks;
}, []);
};
interface Props {
children: string;
chunks: MatchChunk[];
}
const Marks = ({ children: text, chunks }: Props) => {
if (!chunks.length) {
return <>{text}</>;
}
const highlightedChunks = fillInChunks(combineChunks(chunks), text.length);
return (
<>
{highlightedChunks.map(({ start, end, highlight }) => {
const insert = text.substring(start, end);
const key = `${start}-${end}`;
return highlight ? (
<mark key={key} className="is-light">
{insert}
</mark>
) : (
<span key={key}>{insert}</span>
);
})}
</>
);
};
export default Marks;
| 5,652
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/text/Preformatted.tsx
|
import { HTMLAttributes } from 'react';
import clsx from '@proton/utils/clsx';
const Preformatted = ({ className = '', ...rest }: HTMLAttributes<HTMLPreElement>) => {
return <pre className={clsx(['bg-weak p-4 mb-4 scroll-if-needed', className])} {...rest} />;
};
export default Preformatted;
| 5,653
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/text/index.ts
|
export { default as ErrorZone } from './ErrorZone';
export { default as Mark } from './Mark';
export { default as Marks } from './Marks';
export { default as Preformatted } from './Preformatted';
export { default as EnDash } from './EnDash';
| 5,654
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/time/Time.test.js
|
import { render } from '@testing-library/react';
import { readableTime } from '@proton/shared/lib/helpers/time';
import Time from './Time';
describe('Time component', () => {
const unixDate = 1552897937;
it('should handle default when time is not set', () => {
const { container } = render(<Time />);
expect(container.firstChild.textContent).toBe('Jan 1, 1970');
});
it('should display time', () => {
const { container } = render(<Time>{unixDate}</Time>);
expect(container.firstChild.textContent).toBe(readableTime(unixDate));
});
it('should support format', () => {
const { container } = render(<Time format="PPp">{unixDate}</Time>);
expect(container.firstChild.textContent).toBe(
readableTime(unixDate, {
format: 'PPp',
})
);
});
it('should support format forcing', () => {
const todayUnixDate = Math.floor(Date.now() / 1000);
const { container } = render(
<Time format="PP" sameDayFormat="PP">
{todayUnixDate}
</Time>
);
expect(container.firstChild.textContent).toBe(
readableTime(todayUnixDate, {
format: 'PP',
sameDayFormat: 'PP',
})
);
});
it('should support format forcing (sameDayFormat={false})', () => {
const todayUnixDate = Math.floor(Date.now() / 1000);
const { container } = render(
<Time format="PP" sameDayFormat={false}>
{todayUnixDate}
</Time>
);
expect(container.firstChild.textContent).toBe(
readableTime(todayUnixDate, {
format: 'PP',
sameDayFormat: 'PP',
})
);
});
});
| 5,655
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/time/Time.tsx
|
import { HTMLAttributes } from 'react';
import { Options, readableTime } from '@proton/shared/lib/helpers/time';
import { dateLocale } from '@proton/shared/lib/i18n';
const getValue = (value?: string | number | null) => {
if (typeof value === 'string') {
const numberValue = parseInt(value, 10);
if (!Number.isNaN(numberValue)) {
return numberValue;
}
}
if (typeof value === 'number') {
return value;
}
return 0;
};
interface Props extends HTMLAttributes<HTMLTimeElement> {
children?: string | number | null;
sameDayFormat?: Options['sameDayFormat'];
format?: Options['format'];
options?: Options;
}
const Time = ({ children, sameDayFormat, format, options, ...rest }: Props) => {
return (
<time {...rest}>
{readableTime(getValue(children), { locale: dateLocale, sameDayFormat, format, ...options })}
</time>
);
};
export default Time;
| 5,656
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/time/TimeIntl.test.tsx
|
import { render } from '@testing-library/react';
import { fromUnixTime, getUnixTime } from 'date-fns';
import { readableTimeIntl } from '@proton/shared/lib/helpers/time';
import { dateLocale } from '@proton/shared/lib/i18n';
import TimeIntl from './TimeIntl';
jest.mock('@proton/shared/lib/i18n', () => ({
dateLocale: {
code: 'en-US',
formatLong: {
time: jest.fn(),
},
},
}));
const mockedFormatLongTime = jest.mocked(dateLocale.formatLong!.time).mockReturnValue('h:mm:ss a zzzz');
describe('TimeIntl component', () => {
const unixDate = 1552897937;
it('should handle default when time is not set', () => {
const { container } = render(<TimeIntl />);
expect(container.firstChild?.textContent).toBe('Jan 1, 1970');
});
it('should display time if same day', () => {
jest.useFakeTimers().setSystemTime(fromUnixTime(unixDate));
const { container } = render(<TimeIntl>{unixDate}</TimeIntl>);
expect(container.firstChild?.textContent).toBe(
readableTimeIntl(unixDate, {
hour12: true,
intlOptions: {
hour: 'numeric',
minute: 'numeric',
},
})
);
jest.useRealTimers();
});
it('should display time with AM/PM if b is present in date-fns time format', () => {
jest.useFakeTimers().setSystemTime(fromUnixTime(unixDate));
mockedFormatLongTime.mockReturnValueOnce('h:mm:ss b zzzz');
const { container } = render(<TimeIntl>{unixDate}</TimeIntl>);
expect(container.firstChild?.textContent).toBe(
readableTimeIntl(unixDate, {
hour12: true,
intlOptions: {
hour: 'numeric',
minute: 'numeric',
},
})
);
jest.useRealTimers();
});
it('should support Intl options', () => {
const options: Intl.DateTimeFormatOptions = {
hour: 'numeric',
minute: 'numeric',
month: 'short',
day: 'numeric',
year: 'numeric',
};
const { container } = render(<TimeIntl options={options}>{unixDate}</TimeIntl>);
expect(container.firstChild?.textContent).toBe(
readableTimeIntl(unixDate, {
intlOptions: options,
hour12: true,
})
);
});
it('should support Intl options forcing', () => {
const todayUnixDate = Math.floor(Date.now() / 1000);
const options: Intl.DateTimeFormatOptions = {
month: 'short',
day: 'numeric',
year: 'numeric',
};
const sameDayOptions: Intl.DateTimeFormatOptions = {
month: 'short',
day: 'numeric',
year: 'numeric',
};
const { container } = render(
<TimeIntl options={options} sameDayOptions={sameDayOptions}>
{todayUnixDate}
</TimeIntl>
);
expect(container.firstChild?.textContent).toBe(
readableTimeIntl(todayUnixDate, {
intlOptions: options,
sameDayIntlOptions: sameDayOptions,
})
);
});
it('should support Intl options forcing (sameDayOptions={false})', () => {
const todayUnixDate = Math.floor(Date.now() / 1000);
const options: Intl.DateTimeFormatOptions = {
month: 'short',
day: 'numeric',
year: 'numeric',
};
const { container } = render(
<TimeIntl options={options} sameDayOptions={false}>
{todayUnixDate}
</TimeIntl>
);
expect(container.firstChild?.textContent).toBe(
readableTimeIntl(todayUnixDate, {
intlOptions: options,
sameDayIntlOptions: options,
})
);
});
it('should support 24hour date format', () => {
mockedFormatLongTime.mockReturnValueOnce('h:mm:ss zzzz');
const todayUnixDate = Math.floor(Date.now() / 1000);
const { container } = render(<TimeIntl>{todayUnixDate}</TimeIntl>);
expect(container.firstChild?.textContent).toBe(readableTimeIntl(todayUnixDate, { hour12: false }));
});
it('should support date as children', () => {
const date = new Date('2023-03-22');
const { container } = render(<TimeIntl>{date}</TimeIntl>);
expect(container.firstChild?.textContent).toBe(readableTimeIntl(getUnixTime(date)));
});
});
| 5,657
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/time/TimeIntl.tsx
|
import { HTMLAttributes } from 'react';
import { getUnixTime } from 'date-fns';
import { OptionsWithIntl, readableTimeIntl } from '@proton/shared/lib/helpers/time';
import { dateLocale } from '@proton/shared/lib/i18n';
const getValue = (value?: string | number | Date | null) => {
if (value instanceof Date) {
return getUnixTime(value);
}
if (typeof value === 'string') {
const numberValue = parseInt(value, 10);
if (!Number.isNaN(numberValue)) {
return numberValue;
}
}
if (typeof value === 'number') {
return value;
}
return 0;
};
interface Props extends HTMLAttributes<HTMLTimeElement> {
children?: string | number | Date | null;
localeCode?: string;
sameDayOptions?: OptionsWithIntl['sameDayIntlOptions'];
options?: OptionsWithIntl['intlOptions'];
}
// Current dateLocale is based on date-fns and
// the only way to get TimeFormat for now is to check date-fns time format
// If an 'a' or 'b' is present in the format string it will be 12H TimeFormat
const is12HourDateFnsFormat = (formatString: string) => {
const regex = /a|b/;
return regex.test(formatString);
};
const TimeIntl = ({ children, sameDayOptions, options, ...rest }: Props) => {
const time = getValue(children);
const ISOTime = new Date(time * 1000).toISOString();
return (
<time dateTime={ISOTime} {...rest}>
{readableTimeIntl(time, {
localeCode: dateLocale.code,
hour12: is12HourDateFnsFormat(dateLocale.formatLong?.time()),
sameDayIntlOptions: sameDayOptions,
intlOptions: options,
})}
</time>
);
};
export default TimeIntl;
| 5,658
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/time/index.ts
|
export { default as Time } from './Time';
export { default as TimeIntl } from './TimeIntl';
| 5,659
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/timezoneSelector/TimeZoneSelector.tsx
|
import { useMemo, useState } from 'react';
import { c } from 'ttag';
import { TelemetryCalendarEvents, TelemetryMeasurementGroups } from '@proton/shared/lib/api/telemetry';
import {
AbbreviatedTimezone,
getAbbreviatedTimezoneName,
getTimeZoneOptions,
getTimezoneAndOffset,
} from '@proton/shared/lib/date/timezone';
import { sendTelemetryReport } from '@proton/shared/lib/helpers/metrics';
import { SimpleMap } from '@proton/shared/lib/interfaces';
import { useApi } from '../../hooks';
import { DropdownSizeUnit } from '../dropdown';
import { Unit } from '../dropdown/utils';
import { Option } from '../option';
import { SearchableSelect } from '../selectTwo';
import { Props as SearchableSelectProps } from '../selectTwo/SearchableSelect';
import { Props as SelectProps } from '../selectTwo/SelectTwo';
import { Tooltip } from '../tooltip';
interface Props extends Omit<SelectProps<string>, 'onChange' | 'children'> {
timezone?: string;
onChange: (tzid: string) => void;
className?: string;
defaultTimezone?: string;
disabled?: boolean;
date?: Date;
loading?: boolean;
telemetrySource?: string;
abbreviatedTimezone?: AbbreviatedTimezone;
unstyledSelect?: boolean;
selectMaxHeight?: DropdownSizeUnit.Viewport | Unit;
tooltip?: boolean;
}
export const TimeZoneSelector = ({
loading = false,
disabled = false,
telemetrySource,
date,
timezone,
onChange,
abbreviatedTimezone,
unstyledSelect,
selectMaxHeight,
tooltip = false,
...rest
}: Props) => {
const api = useApi();
const [selectIsOpen, setSelectIsOpen] = useState(false);
const timezoneOptions = useMemo(() => {
const options = getTimeZoneOptions(date || new Date());
return options.map(({ text, value, key }) => <Option key={key} value={value} title={text} />);
}, [date]);
const handleChange = ({ value }: { value: string }) => {
if (telemetrySource) {
const dimensions: SimpleMap<string> = {
timezone_from: timezone,
timezone_to: value,
source: telemetrySource,
};
void sendTelemetryReport({
api,
measurementGroup: TelemetryMeasurementGroups.calendarTimeZoneSelector,
event: TelemetryCalendarEvents.change_temporary_time_zone,
dimensions,
});
}
onChange(value);
};
const searchableSelectProps: SearchableSelectProps<string> = {
disabled: loading || disabled,
title: c('Action').t`Select time zone`,
value: timezone,
onChange: handleChange,
onOpen: () => setSelectIsOpen(true),
onClose: () => setSelectIsOpen(false),
search: true,
searchPlaceholder: c('Timezone search placeholder').t`Search time zones`,
size: {
width: DropdownSizeUnit.Dynamic,
height: DropdownSizeUnit.Dynamic,
maxHeight: selectMaxHeight ? selectMaxHeight : undefined,
},
unstyled: unstyledSelect,
renderSelected: () =>
abbreviatedTimezone ? getAbbreviatedTimezoneName(abbreviatedTimezone, timezone) : undefined,
originalPlacement: 'bottom-start',
...rest,
children: timezoneOptions,
};
return (
<>
{tooltip ? (
<Tooltip title={getTimezoneAndOffset(timezone || '')} isOpen={selectIsOpen ? false : undefined}>
<div>
<SearchableSelect {...searchableSelectProps} />
</div>
</Tooltip>
) : (
<SearchableSelect {...searchableSelectProps} />
)}
</>
);
};
export default TimeZoneSelector;
| 5,660
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/timezoneSelector/index.ts
|
export * from './TimeZoneSelector';
| 5,661
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/title/SubTitle.tsx
|
import { HTMLAttributes } from 'react';
export type SubTitleProps = HTMLAttributes<HTMLHeadingElement>;
const SubTitle = ({ children, ...rest }: SubTitleProps) => <h2 {...rest}>{children}</h2>;
export default SubTitle;
| 5,662
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/title/Title.tsx
|
import { HTMLAttributes } from 'react';
const Title = ({ children, ...rest }: HTMLAttributes<HTMLHeadingElement>) => <h1 {...rest}>{children}</h1>;
export default Title;
| 5,663
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/title/index.ts
|
export { default as SubTitle } from './SubTitle';
export { default as Title } from './Title';
| 5,664
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/toggle/Toggle.test.js
|
import { fireEvent, render } from '@testing-library/react';
import Toggle from './Toggle';
describe('Toggle component', () => {
const id = 'pref';
const getInput = (container) => container.querySelector('.toggle-checkbox');
it('should be checked', () => {
const mockOnChange = jest.fn();
const { container } = render(<Toggle id={id} checked onChange={mockOnChange} />);
const inputNode = getInput(container);
expect(inputNode.checked).toBeTruthy();
});
it('should be unchecked', () => {
const mockOnChange = jest.fn();
const { container } = render(<Toggle id={id} checked={false} onChange={mockOnChange} />);
const inputNode = getInput(container);
expect(inputNode.checked).toBeFalsy();
});
it('should call onChange', () => {
const mockOnChange = jest.fn();
const { container } = render(<Toggle id={id} checked={false} onChange={mockOnChange} />);
expect(mockOnChange).toHaveBeenCalledTimes(0);
fireEvent.click(container.firstChild);
expect(mockOnChange).toHaveBeenCalledTimes(1);
});
it("should not call onChange since it's disabled", () => {
const mockOnChange = jest.fn();
const { container } = render(<Toggle id={id} checked={false} disabled onChange={mockOnChange} />);
fireEvent.click(container.firstChild);
expect(mockOnChange).toHaveBeenCalledTimes(0);
});
});
| 5,665
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/toggle/Toggle.tsx
|
import { ChangeEvent, DetailedHTMLProps, InputHTMLAttributes, Ref, forwardRef } from 'react';
import { CircleLoader } from '@proton/atoms';
import clsx from '@proton/utils/clsx';
import Icon, { IconName } from '../icon/Icon';
export interface ToggleProps extends DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> {
loading?: boolean;
}
const Toggle = (
{
id = 'toggle',
className = '',
checked = false,
loading = false,
onChange,
disabled,
title,
children,
...rest
}: ToggleProps,
ref: Ref<HTMLInputElement>
) => {
const handleChange = (event: ChangeEvent<HTMLInputElement>) => {
if (!disabled && onChange) {
onChange(event);
}
};
const label = (name: IconName, condition: boolean) => {
return (
<span className="toggle-container-text" aria-hidden="true">
<Icon name={name} alt="" size={16} className="toggle-container-img" />
{condition && (
<span className="toggle-container-loader">
<CircleLoader />
</span>
)}
</span>
);
};
return (
<label
className={clsx([
children ? 'flex flex-align-items-center flex-nowrap gap-2' : '',
'toggle-label',
className,
])}
htmlFor={id}
title={title}
>
<div
className={clsx([
'toggle-container',
disabled && 'toggle-container--disabled',
checked && 'toggle-container--checked',
loading && 'toggle-container--loading',
])}
>
<input
disabled={loading || disabled}
id={id}
onChange={handleChange}
type="checkbox"
className={clsx(['toggle-checkbox sr-only', className])}
checked={checked}
aria-busy={loading}
ref={ref}
{...rest}
/>
{label('cross', loading && !checked)}
{label('checkmark', loading && checked)}
</div>
{children}
</label>
);
};
export default forwardRef<HTMLInputElement, ToggleProps>(Toggle);
| 5,666
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/toggle/index.ts
|
export { default as Toggle } from './Toggle';
| 5,667
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components/toggle
|
petrpan-code/ProtonMail/WebClients/packages/components/components/toggle/__mocks__/Toggle.tsx
|
// There is a strange behavior of the "checked" attribute of <input type="checkbox" />. It's not updated like everything
// else when "checked" boolean variable is changed. This mock works around the problem.
export default jest.fn().mockImplementation(({ id, checked, onChange, ...rest }) => {
return (
<span id={id} onClick={() => onChange(!checked)} {...rest}>
{checked ? 'CHECKED' : ''}
</span>
);
});
| 5,668
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/toolbar/Toolbar.tsx
|
import { HTMLAttributes, ReactNode } from 'react';
import { c } from 'ttag';
import clsx from '@proton/utils/clsx';
interface Props extends HTMLAttributes<HTMLDivElement> {
children?: ReactNode;
className?: string;
}
const Toolbar = ({ children, className, ...rest }: Props) => (
<nav
className={clsx(['toolbar flex flex-nowrap flex-item-noshrink no-print', className])}
aria-label={c('Label').t`Toolbar`}
{...rest}
>
<div className="flex flex-nowrap toolbar-inner w-full">{children}</div>
</nav>
);
export default Toolbar;
| 5,669
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/toolbar/ToolbarButton.tsx
|
import { ButtonHTMLAttributes, ReactElement, ReactNode, Ref, cloneElement, forwardRef } from 'react';
import clsx from '@proton/utils/clsx';
import noop from '@proton/utils/noop';
import { Tooltip } from '../tooltip';
interface Props extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'title'> {
icon?: ReactElement;
children?: ReactNode;
title?: ReactNode;
}
const ToolbarButton = (
{ icon, children, className, disabled, tabIndex, title, onClick, ...rest }: Props,
ref: Ref<HTMLButtonElement>
) => {
const content = (
<button
type="button"
className={clsx([className, 'flex flex-item-noshrink toolbar-button'])}
onClick={disabled ? noop : onClick}
tabIndex={disabled ? -1 : tabIndex}
disabled={disabled}
ref={ref}
{...rest}
>
{icon &&
cloneElement(icon, {
className: clsx([icon.props.className, 'toolbar-icon m-auto']),
})}
{children}
</button>
);
if (title) {
return <Tooltip title={title}>{content}</Tooltip>;
}
return content;
};
export default forwardRef<HTMLButtonElement, Props>(ToolbarButton);
| 5,670
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/toolbar/index.ts
|
export { default as Toolbar } from './Toolbar';
export { default as ToolbarButton } from './ToolbarButton';
| 5,671
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/tooltip/Tooltip.scss
|
@import '~@proton/styles/scss/lib';
.tooltip {
$tooltip-width: 14.5em;
$arrow-width: 0.5em;
position: fixed;
z-index: $layer-tooltips;
min-inline-size: $arrow-width;
max-inline-size: $tooltip-width;
scale: 1.001; // To avoid text jittering
border-radius: var(--border-radius-md);
background-color: var(--tooltip-background-color);
color: var(--tooltip-text-color);
padding-block: 0.5em;
padding-inline: 0.75em;
text-align: center;
word-break: break-word;
animation-fill-mode: both;
&-in-first {
animation: anime-tooltip-in-first 0.2s easing(ease-out-quart);
@keyframes anime-tooltip-in-first {
from {
scale: 0.9;
opacity: 0;
}
to {
scale: 1.001; // To avoid text jittering
opacity: 1;
}
}
}
&-in {
animation: anime-tooltip-in 0.15s easing(ease-in-quad);
@keyframes anime-tooltip-in {
from {
opacity: 0;
}
to {
opacity: 1;
}
}
}
&-out {
animation: anime-tooltip-out 0.15s easing(ease-out-quad);
@keyframes anime-tooltip-out {
from {
opacity: 1;
}
to {
opacity: 0;
}
}
}
&-out-last {
animation: anime-tooltip-out-last 0.35s easing(ease-in-expo);
@keyframes anime-tooltip-out-last {
from {
scale: 1.001; // To avoid text jittering
opacity: 1;
}
to {
scale: 0.9;
opacity: 0;
}
}
}
// colored versions
@each $color in (primary, danger, warning, success, info) {
$prefix: if($color != 'primary', 'signal-', '');
&-#{$color} {
--tooltip-background-color: var(--#{$prefix + $color});
--tooltip-text-color: var(--#{$prefix + $color}-contrast);
}
}
// Placement - no need for logical props - managed by plugins
/* stylelint-disable */
&--top-start {
border-bottom-left-radius: 0;
}
&--top-end {
border-bottom-right-radius: 0;
}
&--bottom-start {
border-top-left-radius: 0;
}
&--bottom-end {
border-top-right-radius: 0;
}
&--left-end {
border-bottom-right-radius: 0;
}
&--right-end {
border-bottom-left-radius: 0;
}
&--left-start {
border-top-right-radius: 0;
}
&--right-start {
border-top-left-radius: 0;
}
/* stylelint-enable */
/* pseudo-element to make arrows */
&::before {
content: '';
speak: none;
position: absolute;
z-index: 1;
inline-size: $arrow-width;
block-size: $arrow-width;
pointer-events: none;
border: $arrow-width solid transparent;
}
/* stylelint-disable */
&--top::before,
&--top-start::before,
&--top-end::before {
top: 100%;
border-top: $arrow-width solid var(--tooltip-background-color);
}
&--bottom::before,
&--bottom-start::before,
&--bottom-end::before {
bottom: 100%;
border-bottom: $arrow-width solid var(--tooltip-background-color);
}
&--right::before,
&--right-start::before,
&--right-end::before {
left: -#{$arrow-width * 2};
border-right: $arrow-width solid var(--tooltip-background-color);
}
&--left::before,
&--left-start::before,
&--left-end::before {
right: -#{$arrow-width * 2};
border-left: $arrow-width solid var(--tooltip-background-color);
}
&--top::before,
&--bottom::before {
left: calc(50% - #{$arrow-width});
}
&--top-start::before,
&--bottom-start::before {
left: max(calc(var(--arrow-offset, 0) - #{$arrow-width}), 0px);
}
&--top-end::before,
&--bottom-end::before {
right: max(calc(var(--arrow-offset, 0) - #{$arrow-width}), 0px);
}
&--left::before,
&--right::before {
top: calc(50% - #{$arrow-width});
}
&--left-start::before,
&--right-start::before {
top: max(calc(var(--arrow-offset, 0) - #{$arrow-width}), 0px);
}
&--left-end::before,
&--right-end::before {
bottom: max(calc(var(--arrow-offset, 0) - #{$arrow-width}), 0px);
}
/* stylelint-enable */
.kbd {
position: relative;
background-color: transparent;
color: inherit;
border-color: transparent;
&::before {
content: '';
position: absolute;
inset: 0;
background-color: var(--background-strong);
opacity: 0.2;
border-radius: var(--border-radius-sm);
}
}
}
| 5,672
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/tooltip/Tooltip.test.tsx
|
import { fireEvent, render, screen } from '@testing-library/react';
import userEvent, { UserEvent } from '@testing-library/user-event';
import Tooltip from './Tooltip';
describe('tooltip', () => {
let timerUserEvent: UserEvent;
beforeEach(() => {
jest.useFakeTimers();
timerUserEvent = userEvent.setup({ advanceTimers: jest.advanceTimersByTime });
});
afterEach(() => {
jest.runOnlyPendingTimers();
jest.useRealTimers();
});
it('should show tooltip immediately when externally opened', () => {
render(
<Tooltip title={<span data-testid="tooltip">World</span>} isOpen>
<span data-testid="span">Hello</span>
</Tooltip>
);
expect(screen.getByTestId('span')).toHaveTextContent('Hello');
expect(screen.getByTestId('tooltip')).toHaveTextContent('World');
});
it('should not show tooltip when not open', () => {
render(
<Tooltip title={<span data-testid="tooltip">World</span>} isOpen={false}>
<span data-testid="span">Hello</span>
</Tooltip>
);
expect(screen.getByTestId('span')).toHaveTextContent('Hello');
expect(screen.queryByTestId('tooltip')).toBeNull();
});
it('should not close tooltip when externally opened', async () => {
render(
<>
<Tooltip title={<span data-testid="tooltip">World</span>} isOpen>
<span data-testid="span">Hello</span>
</Tooltip>
<div data-testid="outside">hello</div>
</>
);
expect(screen.getByTestId('span')).toHaveTextContent('Hello');
expect(screen.getByTestId('tooltip')).toHaveTextContent('World');
await timerUserEvent.unhover(screen.getByTestId('span'));
await timerUserEvent.click(screen.getByTestId('outside'));
jest.advanceTimersByTime(1000);
fireEvent.animationEnd(screen.getByTestId('tooltip'), { animationName: 'anime-tooltip-out-last' });
expect(screen.getByTestId('span')).toHaveTextContent('Hello');
expect(screen.getByTestId('tooltip')).toHaveTextContent('World');
});
it('should show and hide tooltip with a delay', async () => {
render(
<Tooltip title={<span data-testid="tooltip">World</span>}>
<span data-testid="span">Hello</span>
</Tooltip>
);
expect(screen.getByTestId('span')).toHaveTextContent('Hello');
expect(screen.queryByTestId('tooltip')).toBeNull();
await timerUserEvent.hover(screen.getByTestId('span'));
expect(screen.queryByTestId('tooltip')).toBeNull();
jest.advanceTimersByTime(1000);
fireEvent.animationEnd(screen.getByTestId('tooltip'), { animationName: 'anime-tooltip-in-first' });
expect(screen.getByTestId('tooltip')).toHaveTextContent('World');
await timerUserEvent.unhover(screen.getByTestId('span'));
expect(screen.getByTestId('tooltip')).toHaveTextContent('World');
jest.advanceTimersByTime(500);
fireEvent.animationEnd(screen.getByTestId('tooltip'), { animationName: 'anime-tooltip-out-last' });
expect(screen.queryByTestId('tooltip')).toBeNull();
});
it('should show second tooltip instantly and hide tooltip with a delay', async () => {
render(
<>
<Tooltip title={<span data-testid="tooltip-1">World</span>}>
<span data-testid="span-1">Hello</span>
</Tooltip>
<Tooltip title={<span data-testid="tooltip-2">Bar</span>}>
<span data-testid="span-2">Foo</span>
</Tooltip>
</>
);
expect(screen.queryByTestId('tooltip-1')).toBeNull();
expect(screen.queryByTestId('tooltip-2')).toBeNull();
await timerUserEvent.hover(screen.getByTestId('span-1'));
expect(screen.queryByTestId('tooltip-1')).toBeNull();
expect(screen.queryByTestId('tooltip-2')).toBeNull();
jest.advanceTimersByTime(1000);
fireEvent.animationEnd(screen.getByTestId('tooltip-1'), { animationName: 'anime-tooltip-in-first' });
expect(screen.getByTestId('tooltip-1')).toHaveTextContent('World');
expect(screen.queryByTestId('tooltip-2')).toBeNull();
await timerUserEvent.unhover(screen.getByTestId('span-1'));
expect(screen.getByTestId('tooltip-1')).toHaveTextContent('World');
expect(screen.queryByTestId('tooltip-2')).toBeNull();
await timerUserEvent.hover(screen.getByTestId('span-2'));
fireEvent.animationEnd(screen.getByTestId('tooltip-1'), { animationName: 'anime-tooltip-out' });
expect(screen.queryByTestId('tooltip-1')).toBeNull();
fireEvent.animationEnd(screen.getByTestId('tooltip-2'), { animationName: 'anime-tooltip-in' });
expect(screen.getByTestId('tooltip-2')).toHaveTextContent('Bar');
await timerUserEvent.unhover(screen.getByTestId('span-2'));
jest.advanceTimersByTime(500);
expect(screen.queryByTestId('tooltip-1')).toBeNull();
fireEvent.animationEnd(screen.getByTestId('tooltip-2'), { animationName: 'anime-tooltip-out-last' });
expect(screen.queryByTestId('tooltip-2')).toBeNull();
});
});
| 5,673
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/tooltip/Tooltip.tsx
|
import {
Children,
HTMLProps,
ReactElement,
ReactNode,
Ref,
cloneElement,
forwardRef,
useCallback,
useContext,
useEffect,
useState,
} from 'react';
import { useCombinedRefs } from '@proton/hooks';
import useInstance from '@proton/hooks/useInstance';
import useIsMounted from '@proton/hooks/useIsMounted';
import clsx from '@proton/utils/clsx';
import isTruthy from '@proton/utils/isTruthy';
import { generateUID } from '../../helpers';
import { Popper, PopperPlacement, usePopper } from '../popper';
import { TooltipExclusiveContext } from './TooltipExclusive';
import useTooltipHandlers from './useTooltipHandlers';
import './Tooltip.scss';
export type TooltipType = 'info' | 'error' | 'warning';
interface Props extends Omit<HTMLProps<HTMLElement>, 'title' | 'children'> {
children: ReactElement;
title: ReactNode;
originalPlacement?: PopperPlacement;
type?: TooltipType;
anchorOffset?: { x: number; y: number };
isOpen?: boolean;
relativeReference?: Parameters<typeof usePopper>[0]['relativeReference'];
openDelay?: number;
closeDelay?: number;
longTapDelay?: number;
updateAnimationFrame?: boolean;
tooltipClassName?: string;
}
const getTooltipTypeClass = (type: TooltipType) => {
if (type === 'error') {
return 'tooltip-danger';
}
if (type === 'warning') {
return 'tooltip-warning';
}
};
const mergeCallbacks = (a: any, b: any) => {
return Object.fromEntries(
Object.entries(a).map(([key, cb]: [string, any]) => {
const otherCb = b[key];
return [
key,
otherCb
? (...args: any[]) => {
cb(...args);
otherCb(...args);
}
: cb,
];
})
);
};
interface State {
open: boolean;
position: 'first' | 'last' | 'middle';
closing: boolean;
animate: boolean;
}
const defaultState: State = { position: 'middle', open: false, closing: false, animate: false };
const getAnimateInFirst = (state: State) => {
return state.position === 'first' && state.open && !state.closing && state.animate;
};
const getAnimateOutLast = (state: State) => {
return state.position === 'last' && state.open && state.closing && state.animate;
};
const getAnimateInMiddle = (state: State) => {
return state.position === 'middle' && state.open && !state.closing && state.animate;
};
const getAnimateOutMiddle = (state: State) => {
return state.position === 'middle' && state.open && state.closing && state.animate;
};
const TooltipBase = (
{
children,
title,
originalPlacement = 'top',
type = 'info',
anchorOffset,
isOpen: isExternalOpen,
relativeReference,
openDelay,
closeDelay,
longTapDelay,
updateAnimationFrame,
tooltipClassName,
...rest
}: Props,
ref: Ref<HTMLElement>
) => {
const uid = useInstance(() => generateUID('tooltip'));
const isMounted = useIsMounted();
const [state, setState] = useState<State>(defaultState);
const open = useCallback((immediate?: boolean) => {
if (!isMounted()) {
return;
}
const first = immediate === false;
setState({ position: first ? 'first' : 'middle', animate: true, open: true, closing: false });
}, []);
const close = useCallback((immediate?: boolean) => {
if (!isMounted()) {
return;
}
const last = immediate === false;
setState({ position: last ? 'last' : 'middle', animate: true, open: true, closing: true });
}, []);
const isOpen = state.open;
const { floating, reference, position, arrow, placement } = usePopper({
isOpen,
originalPlacement,
relativeReference,
updateAnimationFrame,
});
const exclusive = useContext(TooltipExclusiveContext) || {};
const tooltipHandlers = useTooltipHandlers({
open,
close,
isOpen,
isExternalOpen,
openDelay,
closeDelay,
longTapDelay,
});
const child = Children.only(children);
// Types are wrong? Not sure why ref doesn't exist on a ReactElement
// @ts-ignore
const mergedRef = useCombinedRefs(child?.ref, reference, ref);
useEffect(() => {
if (isOpen) {
exclusive.add?.(uid);
} else {
exclusive.remove?.(uid);
}
}, [isOpen]);
if (!title) {
return cloneElement(child, {
ref: mergedRef,
...rest,
});
}
if (!child) {
return null;
}
const animateInFirst = getAnimateInFirst(state);
const animateOutLast = getAnimateOutLast(state);
const animateInMiddle = getAnimateInMiddle(state);
const animateOutMiddle = getAnimateOutMiddle(state);
return (
<>
{cloneElement(child, {
ref: mergedRef,
...rest,
...mergeCallbacks(tooltipHandlers, child.props),
'aria-describedby': [child.props['aria-describedby'], uid].filter(isTruthy).join(' '),
})}
<Popper
divRef={floating}
id={uid}
isOpen={(exclusive.last === uid || !exclusive.last) && !!title && isOpen}
style={{ ...position, ...arrow }}
onAnimationEnd={(event) => {
if (event.animationName.includes('anime-tooltip-out-last')) {
setState((oldState) => {
if (getAnimateOutLast(oldState)) {
return defaultState;
}
return oldState;
});
}
if (event.animationName.includes('anime-tooltip-out')) {
setState((oldState) => {
if (getAnimateOutMiddle(oldState)) {
return defaultState;
}
return oldState;
});
}
if (event.animationName.includes('anime-tooltip-in')) {
setState((oldState) => {
if (getAnimateInMiddle(oldState)) {
return { open: true, position: 'middle', closing: false, animate: false };
}
return oldState;
});
}
if (event.animationName.includes('anime-tooltip-in-first')) {
setState((oldState) => {
if (getAnimateInFirst(oldState)) {
return { open: true, position: 'first', closing: false, animate: false };
}
return oldState;
});
}
}}
className={clsx([
'tooltip',
animateInMiddle && 'tooltip-in',
animateOutMiddle && 'tooltip-out',
animateInFirst && `tooltip-in-first`,
animateOutLast && `tooltip-out-last`,
`tooltip--${placement}`,
getTooltipTypeClass(type),
tooltipClassName,
])}
>
{title}
</Popper>
</>
);
};
const Tooltip = forwardRef<HTMLElement, Props>(TooltipBase);
export default Tooltip;
| 5,674
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/tooltip/TooltipExclusive.tsx
|
import { ReactNode, createContext, useState } from 'react';
import lastItem from '@proton/utils/lastItem';
import arrayRemove from '@proton/utils/remove';
interface TooltipExclusiveContextValue {
last?: string;
add: (id: string) => void;
remove: (id: string) => void;
}
export const TooltipExclusiveContext = createContext<TooltipExclusiveContextValue>({} as TooltipExclusiveContextValue);
const TooltipExclusive = ({ children }: { children: ReactNode }) => {
const [tooltips, setTooltips] = useState<string[]>([]);
const remove = (id: string) => {
setTooltips((prev) => arrayRemove(prev, id));
};
const add = (id: string) => {
setTooltips((prev) => [...prev, id]);
};
return (
<TooltipExclusiveContext.Provider value={{ last: lastItem(tooltips), add, remove }}>
{children}
</TooltipExclusiveContext.Provider>
);
};
export default TooltipExclusive;
| 5,675
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/tooltip/index.ts
|
export * from './Tooltip';
export { default as Tooltip } from './Tooltip';
export { default as TooltipExclusive } from './TooltipExclusive';
| 5,676
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/tooltip/useTooltipHandlers.ts
|
import { MutableRefObject, useEffect, useRef } from 'react';
import usePrevious from '@proton/hooks/usePrevious';
const LONG_TAP_TIMEOUT = 500;
const OPEN_DELAY_TIMEOUT = 1000;
const CLOSE_DELAY_TIMEOUT = 250;
let visibleTimeout = 0;
let globalId = 0;
enum State {
Opened,
Closing,
}
type CloseCb = (immediate?: boolean) => void;
type OpenCb = (immediate?: boolean) => void;
const tooltips = new Map<number, { state: State; close: MutableRefObject<CloseCb> }>();
const closePendingTooltips = () => {
for (let [id, entry] of tooltips) {
if (entry.state === State.Closing) {
entry.close.current();
tooltips.delete(id);
}
}
};
interface Props {
open: OpenCb;
close: CloseCb;
isOpen: boolean;
isExternalOpen?: boolean;
openDelay?: number;
closeDelay?: number;
longTapDelay?: number;
}
const useTooltipHandlers = ({
open: outsideOpen,
close: outsideClose,
isOpen,
isExternalOpen,
openDelay = OPEN_DELAY_TIMEOUT,
closeDelay = CLOSE_DELAY_TIMEOUT,
longTapDelay = LONG_TAP_TIMEOUT,
}: Props) => {
const idRef = useRef(-1);
if (idRef.current === -1) {
idRef.current = ++globalId;
}
const id = idRef.current;
const closeTimeoutRef = useRef(0);
const longTapTimeoutRef = useRef(0);
const ignoreFocusRef = useRef(false);
const ignoreNonTouchEventsRef = useRef(false);
const ignoreNonTouchEventsTimeoutRef = useRef(0);
const closeRef = useRef(outsideClose);
const openRef = useRef(outsideOpen);
const wasExternallyOpened = usePrevious(isExternalOpen);
useEffect(() => {
const entry = tooltips.get(id);
if (!entry) {
return;
}
closeRef.current = outsideClose;
openRef.current = outsideOpen;
});
useEffect(() => {
return () => {
window.clearTimeout(closeTimeoutRef.current);
window.clearTimeout(longTapTimeoutRef.current);
window.clearTimeout(ignoreNonTouchEventsTimeoutRef.current);
tooltips.get(id)?.close.current();
tooltips.delete(id);
};
}, [id]);
const open = (immediate?: boolean) => {
window.clearTimeout(visibleTimeout);
window.clearTimeout(closeTimeoutRef.current);
const oldTooltip = tooltips.get(id);
tooltips.set(id, { state: State.Opened, close: closeRef });
if (oldTooltip?.state === State.Closing) {
return;
}
closePendingTooltips();
openRef.current(immediate);
};
const close = () => {
window.clearTimeout(visibleTimeout);
// Trying to close something that isn't open.
if (tooltips.get(id)?.state !== State.Opened) {
return;
}
window.clearTimeout(closeTimeoutRef.current);
if (!closeDelay) {
outsideClose();
tooltips.delete(id);
return;
}
tooltips.set(id, { state: State.Closing, close: closeRef });
closeTimeoutRef.current = window.setTimeout(() => {
const entry = tooltips.get(id);
if (entry?.state === State.Closing) {
entry.close.current(false);
tooltips.delete(id);
}
}, closeDelay);
};
const handleCloseTooltip = () => {
window.clearTimeout(longTapTimeoutRef.current);
longTapTimeoutRef.current = 0;
window.clearTimeout(ignoreNonTouchEventsTimeoutRef.current);
// Clear non-touch events after a small timeout to avoid the focus event accidentally triggering it after touchend
// touchstart -> touchend -> focus
ignoreNonTouchEventsTimeoutRef.current = window.setTimeout(() => {
ignoreNonTouchEventsRef.current = false;
}, 100);
close();
};
useEffect(() => {
if (!isOpen) {
return;
}
// Edge case for elements that don't gain focus, they'll never receive a blur event to close the tooltip
// for example if long-tapping a span with text, this is to force close the tooltip on next touchstart
document.addEventListener('touchstart', close);
return () => {
document.removeEventListener('touchstart', close);
};
}, [isOpen, close]);
const handleTouchStart = () => {
window.clearTimeout(ignoreNonTouchEventsTimeoutRef.current);
ignoreNonTouchEventsTimeoutRef.current = 0;
window.clearTimeout(longTapTimeoutRef.current);
// Initiate a long-tap timer to open the tooltip on touch devices
longTapTimeoutRef.current = window.setTimeout(() => {
open();
longTapTimeoutRef.current = 0;
}, longTapDelay);
// Also set to ignore non-touch events
ignoreNonTouchEventsRef.current = true;
};
const handleTouchEnd = () => {
// Tooltip was opened from a long tap, no need to close
if (isOpen && !longTapTimeoutRef.current) {
return;
}
// Otherwise it's either not opened or it wasn't opened from the long tap, so we can set to close the tooltip
window.clearTimeout(longTapTimeoutRef.current);
longTapTimeoutRef.current = 0;
handleCloseTooltip();
};
const handleMouseEnter = () => {
if (ignoreNonTouchEventsRef.current) {
return;
}
window.clearTimeout(visibleTimeout);
if (tooltips.size || !openDelay || isOpen) {
open();
} else {
visibleTimeout = window.setTimeout(() => {
open(false);
}, openDelay);
}
};
const handleMouseDown = () => {
if (ignoreNonTouchEventsRef.current) {
return;
}
// Close the tooltip on mouse down, and ignore the upcoming focus event (on chrome)
ignoreFocusRef.current = true;
close();
};
const handleMouseLeave = () => {
// Reset ignore focus when leaving the element
ignoreFocusRef.current = false;
if (ignoreNonTouchEventsRef.current) {
return;
}
close();
};
const handleFocus = () => {
// Reset ignore focus if it's set. Manages the case for
// mousedown -> mouseup -> focus
// and mouseleave never triggered, just as a safety mechanism to reset ignore
if (ignoreNonTouchEventsRef.current || ignoreFocusRef.current) {
ignoreFocusRef.current = false;
return;
}
open();
};
useEffect(() => {
/**
* if `isExternalOpen` shifted from being `true`
* to `undefined` we can safely close the tooltip :
* the tooltip is no longer externally controllable
* (ie: errored InputField lost focus)
*/
if (isExternalOpen === undefined) {
if (wasExternallyOpened) {
close();
}
return;
}
if (isExternalOpen && !isOpen) {
return open();
}
if (!isExternalOpen && isOpen) {
return close();
}
}, [isExternalOpen, isOpen]);
if (isExternalOpen !== undefined) {
return {};
}
return {
onTouchEnd: handleTouchEnd,
onTouchStart: handleTouchStart,
onMouseDown: handleMouseDown,
onMouseEnter: handleMouseEnter,
onMouseLeave: handleMouseLeave,
onFocus: handleFocus,
onBlur: handleCloseTooltip,
};
};
export default useTooltipHandlers;
| 5,677
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/topnavbar/TopNavbar.tsx
|
import { ComponentPropsWithoutRef } from 'react';
import clsx from '@proton/utils/clsx';
interface Props extends ComponentPropsWithoutRef<'div'> {}
const TopNavbar = ({ children, className, ...rest }: Props) => {
return (
<div
className={clsx([
'flex flex-justify-end topnav-container on-mobile-no-flex flex-item-centered-vert no-print',
className,
])}
{...rest}
>
{children}
</div>
);
};
export default TopNavbar;
| 5,678
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/topnavbar/TopNavbarList.tsx
|
import { Children, ComponentPropsWithoutRef, isValidElement } from 'react';
import clsx from '@proton/utils/clsx';
interface Props extends ComponentPropsWithoutRef<'ul'> {}
const TopNavbarList = ({ children }: Props) => {
const validElements = Children.toArray(children).filter((child) => isValidElement(child));
const navIconsLength = validElements.length;
return (
<ul
className={clsx([
'topnav-list unstyled my-0 ml-2 gap-2 flex flex-nowrap flex-align-items-center hidden-empty',
navIconsLength >= 4 && 'topnav-list--four-elements',
])}
>
{children}
</ul>
);
};
export default TopNavbarList;
| 5,679
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/topnavbar/TopNavbarListItem.tsx
|
import { ComponentPropsWithoutRef, isValidElement } from 'react';
import clsx from '@proton/utils/clsx';
interface Props extends ComponentPropsWithoutRef<'li'> {
noShrink?: boolean;
collapsedOnDesktop?: boolean;
noCollapse?: boolean;
}
const TopNavbarListItem = ({
children,
noShrink,
collapsedOnDesktop = true,
noCollapse = false,
className,
...rest
}: Props) => {
if (!isValidElement(children)) {
return null;
}
return (
<li
className={clsx([
'topnav-listItem',
noShrink && 'flex-item-noshrink',
!collapsedOnDesktop && 'topnav-listItem--noCollapse',
noCollapse && 'topnav-listItem--noCollapse',
className,
])}
{...rest}
>
{children}
</li>
);
};
export default TopNavbarListItem;
| 5,680
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/topnavbar/TopNavbarListItemButton.tsx
|
import { ElementType, ForwardedRef, ReactElement, cloneElement, forwardRef } from 'react';
import { PolymorphicPropsWithRef } from 'react-polymorphic-types';
import { c } from 'ttag';
import { ButtonLike, ButtonLikeProps, NotificationDot } from '@proton/atoms';
import { ThemeColor } from '@proton/colors/types';
import clsx from '@proton/utils/clsx';
type ButtonButtonLikeProps = ButtonLikeProps<'button'>;
interface OwnProps {
color?: ButtonButtonLikeProps['color'];
shape?: ButtonButtonLikeProps['shape'];
icon?: ReactElement;
text?: string;
notificationDotColor?: ThemeColor;
}
export type TopNavbarListItemButtonProps<E extends ElementType> = PolymorphicPropsWithRef<OwnProps, E>;
const defaultElement = 'button';
const TopNavbarListItemButtonBase = <E extends ElementType = typeof defaultElement>(
{
color = 'weak',
shape = 'ghost',
text,
icon,
disabled,
className,
notificationDotColor,
tabIndex,
children,
as,
...rest
}: TopNavbarListItemButtonProps<E>,
ref: ForwardedRef<Element>
) => {
const isDisabled = disabled;
const Element: ElementType = as || defaultElement;
return (
<ButtonLike
as={Element}
color={color}
shape={shape}
className={clsx([
'topnav-link inline-flex flex-nowrap flex-align-items-center flex-item-noshrink relative',
className,
notificationDotColor && 'topnav-link--notification',
])}
disabled={isDisabled}
tabIndex={isDisabled ? -1 : tabIndex}
ref={ref}
{...rest}
>
{icon &&
cloneElement(icon, {
className: clsx([icon.props.className, 'topnav-icon mr-2 flex-item-noshrink']),
})}
<span className="navigation-title">{text}</span>
{notificationDotColor && (
<NotificationDot
className="ml-1"
color={notificationDotColor}
alt={c('Action').t`Attention required`}
/>
)}
{children}
</ButtonLike>
);
};
const TopNavbarListItemButton: <E extends ElementType = typeof defaultElement>(
props: TopNavbarListItemButtonProps<E>
) => ReactElement | null = forwardRef(TopNavbarListItemButtonBase);
export default TopNavbarListItemButton;
| 5,681
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/topnavbar/TopNavbarListItemSearchButton.tsx
|
import { forwardRef } from 'react';
import { c } from 'ttag';
import { Icon } from '../icon';
import TopNavbarListItemButton, { TopNavbarListItemButtonProps } from './TopNavbarListItemButton';
const TopNavbarListItemSearchButtonBase = (
props: Omit<TopNavbarListItemButtonProps<'button'>, 'icon' | 'text' | 'as'>,
ref: typeof props.ref
) => {
return (
<TopNavbarListItemButton
{...props}
ref={ref}
as="button"
type="button"
icon={<Icon name="magnifier" />}
title={c('Header').t`Search`}
text={c('Header').t`Search`}
/>
);
};
const TopNavbarListItemSearchButton = forwardRef(TopNavbarListItemSearchButtonBase);
export default TopNavbarListItemSearchButton;
| 5,682
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/topnavbar/TopNavbarOffer.tsx
|
import { useEffect, useRef } from 'react';
import { useHistory, useLocation } from 'react-router-dom';
import { c } from 'ttag';
import useOfferFlags from '@proton/components/containers/offers/hooks/useOfferFlags';
import { CYCLE, OPEN_OFFER_MODAL_EVENT } from '@proton/shared/lib/constants';
import { OfferModal, useOfferModal } from '../../containers';
import { OfferConfig } from '../../containers/offers/interface';
import { subscriptionModalClassName } from '../../containers/payments/subscription/constants';
import { useSubscription, useUser, useWelcomeFlags } from '../../hooks';
import { PromotionButton } from '../button/PromotionButton';
import TopNavbarListItem from './TopNavbarListItem';
interface Props {
offerConfig: OfferConfig;
ignoreVisited?: boolean;
ignoreOnboarding?: boolean;
}
const TopNavbarOffer = ({ offerConfig, ignoreVisited, ignoreOnboarding }: Props) => {
const [welcomeFlags] = useWelcomeFlags();
const onceRef = useRef(false);
const [user] = useUser();
const [subscription, loadingSubscription] = useSubscription();
const history = useHistory();
const location = useLocation();
const { isVisited, loading } = useOfferFlags(offerConfig);
const {
offer,
loadingOffer,
setFetchOffer,
renderOfferModal,
offerModalProps,
setOfferModalOpen,
currency,
onChangeCurrency,
} = useOfferModal(offerConfig);
// Listen custom event to open offer modal
useEffect(() => {
const open = () => {
if (renderOfferModal) {
return;
}
setOfferModalOpen(true);
setFetchOffer(true);
};
document.addEventListener(OPEN_OFFER_MODAL_EVENT, open);
return () => {
document.removeEventListener(OPEN_OFFER_MODAL_EVENT, open);
};
}, [renderOfferModal]);
// Auto-popup offer modal
useEffect(() => {
const searchParams = new URLSearchParams(location.search);
const autoOffer = searchParams.get('offer') === 'auto';
const plan = searchParams.get('plan');
const combinedIgnoreVisited = ignoreVisited || autoOffer;
// No welcome modal in account
if (
loading ||
loadingSubscription ||
!offerConfig.autoPopUp ||
(isVisited && !combinedIgnoreVisited) ||
onceRef.current ||
// Hide for paid mail cycle 12/24
(user.hasPaidMail &&
[CYCLE.YEARLY, CYCLE.TWO_YEARS].includes(subscription?.Cycle) &&
!combinedIgnoreVisited) ||
// Hide the autopopup during the welcome flow and re-trigger it when the welcome flow completes.
(!welcomeFlags.isDone && !ignoreOnboarding) ||
// If the subscription modal is open. Explicitly not checking if any modal is open since it intereferes with the onboarding modal.
document.querySelector(`.${subscriptionModalClassName}`) !== null ||
// Trying to catch if the automatic subscription modal will get opened.
!!plan
) {
return;
}
if (autoOffer) {
history.replace({ search: undefined });
}
onceRef.current = true;
setFetchOffer(true);
setOfferModalOpen(true);
}, [loading, loadingSubscription, user.hasPaidMail, subscription, welcomeFlags.isDone]);
return (
<>
<TopNavbarListItem collapsedOnDesktop={false} noShrink>
<PromotionButton
as="button"
type="button"
color="norm"
shape={offerConfig.shapeButton || 'solid'}
iconName={offerConfig.icon || 'bag-percent'}
onClick={() => {
setOfferModalOpen(true);
setFetchOffer(true);
}}
loading={loadingOffer && !offer}
data-testid="cta:special-offer"
>
{offerConfig.getCTAContent?.() || c('specialoffer: Action').t`Special offer`}
</PromotionButton>
</TopNavbarListItem>
{renderOfferModal && offer && (
<OfferModal
currency={currency}
onChangeCurrency={onChangeCurrency}
offer={offer}
offerConfig={offerConfig}
modalProps={{
...offerModalProps,
onClose: () => {
offerModalProps.onClose?.();
setFetchOffer(false);
},
}}
/>
)}
</>
);
};
export default TopNavbarOffer;
| 5,683
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/topnavbar/TopNavbarUpgradeButton.tsx
|
import { useLocation } from 'react-router-dom';
import { c } from 'ttag';
import { SettingsLink, useConfig, useSubscription, useUser } from '@proton/components';
import { APPS, APP_NAMES, UPSELL_COMPONENT } from '@proton/shared/lib/constants';
import { isTrial } from '@proton/shared/lib/helpers/subscription';
import { getUpsellRefFromApp } from '@proton/shared/lib/helpers/upsell';
import PromotionButton from '../button/PromotionButton/PromotionButton';
import TopNavbarListItem from './TopNavbarListItem';
interface Props {
app?: APP_NAMES;
}
const TopNavbarUpgradeButton = ({ app }: Props) => {
const [user] = useUser();
const [subscription] = useSubscription();
const location = useLocation();
const { APP_NAME } = useConfig();
const isVPN = APP_NAME === APPS.PROTONVPN_SETTINGS;
const upgradePathname = isVPN ? '/dashboard' : '/upgrade';
const upsellRef = getUpsellRefFromApp({
app: APP_NAME,
feature: '1',
component: UPSELL_COMPONENT.BUTTON,
fromApp: app,
});
// We want to have metrics from where the user has clicked on the upgrade button
const upgradeUrl = `${upgradePathname}?ref=${upsellRef}`;
const displayUpgradeButton = (user.isFree || isTrial(subscription)) && !location.pathname.endsWith(upgradePathname);
if (displayUpgradeButton) {
return (
<TopNavbarListItem noCollapse>
<PromotionButton
as={SettingsLink}
iconName="upgrade"
path={upgradeUrl}
title={c('specialoffer: Link').t`Go to subscription plans`}
data-testid="cta:upgrade-plan"
>{c('specialoffer: Link').t`Upgrade`}</PromotionButton>
</TopNavbarListItem>
);
}
return null;
};
export default TopNavbarUpgradeButton;
| 5,684
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/topnavbar/TopNavbarUpsell.tsx
|
import { ComponentPropsWithoutRef } from 'react';
import { APP_NAMES } from '@proton/shared/lib/constants';
import useOfferConfig from '../../containers/offers/hooks/useOfferConfig';
import TopNavbarOffer from './TopNavbarOffer';
import TopNavbarUpgradeButton from './TopNavbarUpgradeButton';
interface Props {
offerProps?: Omit<ComponentPropsWithoutRef<typeof TopNavbarOffer>, 'offerConfig'>;
app?: APP_NAMES;
}
const TopNavbarUpsell = ({ offerProps, app }: Props) => {
const [offerConfig, loadingOffer] = useOfferConfig();
if (loadingOffer) {
return null;
}
if (offerConfig) {
return <TopNavbarOffer {...offerProps} offerConfig={offerConfig} />;
}
return <TopNavbarUpgradeButton app={app} />;
};
export default TopNavbarUpsell;
| 5,685
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/topnavbar/index.ts
|
export { default as TopNavbar } from './TopNavbar';
export { default as TopNavbarList } from './TopNavbarList';
export { default as TopNavbarListItem } from './TopNavbarListItem';
export { default as TopNavbarListItemButton } from './TopNavbarListItemButton';
export { default as TopNavbarListItemSearchButton } from './TopNavbarListItemSearchButton';
export { default as TopNavbarUpsell } from './TopNavbarUpsell';
| 5,686
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/treeview/TreeViewContainer.tsx
|
import { ReactNode } from 'react';
export interface Props {
role?: string;
children: ReactNode;
}
const TreeViewContainer = ({ role = 'tree', children }: Props) => {
return (
<ul role={role} className="treeview-container unstyled my-0">
{children}
</ul>
);
};
export default TreeViewContainer;
| 5,687
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/treeview/TreeViewItem.tsx
|
import { DragEvent, MouseEvent, ReactNode } from 'react';
export interface Props {
disabled?: boolean;
loading?: boolean;
content?: ReactNode;
toggled?: boolean;
focussed?: boolean;
children?: ReactNode;
onDragEnd?: () => void;
onToggle?: () => void;
onFocus?: () => void;
onDragStart?: () => void;
onDragOver?: (event: DragEvent) => void;
onDrop?: () => void;
onDrag?: () => void;
draggable?: boolean;
title?: string;
}
const TreeView = ({
draggable = false,
onDragEnd,
onDragStart,
onDragOver,
onDrop,
onDrag,
disabled,
content,
toggled = false,
focussed = false,
children,
onToggle,
onFocus,
title,
}: Props) => {
const handleClick = (event: MouseEvent) => {
event.stopPropagation();
if (disabled) {
return;
}
onToggle?.();
};
return (
<li
title={title}
role={children ? 'treeitem' : 'none'}
tabIndex={focussed ? 0 : -1}
onClick={handleClick}
onFocus={onFocus}
aria-expanded={toggled}
className="treeview-item"
>
<div
className="treeview-content"
draggable={!disabled && draggable}
onDragStart={onDragStart}
onDragEnd={onDragEnd}
onDragOver={onDragOver}
onDrop={onDrop}
onDrag={onDrag}
>
{content}
</div>
{toggled ? children : null}
</li>
);
};
export default TreeView;
| 5,688
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/treeview/index.ts
|
export { default as TreeViewContainer } from './TreeViewContainer';
export { default as TreeViewItem } from './TreeViewItem';
| 5,689
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/truncatedText/TruncatedText.tsx
|
import { useState } from 'react';
import { c } from 'ttag';
import truncate from '@proton/utils/truncate';
import { InlineLinkButton } from '../button';
interface Props {
children: string;
maxChars: number;
}
const TruncatedText = ({ children, maxChars }: Props) => {
const [isShowingMore, setIsShowingMore] = useState(false);
return (
<>
{isShowingMore ? children : truncate(children, maxChars)}{' '}
{children.length > maxChars && (
<InlineLinkButton
color="norm"
onClick={() => setIsShowingMore((prevState) => !prevState)}
className="align-baseline"
>
{isShowingMore ? c('Action').t`Show less` : c('Action').t`Show more`}
</InlineLinkButton>
)}
</>
);
};
export default TruncatedText;
| 5,690
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/truncatedText/index.ts
|
export { default as TruncatedText } from './TruncatedText';
| 5,691
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/upsell/MailUpsellButton.tsx
|
import { PromotionButton } from '../button/PromotionButton';
interface Props {
onClick: () => void;
text: string;
}
const MailUpsellButton = ({ onClick, text }: Props) => {
return (
<PromotionButton iconName="brand-proton-mail-filled-plus" onClick={onClick}>
{text}
</PromotionButton>
);
};
export default MailUpsellButton;
| 5,692
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/upsell/UpsellIcon.tsx
|
import { forwardRef } from 'react';
import { c } from 'ttag';
import { BRAND_NAME } from '@proton/shared/lib/constants';
import upsellIconSvg from '@proton/styles/assets/img/illustrations/upsell-icon.svg';
const UpsellIcon = forwardRef<HTMLImageElement, React.HTMLProps<HTMLImageElement>>(({ ...imageElementProps }, ref) => (
<img
{...imageElementProps}
ref={ref}
src={upsellIconSvg}
alt={c('Description').t`Upsell icon containing ${BRAND_NAME} logo followed by a plus sign`}
/>
));
UpsellIcon.displayName = 'UpsellIcon';
export default UpsellIcon;
| 5,693
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components
|
petrpan-code/ProtonMail/WebClients/packages/components/components/upsell/index.ts
|
export * from './modal';
export { default as MailUpsellButton } from './MailUpsellButton';
| 5,694
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components/upsell
|
petrpan-code/ProtonMail/WebClients/packages/components/components/upsell/modal/UpsellModal.tsx
|
import React from 'react';
import { c } from 'ttag';
import { Button } from '@proton/atoms/Button';
import {
Icon,
Info,
ModalStateProps,
ModalTwo,
ModalTwoContent,
ModalTwoHeader,
useSettingsLink,
} from '@proton/components/components';
import headerImage from '@proton/styles/assets/img/illustrations/upsell-header.svg';
import { UpsellFeatureName, upsellFeatures } from './constants';
type UpsellBoxProps = Required<
Pick<UpsellModalProps, 'description' | 'title' | 'features'> & { handleUpgrade: () => void }
>;
const UpsellBox = ({ description, handleUpgrade, title, features }: UpsellBoxProps) => (
<div>
<div className="text-center">
<div className="mb-4 rounded">
<img
src={headerImage}
className="w-full block"
alt={c('Description').t`ProtonMail logo and a plus sign`}
/>
</div>
<h1 className="h3 text-bold mb-4">{title}</h1>
<div className="color-weak mb-4 px-4">{description}</div>
</div>
<div className="border border-primary rounded p-6 pt-4">
<ul className="m-0 unstyled mb-4">
{features.map((featureName) => {
const feature = upsellFeatures[featureName];
return (
<li className="py-2 rounded" key={feature.getText()}>
<div className="flex flex-nowrap flex-align-items-center">
<div className="mr-3 flex-item-noshrink flex">
<Icon className="color-primary m-auto" size={20} name={feature.icon} />
</div>
<div className="flex-item-fluid">
{feature.getText()}
{feature.getTooltip ? (
<Info buttonClass="ml-2" title={feature.getTooltip()} />
) : null}
</div>
</div>
</li>
);
})}
</ul>
<Button onClick={handleUpgrade} size="large" color="norm" shape="solid" fullWidth>{c('new_plans: Action')
.t`Upgrade now`}</Button>
</div>
</div>
);
export interface UpsellModalProps {
['data-testid']?: string;
description: string;
features: UpsellFeatureName[];
modalProps: ModalStateProps;
title: string;
upsellRef: string;
onClose?: () => void;
}
const UpsellModal = ({
description,
features,
modalProps,
title,
upsellRef,
'data-testid': dataTestid,
onClose,
}: UpsellModalProps) => {
const goToSettings = useSettingsLink();
const handleUpgrade = () => {
goToSettings(`/upgrade?ref=${upsellRef}`, undefined, false);
modalProps.onClose();
};
const handleClose = () => {
onClose?.();
modalProps.onClose();
};
return (
<ModalTwo data-testid={dataTestid} {...modalProps} onClose={handleClose}>
<ModalTwoHeader />
<ModalTwoContent>
<UpsellBox title={title} description={description} features={features} handleUpgrade={handleUpgrade} />
</ModalTwoContent>
</ModalTwo>
);
};
export default UpsellModal;
| 5,695
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components/upsell
|
petrpan-code/ProtonMail/WebClients/packages/components/components/upsell/modal/constants.ts
|
import { c } from 'ttag';
import { BRAND_NAME, CALENDAR_APP_NAME, DRIVE_APP_NAME, MAIL_APP_NAME } from '@proton/shared/lib/constants';
import { UpsellFeature } from './interface';
export type UpsellFeatureName =
| 'auto-delete-trash-and-spam'
| 'schedule-messages'
| 'unlimited-folders-and-labels'
| 'search-message-content'
| 'more-storage'
| 'more-email-addresses'
| 'custom-email-domains'
| 'email-aliases'
| 'snooze-messages';
const domain = 'proton.me';
// Dirty fix because we cannot add twice the same variable in a string with ttag
const domain2 = 'proton.me';
/**
* Default upsell features
*/
export const upsellFeatures: Record<UpsellFeatureName, UpsellFeature> = {
'auto-delete-trash-and-spam': {
icon: 'trash-clock',
getText: () => c('new_plans: feature').t`Auto-delete spam and trashed messages`,
},
'schedule-messages': {
icon: 'paper-plane-horizontal-clock',
getText: () => c('new_plans: feature').t`Schedule messages at any time`,
},
'unlimited-folders-and-labels': {
icon: 'folders',
getText: () => c('new_plans: feature').t`Unlimited folders, labels, and filters`,
},
'search-message-content': {
icon: 'magnifier',
getText: () => c('new_plans: feature').t`Search message content`,
},
'more-storage': {
icon: 'storage',
getText: () => c('new_plans: feature').t`Up to 3 TB of storage`,
getTooltip: () =>
c('new_plans: feature info')
.t`Storage space is shared across ${MAIL_APP_NAME}, ${CALENDAR_APP_NAME} and ${DRIVE_APP_NAME}`,
},
'more-email-addresses': {
icon: 'envelopes',
getText: () => c('new_plans: feature').t`Up to 15 email addresses`,
getTooltip: () =>
c('new_plans: feature info')
.t`Create multiple email addresses for your online identities e.g. JohnShopper@${domain} for shopping accounts, JohnNews@${domain2} for news subscription`,
},
'custom-email-domains': {
icon: 'globe',
getText: () => c('new_plans: feature').t`Custom email domains`,
getTooltip: () =>
c('new_plans: feature info').t`Use your own custom email domain address, e.g., you@yourname.com`,
},
'email-aliases': {
icon: 'eye-slash',
getText: () => c('new_plans: feature').t`Hide-my-email aliases`,
getTooltip: () => c('new_plans: feature info').t`Get unlimited aliases with SimpleLogin by ${BRAND_NAME}`,
},
'snooze-messages': {
icon: 'clock',
getText: () => c('new_plans: feature').t`Custom snooze time`,
getTooltip: () => c('new_plans: feature info').t`Snooze messages and get reminded when you want`,
},
};
| 5,696
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components/upsell
|
petrpan-code/ProtonMail/WebClients/packages/components/components/upsell/modal/index.ts
|
export { default as UpsellModal } from './UpsellModal';
export type { UpsellFeature as UpsellFeatures } from './interface';
export { default as FiltersUpsellModal } from './types/FiltersUpsellModal';
export { default as LabelsUpsellModal } from './types/LabelsUpsellModal';
export { default as AutoDeleteUpsellModal } from './types/AutoDeleteUpsellModal';
export { default as PmMeUpsellModal } from './types/PmMeUpsellModal';
| 5,697
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components/upsell
|
petrpan-code/ProtonMail/WebClients/packages/components/components/upsell/modal/interface.ts
|
import { IconName } from '../../icon';
export interface UpsellFeature {
getText: () => string;
getTooltip?: () => string;
icon: IconName;
}
| 5,698
|
0
|
petrpan-code/ProtonMail/WebClients/packages/components/components/upsell/modal
|
petrpan-code/ProtonMail/WebClients/packages/components/components/upsell/modal/types/AutoDeleteUpsellModal.tsx
|
import { c } from 'ttag';
import { APP_UPSELL_REF_PATH, MAIL_UPSELL_PATHS, UPSELL_COMPONENT } from '@proton/shared/lib/constants';
import { getUpsellRef } from '@proton/shared/lib/helpers/upsell';
import { ModalStateProps } from '../../../modalTwo';
import { UpsellModal } from '../index';
interface Props {
modalProps: ModalStateProps;
}
const AutoDeleteUpsellModal = ({ modalProps }: Props) => (
<UpsellModal
data-testid="auto-delete:banner:upsell-modal"
modalProps={modalProps}
features={[
'auto-delete-trash-and-spam',
'schedule-messages',
'unlimited-folders-and-labels',
'search-message-content',
'more-storage',
'more-email-addresses',
'custom-email-domains',
'email-aliases',
]}
description={c('Description')
.t`Automatically clear out messages older than 30 days from trash and spam. Enjoy this and other benefits when you upgrade.`}
title={c('Title').t`Clear out the junk`}
upsellRef={getUpsellRef({
app: APP_UPSELL_REF_PATH.MAIL_UPSELL_REF_PATH,
component: UPSELL_COMPONENT.MODAL,
feature: MAIL_UPSELL_PATHS.AUTO_DELETE,
})}
/>
);
export default AutoDeleteUpsellModal;
| 5,699
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.