src/components/ui/Category.tsx

+import { Plus } from "@styled-icons/boxicons-regular";
 import styled, { css } from "styled-components";
+
 import { Children } from "../../types/Preact";
-import { Plus } from "@styled-icons/feather";
 
-const CategoryBase = styled.div<Pick<Props, 'variant'>>`
+const CategoryBase = styled.div<Pick<Props, "variant">>`
     font-size: 12px;
     font-weight: 700;
     text-transform: uppercase;
 
     margin-top: 4px;
-    padding: 6px 10px;
+    padding: 6px 0;
     margin-bottom: 4px;
     white-space: nowrap;
-    
+
     display: flex;
     align-items: center;
     flex-direction: row;
     justify-content: space-between;
 
     svg {
-        stroke: var(--foreground);
         cursor: pointer;
     }
 
-    ${ props => props.variant === 'uniform' && css`
-        padding-top: 6px;
-    ` }
+    &:first-child {
+        margin-top: 0;
+        padding-top: 0;
+    }
+
+    ${(props) =>
+        props.variant === "uniform" &&
+        css`
+            padding-top: 6px;
+        `}
 `;
 
-interface Props {
+type Props = Omit<
+    JSX.HTMLAttributes<HTMLDivElement>,
+    "children" | "as" | "action"
+> & {
     text: Children;
     action?: () => void;
-    variant?: 'default' | 'uniform';
-}
+    variant?: "default" | "uniform";
+};
 
 export default function Category(props: Props) {
+    const { text, action, ...otherProps } = props;
+
     return (
-        <CategoryBase>
-            {props.text}
-            {props.action && (
-                <Plus size={16} onClick={props.action} />
-            )}
+        <CategoryBase {...otherProps}>
+            {text}
+            {action && <Plus size={16} onClick={action} />}
         </CategoryBase>
     );
-};
+}

src/components/ui/Checkbox.tsx

-import { Check } from "@styled-icons/feather";
-import { Children } from "../../types/Preact";
+import { Check } from "@styled-icons/boxicons-regular";
 import styled, { css } from "styled-components";
 
+import { Children } from "../../types/Preact";
+
 const CheckboxBase = styled.label`
     gap: 4px;
     z-index: 1;
-    padding: 4px;
     display: flex;
-    border-radius: 4px;
+    margin-top: 20px;
     align-items: center;
+    border-radius: var(--border-radius);
 
     cursor: pointer;
     font-size: 18px;
@@ -16,33 +17,36 @@ const CheckboxBase = styled.label`
 
     transition: 0.2s ease all;
 
-    p {
-        margin: 0;
-    }
-
     input {
         display: none;
     }
 
     &:hover {
-        background: var(--secondary-background);
-
         .check {
             background: var(--background);
         }
     }
+
+    &[disabled] {
+        opacity: 0.5;
+        cursor: not-allowed;
+
+        &:hover {
+            background: unset;
+        }
+    }
 `;
 
 const CheckboxContent = styled.span`
-    flex-grow: 1;
     display: flex;
+    flex-grow: 1;
     font-size: 1rem;
     font-weight: 600;
     flex-direction: column;
 `;
 
 const CheckboxDescription = styled.span`
-    font-size: 0.8em;
+    font-size: 0.75rem;
     font-weight: 400;
     color: var(--secondary-foreground);
 `;
@@ -52,14 +56,14 @@ const Checkmark = styled.div<{ checked: boolean }>`
     width: 24px;
     height: 24px;
     display: grid;
-    border-radius: 4px;
+    flex-shrink: 0;
     place-items: center;
     transition: 0.2s ease all;
+    border-radius: var(--border-radius);
     background: var(--secondary-background);
 
     svg {
         color: var(--secondary-background);
-        stroke-width: 2;
     }
 
     ${(props) =>

src/components/ui/ColourSwatches.tsx

-import { useRef } from "preact/hooks";
-import { Check } from "@styled-icons/feather";
+import { Check } from "@styled-icons/boxicons-regular";
+import { Palette } from "@styled-icons/boxicons-solid";
 import styled, { css } from "styled-components";
-import { Pencil } from "@styled-icons/bootstrap";
+
+import { RefObject } from "preact";
+import { useRef } from "preact/hooks";
 
 interface Props {
     value: string;
@@ -32,21 +34,40 @@ const presets = [
 ];
 
 const SwatchesBase = styled.div`
-    gap: 8px;
+    /*gap: 8px;*/
     display: flex;
 
     input {
+        width: 0;
+        height: 0;
+        top: 72px;
         opacity: 0;
-        margin-top: 44px;
-        position: absolute;
+        padding: 0;
+        border: 0;
+        position: relative;
         pointer-events: none;
     }
+
+    .overlay {
+        position: relative;
+        width: 0;
+
+        div {
+            width: 8px;
+            height: 68px;
+            background: linear-gradient(
+                to right,
+                var(--primary-background),
+                transparent
+            );
+        }
+    }
 `;
 
 const Swatch = styled.div<{ type: "small" | "large"; colour: string }>`
     flex-shrink: 0;
     cursor: pointer;
-    border-radius: 4px;
+    border-radius: var(--border-radius);
     background-color: ${(props) => props.colour};
 
     display: grid;
@@ -68,7 +89,7 @@ const Swatch = styled.div<{ type: "small" | "large"; colour: string }>`
                   height: 30px;
 
                   svg {
-                      stroke-width: 2;
+                      /*stroke-width: 2;*/
                   }
               `
             : css`
@@ -81,32 +102,39 @@ const Rows = styled.div`
     gap: 8px;
     display: flex;
     flex-direction: column;
+    overflow: auto;
+    padding-bottom: 4px;
 
     > div {
         gap: 8px;
         display: flex;
         flex-direction: row;
+        padding-inline-start: 8px;
     }
 `;
 
 export default function ColourSwatches({ value, onChange }: Props) {
-    const ref = useRef<HTMLInputElement>();
+    const ref = useRef<HTMLInputElement>() as RefObject<HTMLInputElement>;
 
     return (
         <SwatchesBase>
-            <Swatch
-                colour={value}
-                type="large"
-                onClick={() => ref.current.click()}
-            >
-                <Pencil size={32} />
-            </Swatch>
             <input
                 type="color"
                 value={value}
                 ref={ref}
                 onChange={(ev) => onChange(ev.currentTarget.value)}
             />
+            <Swatch
+                colour={value}
+                type="large"
+                onClick={() => ref.current?.click()}>
+                <Palette size={32} />
+            </Swatch>
+
+            <div class="overlay">
+                <div />
+            </div>
+
             <Rows>
                 {presets.map((row, i) => (
                     <div key={i}>
@@ -115,11 +143,8 @@ export default function ColourSwatches({ value, onChange }: Props) {
                                 colour={swatch}
                                 type="small"
                                 key={i}
-                                onClick={() => onChange(swatch)}
-                            >
-                                {swatch === value && (
-                                    <Check size={18} strokeWidth={2} />
-                                )}
+                                onClick={() => onChange(swatch)}>
+                                {swatch === value && <Check size={22} />}
                             </Swatch>
                         ))}
                     </div>

src/components/ui/ComboBox.tsx

 import styled from "styled-components";
 
 export default styled.select`
-    padding: 8px;
-    border-radius: 2px;
+    width: 100%;
+    padding: 10px;
+    cursor: pointer;
+    border-radius: var(--border-radius);
+
+    font-family: inherit;
+    font-size: var(--text-size);
     color: var(--secondary-foreground);
     background: var(--secondary-background);
+
+    border: none;
+    outline: 2px solid transparent;
+    transition: box-shadow 0.2s ease-in-out;
+    transition: outline-color 0.2s ease-in-out;
+
+    &:focus {
+        box-shadow: 0 0 0 1.5pt var(--accent);
+    }
 `;

src/components/ui/DateDivider.tsx

-import dayjs from "dayjs";
 import styled, { css } from "styled-components";
 
+import { dayjs } from "../../context/Locale";
+
 const Base = styled.div<{ unread?: boolean }>`
     height: 0;
     display: flex;
-    margin: 14px 10px;
     user-select: none;
     align-items: center;
+    margin: 17px 12px 5px;
     border-top: thin solid var(--tertiary-foreground);
 
     time {
         margin-top: -2px;
-        font-size: .6875rem;
-        line-height: .6875rem;
-        padding: 2px 5px 2px 0;
+        font-size: 0.6875rem;
+        line-height: 0.6875rem;
+        padding: 2px 0 2px 0;
+        padding-inline-end: 5px;
         color: var(--tertiary-foreground);
         background: var(--primary-background);
     }
 
-    ${ props => props.unread && css`
-        border-top: thin solid var(--accent);
-    ` }
+    ${(props) =>
+        props.unread &&
+        css`
+            border-top: thin solid var(--accent);
+        `}
 `;
 
 const Unread = styled.div`
@@ -39,10 +43,8 @@ interface Props {
 export default function DateDivider(props: Props) {
     return (
         <Base unread={props.unread}>
-            { props.unread && <Unread>NEW</Unread> }
-            <time>
-                { dayjs(props.date).format("LL") }
-            </time>
+            {props.unread && <Unread>NEW</Unread>}
+            <time>{dayjs(props.date).format("LL")}</time>
         </Base>
     );
 }

src/components/ui/Details.tsx

+import styled, { css } from "styled-components";
+
+export default styled.details<{ sticky?: boolean; large?: boolean }>`
+    summary {
+        ${(props) =>
+            props.sticky &&
+            css`
+                top: -1px;
+                z-index: 10;
+                position: sticky;
+            `}
+
+        ${(props) =>
+            props.large &&
+            css`
+                /*padding: 5px 0;*/
+                background: var(--primary-background);
+                color: var(--secondary-foreground);
+
+                .padding {
+                    /*TOFIX: make this applicable only for the friends list menu, DO NOT REMOVE.*/
+                    display: flex;
+                    align-items: center;
+                    padding: 5px 0;
+                    margin: 0.8em 0px 0.4em;
+                    cursor: pointer;
+                }
+            `}
+
+        outline: none;
+        cursor: pointer;
+        list-style: none;
+        user-select: none;
+        align-items: center;
+        transition: 0.2s opacity;
+
+        font-size: 12px;
+        font-weight: 600;
+        text-transform: uppercase;
+
+        &::marker,
+        &::-webkit-details-marker {
+            display: none;
+        }
+
+        .title {
+            flex-grow: 1;
+            margin-top: 1px;
+            text-overflow: ellipsis;
+            overflow: hidden;
+            white-space: nowrap;
+        }
+
+        .padding {
+            display: flex;
+            align-items: center;
+
+            > svg {
+                flex-shrink: 0;
+                margin-inline-end: 4px;
+                transition: 0.2s ease transform;
+            }
+        }
+    }
+
+    &:not([open]) {
+        summary {
+            opacity: 0.7;
+        }
+
+        summary svg {
+            transform: rotateZ(-90deg);
+        }
+    }
+`;

src/components/ui/Header.tsx

 import styled, { css } from "styled-components";
 
 interface Props {
+    borders?: boolean;
     background?: boolean;
-    placement: 'primary' | 'secondary'
+    placement: "primary" | "secondary";
 }
 
 export default styled.div<Props>`
-    height: 56px;
-    font-weight: 600;
-    user-select: none;
-
-    gap: 10px;
+    gap: 6px;
+    height: 48px;
     flex: 0 auto;
     display: flex;
-    padding: 20px;
     flex-shrink: 0;
+    padding: 0 16px;
+    font-weight: 600;
+    user-select: none;
     align-items: center;
 
-    background-color: var(--primary-header);
     background-size: cover !important;
     background-position: center !important;
+    background-color: var(--primary-header);
+
+    svg {
+        flex-shrink: 0;
+    }
+
+    .menu {
+        margin-inline-end: 8px;
+        color: var(--secondary-foreground);
+    }
+
+    /*@media only screen and (max-width: 768px) {
+        padding: 0 12px;
+    }*/
+
+    @media (pointer: coarse) {
+        height: 56px;
+    }
+
+    ${(props) =>
+        props.background &&
+        css`
+            height: 120px !important;
+            align-items: flex-end;
+
+            text-shadow: 0px 0px 1px black;
+        `}
 
-    ${ props => props.background && css`
-        height: 120px;
-        align-items: flex-end;
-    ` }
+    ${(props) =>
+        props.placement === "secondary" &&
+        css`
+            background-color: var(--secondary-header);
+            padding: 14px;
+        `}
 
-    ${ props => props.placement === 'secondary' && css`
-        background-color: var(--secondary-header);
-        padding: 14px;
-    ` }
+    ${(props) =>
+        props.borders &&
+        css`
+            border-start-start-radius: 8px;
+        `}
 `;

src/components/ui/IconButton.tsx

 import styled, { css } from "styled-components";
 
 interface Props {
-    type?: 'default' | 'circle'
+    rotate?: string;
+    type?: "default" | "circle";
 }
 
 const normal = `var(--secondary-foreground)`;
@@ -12,32 +13,47 @@ export default styled.div<Props>`
     display: grid;
     cursor: pointer;
     place-items: center;
+    transition: 0.1s ease background-color;
 
     fill: ${normal};
     color: ${normal};
-    stroke: ${normal};
+    /*stroke: ${normal};*/
 
     a {
         color: ${normal};
     }
 
+    svg {
+        transition: 0.2s ease transform;
+    }
+
     &:hover {
         fill: ${hover};
         color: ${hover};
-        stroke: ${hover};
+        /*stroke: ${hover};*/
 
         a {
             color: ${hover};
         }
     }
 
-    ${ props => props.type === 'circle' && css`
-        padding: 4px;
-        border-radius: 50%;
-        background-color: var(--secondary-header);
-
-        &:hover {
-            background-color: var(--primary-header);
-        }
-    ` }
+    ${(props) =>
+        props.type === "circle" &&
+        css`
+            padding: 4px;
+            border-radius: 50%;
+            background-color: var(--secondary-header);
+
+            &:hover {
+                background-color: var(--primary-header);
+            }
+        `}
+
+    ${(props) =>
+        props.rotate &&
+        css`
+            svg {
+                transform: rotateZ(${props.rotate});
+            }
+        `}
 `;

src/components/ui/InputBox.tsx

@@ -6,20 +6,26 @@ interface Props {
 
 export default styled.input<Props>`
     z-index: 1;
+    font-size: 1rem;
     padding: 8px 16px;
-    border-radius: 6px;
+    border-radius: var(--border-radius);
+
+    font-family: inherit;
     color: var(--foreground);
-    border: 2px solid transparent;
     background: var(--primary-background);
     transition: 0.2s ease background-color;
-    transition: border-color 0.2s ease-in-out;
+
+    border: none;
+    outline: 2px solid transparent;
+    transition: outline-color 0.2s ease-in-out;
+    transition: box-shadow 0.2s ease-in-out;
 
     &:hover {
         background: var(--secondary-background);
     }
 
     &:focus {
-        border: 2px solid var(--accent);
+        box-shadow: 0 0 0 1.5pt var(--accent);
     }
 
     ${(props) =>

src/components/ui/Masks.tsx

+// This file must be imported and used at least once for SVG masks.
+
+export default function Masks() {
+    return (
+        <svg width={0} height={0} style={{ position: "fixed" }}>
+            <defs>
+                <mask id="server">
+                    <rect x="0" y="0" width="32" height="32" fill="white" />
+                    <circle cx="27" cy="5" r="7" fill={"black"} />
+                </mask>
+                <mask id="user">
+                    <rect x="0" y="0" width="32" height="32" fill="white" />
+                    <circle cx="27" cy="27" r="7" fill={"black"} />
+                </mask>
+                <mask id="session">
+                    <rect x="0" y="0" width="32" height="32" fill="white" />
+                    <circle cx="26" cy="28" r="10" fill={"black"} />
+                </mask>
+                <mask id="overlap">
+                    <rect x="0" y="0" width="32" height="32" fill="white" />
+                    <circle cx="32" cy="16" r="18" fill={"black"} />
+                </mask>
+            </defs>
+        </svg>
+    );
+}

src/components/ui/Modal.tsx

-import Button from "./Button";
-import classNames from "classnames";
-import { Children } from "../../types/Preact";
-import { createPortal, useEffect } from "preact/compat";
+/* eslint-disable react-hooks/rules-of-hooks */
 import styled, { css, keyframes } from "styled-components";
 
+import { createPortal, useCallback, useEffect, useState } from "preact/compat";
+
+import { internalSubscribe } from "../../lib/eventEmitter";
+
+import { Children } from "../../types/Preact";
+import Button, { ButtonProps } from "./Button";
+
 const open = keyframes`
     0% {opacity: 0;}
     70% {opacity: 0;}
     100% {opacity: 1;}
 `;
 
+const close = keyframes`
+    0% {opacity: 1;}
+    70% {opacity: 0;}
+    100% {opacity: 0;}
+`;
+
 const zoomIn = keyframes`
     0% {transform: scale(0.5);}
     98% {transform: scale(1.01);}
     100% {transform: scale(1);}
 `;
 
+const zoomOut = keyframes`
+    0% {transform: scale(1);}
+    100% {transform: scale(0.5);}
+`;
+
 const ModalBase = styled.div`
     top: 0;
     left: 0;
@@ -35,42 +50,65 @@ const ModalBase = styled.div`
 
     color: var(--foreground);
     background: rgba(0, 0, 0, 0.8);
+
+    &.closing {
+        animation-name: ${close};
+    }
+
+    &.closing > div {
+        animation-name: ${zoomOut};
+    }
 `;
 
 const ModalContainer = styled.div`
     overflow: hidden;
-    border-radius: 8px;
     max-width: calc(100vw - 20px);
+    border-radius: var(--border-radius);
 
     animation-name: ${zoomIn};
     animation-duration: 0.25s;
-    animation-timing-function: cubic-bezier(.3,.3,.18,1.1);
+    animation-timing-function: cubic-bezier(0.3, 0.3, 0.18, 1.1);
 `;
 
-const ModalContent = styled.div<{ [key in 'attachment' | 'noBackground' | 'border' | 'padding']?: boolean }>`
-    border-radius: 8px;
+const ModalContent = styled.div<
+    { [key in "attachment" | "noBackground" | "border" | "padding"]?: boolean }
+>`
     text-overflow: ellipsis;
+    border-radius: var(--border-radius);
 
     h3 {
         margin-top: 0;
     }
 
-    ${ props => !props.noBackground && css`
-        background: var(--secondary-header);
-    ` }
-
-    ${ props => props.padding && css`
-        padding: 1.5em;
-    ` }
-
-    ${ props => props.attachment && css`
-        border-radius: 8px 8px 0 0;
-    ` }
+    form {
+        display: flex;
+        flex-direction: column;
+    }
 
-    ${ props => props.border && css`
-        border-radius: 10px;
-        border: 2px solid var(--secondary-background);
-    ` }
+    ${(props) =>
+        !props.noBackground &&
+        css`
+            background: var(--secondary-header);
+        `}
+
+    ${(props) =>
+        props.padding &&
+        css`
+            padding: 1.5em;
+        `}
+
+    ${(props) =>
+        props.attachment &&
+        css`
+            border-radius: var(--border-radius) var(--border-radius) 0 0;
+        `}
+
+    ${(props) =>
+        props.border &&
+        css`
+            border-radius: var(--border-radius);
+            border: 2px solid var(--secondary-background);
+        `}
 `;
 
 const ModalActions = styled.div`
@@ -83,13 +121,10 @@ const ModalActions = styled.div`
     background: var(--secondary-background);
 `;
 
-export interface Action {
-    text: Children;
-    onClick: () => void;
+export type Action = Omit<ButtonProps, "onClick"> & {
     confirmation?: boolean;
-    contrast?: boolean;
-    error?: boolean;
-}
+    onClick: () => void;
+};
 
 interface Props {
     children?: Children;
@@ -98,23 +133,26 @@ interface Props {
     disallowClosing?: boolean;
     noBackground?: boolean;
     dontModal?: boolean;
+    padding?: boolean;
 
-    onClose: () => void;
+    onClose?: () => void;
     actions?: Action[];
     disabled?: boolean;
     border?: boolean;
     visible: boolean;
 }
 
+export let isModalClosing = false;
+
 export default function Modal(props: Props) {
     if (!props.visible) return null;
 
-    let content = (
+    const content = (
         <ModalContent
             attachment={!!props.actions}
             noBackground={props.noBackground}
             border={props.border}
-            padding={!props.dontModal}>
+            padding={props.padding ?? !props.dontModal}>
             {props.title && <h3>{props.title}</h3>}
             {props.children}
         </ModalContent>
@@ -124,11 +162,36 @@ export default function Modal(props: Props) {
         return content;
     }
 
-    let confirmationAction = props.actions?.find(action => action.confirmation);
+    const [animateClose, setAnimateClose] = useState(false);
+    isModalClosing = animateClose;
+    const onClose = useCallback(() => {
+        setAnimateClose(true);
+        setTimeout(() => props.onClose?.(), 2e2);
+    }, [setAnimateClose, props]);
+
+    useEffect(() => internalSubscribe("Modal", "close", onClose), [onClose]);
+
+    useEffect(() => {
+        if (props.disallowClosing) return;
+
+        function keyDown(e: KeyboardEvent) {
+            if (e.key === "Escape") {
+                onClose();
+            }
+        }
+
+        document.body.addEventListener("keydown", keyDown);
+        return () => document.body.removeEventListener("keydown", keyDown);
+    }, [props.disallowClosing, onClose]);
+
+    const confirmationAction = props.actions?.find(
+        (action) => action.confirmation,
+    );
+
     useEffect(() => {
         if (!confirmationAction) return;
 
-        // ! FIXME: this may be done better if we
+        // ! TODO: this may be done better if we
         // ! can focus the button although that
         // ! doesn't seem to work...
         function keyDown(e: KeyboardEvent) {
@@ -139,27 +202,27 @@ export default function Modal(props: Props) {
 
         document.body.addEventListener("keydown", keyDown);
         return () => document.body.removeEventListener("keydown", keyDown);
-    }, [ confirmationAction ]);
+    }, [confirmationAction]);
 
     return createPortal(
-        <ModalBase onClick={(!props.disallowClosing && props.onClose) || undefined}>
-            <ModalContainer onClick={e => (e.cancelBubble = true)}>
+        <ModalBase
+            className={animateClose ? "closing" : undefined}
+            onClick={(!props.disallowClosing && props.onClose) || undefined}>
+            <ModalContainer onClick={(e) => (e.cancelBubble = true)}>
                 {content}
                 {props.actions && (
                     <ModalActions>
-                        {props.actions.map(x => (
+                        {props.actions.map((x, index) => (
                             <Button
-                                contrast={x.contrast ?? true}
-                                error={x.error ?? false}
-                                onClick={x.onClick}
-                                disabled={props.disabled}>
-                                {x.text}
-                            </Button>
+                                key={index}
+                                {...x}
+                                disabled={props.disabled}
+                            />
                         ))}
                     </ModalActions>
                 )}
             </ModalContainer>
         </ModalBase>,
-        document.body
+        document.body,
     );
 }

src/components/ui/Overline.tsx

 import styled, { css } from "styled-components";
+
+import { Text } from "preact-i18n";
+
 import { Children } from "../../types/Preact";
-import { Text } from 'preact-i18n';
 
-interface Props {
+type Props = Omit<JSX.HTMLAttributes<HTMLDivElement>, "children" | "as"> & {
     error?: string;
     block?: boolean;
+    spaced?: boolean;
+    noMargin?: boolean;
     children?: Children;
     type?: "default" | "subtle" | "error";
-}
+};
 
 const OverlineBase = styled.div<Omit<Props, "children" | "error">>`
     display: inline;
-    margin: 0.4em 0;
-    margin-top: 0.8em;
+
+    ${(props) =>
+        !props.noMargin &&
+        css`
+            margin: 0.4em 0;
+        `}
+
+    ${(props) =>
+        props.spaced &&
+        css`
+            margin-top: 0.8em;
+        `}
 
     font-size: 14px;
     font-weight: 600;
@@ -46,9 +60,11 @@ export default function Overline(props: Props) {
         <OverlineBase {...props}>
             {props.children}
             {props.children && props.error && <> &middot; </>}
-            {props.error && <Overline type="error">
-                <Text id={`error.${props.error}`}>{props.error}</Text>
-            </Overline>}
+            {props.error && (
+                <Overline type="error">
+                    <Text id={`error.${props.error}`}>{props.error}</Text>
+                </Overline>
+            )}
         </OverlineBase>
     );
 }

src/components/ui/Preloader.tsx

-export default function Preloader() {
-    return <span>LOADING</span>;
+import styled, { keyframes } from "styled-components";
+
+const skSpinner = keyframes`
+    0%, 80%, 100% { 
+        -webkit-transform: scale(0);
+        transform: scale(0);
+    }
+    40% { 
+        -webkit-transform: scale(1.0);
+        transform: scale(1.0);
+    }
+`;
+
+const prRing = keyframes`
+    0% {
+        transform: rotate(0deg);
+    }
+    100% {
+        transform: rotate(360deg);
+    }
+`;
+
+const PreloaderBase = styled.div`
+    width: 100%;
+    height: 100%;
+
+    display: grid;
+    place-items: center;
+
+    .spinner {
+        width: 58px;
+        display: flex;
+        text-align: center;
+        margin: 100px auto 0;
+        justify-content: space-between;
+    }
+
+    .spinner > div {
+        width: 14px;
+        height: 14px;
+        background-color: var(--tertiary-foreground);
+
+        border-radius: 100%;
+        display: inline-block;
+        animation: ${skSpinner} 1.4s infinite ease-in-out both;
+    }
+
+    .spinner div:nth-child(1) {
+        animation-delay: -0.32s;
+    }
+
+    .spinner div:nth-child(2) {
+        animation-delay: -0.16s;
+    }
+
+    .ring {
+        display: inline-block;
+        position: relative;
+        width: 48px;
+        height: 52px;
+    }
+
+    .ring div {
+        width: 32px;
+        margin: 8px;
+        height: 32px;
+        display: block;
+        position: absolute;
+        border-radius: 50%;
+        box-sizing: border-box;
+        border: 2px solid #fff;
+        animation: ${prRing} 1.2s cubic-bezier(0.5, 0, 0.5, 1) infinite;
+        border-color: #fff transparent transparent transparent;
+    }
+
+    .ring div:nth-child(1) {
+        animation-delay: -0.45s;
+    }
+
+    .ring div:nth-child(2) {
+        animation-delay: -0.3s;
+    }
+
+    .ring div:nth-child(3) {
+        animation-delay: -0.15s;
+    }
+`;
+
+interface Props {
+    type: "spinner" | "ring";
+}
+
+export default function Preloader({ type }: Props) {
+    return (
+        <PreloaderBase>
+            <div class={type}>
+                <div />
+                <div />
+                <div />
+            </div>
+        </PreloaderBase>
+    );
 }

src/components/ui/Radio.tsx

-import { Children } from "../../types/Preact";
+import { Circle } from "@styled-icons/boxicons-regular";
 import styled, { css } from "styled-components";
-import { CircleFill } from "@styled-icons/bootstrap";
+
+import { Children } from "../../types/Preact";
 
 interface Props {
     children: Children;
@@ -26,8 +27,8 @@ const RadioBase = styled.label<BaseProps>`
     font-size: 1rem;
     font-weight: 600;
     user-select: none;
-    border-radius: 4px;
     transition: 0.2s ease all;
+    border-radius: var(--border-radius);
 
     &:hover {
         background: var(--hover);
@@ -48,7 +49,7 @@ const RadioBase = styled.label<BaseProps>`
 
         svg {
             color: var(--foreground);
-            stroke-width: 2;
+            /*stroke-width: 2;*/
         }
     }
 
@@ -92,10 +93,9 @@ export default function Radio(props: Props) {
             disabled={props.disabled}
             onClick={() =>
                 !props.disabled && props.onSelect && props.onSelect()
-            }
-        >
+            }>
             <div>
-                <CircleFill size={12} />
+                <Circle size={12} />
             </div>
             <input type="radio" checked={props.checked} />
             <span>

src/components/ui/TextArea.module.scss

 .container {
-    font-size: 0.875rem;
+    font-size: .875rem;
     line-height: 20px;
     position: relative;
 }

src/components/ui/TextArea.tsx

-// ! FIXME: temporarily here until re-written
-// ! DO NOT IMRPOVE, JUST RE-WRITE
-
-import classNames from "classnames";
-import { memo } from "preact/compat";
-import styles from "./TextArea.module.scss";
-import { useState, useEffect, useRef, useLayoutEffect } from "preact/hooks";
+import styled, { css } from "styled-components";
 
 export interface TextAreaProps {
-    id?: string;
-    value: string;
-    maxRows?: number;
-    padding?: number;
-    minHeight?: number;
-    disabled?: boolean;
-    maxLength?: number;
-    className?: string;
-    autoFocus?: boolean;
-    forceFocus?: boolean;
-    placeholder?: string;
-    onKeyDown?: (ev: KeyboardEvent) => void;
-    onKeyUp?: (ev: KeyboardEvent) => void;
-    onChange: (
-        value: string,
-        ev: JSX.TargetedEvent<HTMLTextAreaElement, Event>
-    ) => void;
-    onFocus?: (current: HTMLTextAreaElement) => void;
-    onBlur?: () => void;
+    code?: boolean;
+    padding?: string;
+    lineHeight?: string;
+    hideBorder?: boolean;
 }
 
-const lineHeight = 20;
-
-export const TextArea = memo((props: TextAreaProps) => {
-    const padding = props.padding ? props.padding * 2 : 0;
-
-    const [height, setHeightState] = useState(
-        props.minHeight ?? lineHeight + padding
-    );
-    const ghost = useRef<HTMLDivElement>();
-    const ref = useRef<HTMLTextAreaElement>();
-
-    function setHeight(h: number = lineHeight) {
-        let newHeight = Math.min(
-            Math.max(
-                lineHeight,
-                props.maxRows ? Math.min(h, props.maxRows * lineHeight) : h
-            ),
-            props.minHeight ?? Infinity
-        );
-
-        if (props.padding) newHeight += padding;
-        if (height !== newHeight) {
-            setHeightState(newHeight);
-        }
+export const TEXT_AREA_BORDER_WIDTH = 2;
+export const DEFAULT_TEXT_AREA_PADDING = 16;
+export const DEFAULT_LINE_HEIGHT = 20;
+
+export default styled.textarea<TextAreaProps>`
+    width: 100%;
+    resize: none;
+    display: block;
+    color: var(--foreground);
+    background: var(--secondary-background);
+    padding: ${(props) => props.padding ?? "var(--textarea-padding)"};
+    line-height: ${(props) =>
+        props.lineHeight ?? "var(--textarea-line-height)"};
+
+    ${(props) =>
+        props.hideBorder &&
+        css`
+            border: none;
+        `}
+
+    ${(props) =>
+        !props.hideBorder &&
+        css`
+            border-radius: var(--border-radius);
+            transition: border-color 0.2s ease-in-out;
+            border: var(--input-border-width) solid transparent;
+        `}
+
+    &:focus {
+        outline: none;
+
+        ${(props) =>
+            !props.hideBorder &&
+            css`
+                border: var(--input-border-width) solid var(--accent);
+            `}
     }
 
-    function onChange(ev: JSX.TargetedEvent<HTMLTextAreaElement, Event>) {
-        props.onChange(ev.currentTarget.value, ev);
-    }
-
-    useLayoutEffect(() => {
-        setHeight(ghost.current.clientHeight);
-    }, [ghost, props.value]);
-
-    useEffect(() => {
-        if (props.autoFocus) ref.current.focus();
-    }, [props.value]);
-
-    const inputSelected = () =>
-        ["TEXTAREA", "INPUT"].includes(document.activeElement?.nodeName ?? "");
-
-    useEffect(() => {
-        if (props.forceFocus) {
-            ref.current.focus();
-        }
-
-        if (props.autoFocus && !inputSelected()) {
-            ref.current.focus();
-        }
-
-        // ? if you are wondering what this is
-        // ? it is a quick and dirty hack to fix
-        // ? value not setting correctly
-        // ? I have no clue what's going on
-        ref.current.value = props.value;
-
-        if (!props.autoFocus) return;
-        function keyDown(e: KeyboardEvent) {
-            if ((e.ctrlKey && e.key !== "v") || e.altKey || e.metaKey) return;
-            if (e.key.length !== 1) return;
-            if (ref && !inputSelected()) {
-                ref.current.focus();
-            }
-        }
-
-        document.body.addEventListener("keydown", keyDown);
-        return () => document.body.removeEventListener("keydown", keyDown);
-    }, [ref]);
-
-    useEffect(() => {
-        function focus(textarea_id: string) {
-            if (props.id === textarea_id) {
-                ref.current.focus();
-            }
-        }
-
-        // InternalEventEmitter.addListener("focus_textarea", focus);
-        // return () =>
-            // InternalEventEmitter.removeListener("focus_textarea", focus);
-    }, [ref]);
-
-    return (
-        <div className={classNames(styles.container, props.className)}>
-            <textarea
-                id={props.id}
-                name={props.id}
-                style={{ height }}
-                value={props.value}
-                onChange={onChange}
-                disabled={props.disabled}
-                maxLength={props.maxLength}
-                className={styles.textarea}
-                onKeyDown={props.onKeyDown}
-                placeholder={props.placeholder}
-                onContextMenu={e => e.stopPropagation()}
-                onKeyUp={ev => {
-                    setHeight(ghost.current.clientHeight);
-                    props.onKeyUp && props.onKeyUp(ev);
-                }}
-                ref={ref}
-                onFocus={() => props.onFocus && props.onFocus(ref.current)}
-                onBlur={props.onBlur}
-            />
-            <div className={styles.hide}>
-                <div className={styles.ghost} ref={ghost}>
-                    {props.value
-                        ? props.value
-                              .split("\n")
-                              .map(x => `‎${x}`)
-                              .join("\n")
-                        : undefined ?? "‎\n"}
-                </div>
-            </div>
-        </div>
-    );
-});
+    ${(props) =>
+        props.code
+            ? css`
+                  font-family: var(--monospace-font), monospace;
+              `
+            : css`
+                  font-family: inherit;
+              `}
+
+    font-variant-ligatures: var(--ligatures);
+`;

src/components/ui/Tip.tsx

-import styled from "styled-components";
-import { Info } from "@styled-icons/feather";
+import { InfoCircle } from "@styled-icons/boxicons-regular";
+import styled, { css } from "styled-components";
+
 import { Children } from "../../types/Preact";
 
-export const TipBase = styled.div`
+interface Props {
+    warning?: boolean;
+    error?: boolean;
+}
+
+export const Separator = styled.div<Props>`
+    height: 1px;
+    width: calc(100% - 10px);
+    background: var(--secondary-header);
+    margin: 18px auto;
+`;
+
+export const TipBase = styled.div<Props>`
     display: flex;
     padding: 12px;
     overflow: hidden;
     align-items: center;
 
     font-size: 14px;
-    border-radius: 7px;
     background: var(--primary-header);
+    border-radius: var(--border-radius);
     border: 2px solid var(--secondary-header);
 
     a {
@@ -22,15 +35,37 @@ export const TipBase = styled.div`
 
     svg {
         flex-shrink: 0;
-        margin-right: 10px;
+        margin-inline-end: 10px;
     }
+
+    ${(props) =>
+        props.warning &&
+        css`
+            color: var(--warning);
+            border: 2px solid var(--warning);
+            background: var(--secondary-header);
+        `}
+
+    ${(props) =>
+        props.error &&
+        css`
+            color: var(--error);
+            border: 2px solid var(--error);
+            background: var(--secondary-header);
+        `}
 `;
 
-export default function Tip(props: { children: Children }) {
+export default function Tip(
+    props: Props & { children: Children; hideSeparator?: boolean },
+) {
+    const { children, hideSeparator, ...tipProps } = props;
     return (
-        <TipBase>
-            <Info size={20} strokeWidth={2} />
-            <span>{props.children}</span>
-        </TipBase>
+        <>
+            {!hideSeparator && <Separator />}
+            <TipBase {...tipProps}>
+                <InfoCircle size={20} />
+                <span>{children}</span>
+            </TipBase>
+        </>
     );
 }

src/components/ui/fluent/CategoryButton.tsx

+import { ChevronRight, LinkExternal } from "@styled-icons/boxicons-regular";
+import styled, { css } from "styled-components";
+
+import { Children } from "../../../types/Preact";
+
+interface BaseProps {
+    readonly hover?: boolean;
+    readonly account?: boolean;
+    readonly disabled?: boolean;
+    readonly largeDescription?: boolean;
+}
+
+const CategoryBase = styled.div<BaseProps>`
+    /*height: 54px;*/
+    padding: 9.8px 12px;
+    border-radius: 6px;
+    margin-bottom: 10px;
+    color: var(--foreground);
+    background: var(--secondary-header);
+    gap: 12px;
+    display: flex;
+    align-items: center;
+    flex-direction: row;
+
+    > svg {
+        flex-shrink: 0;
+    }
+
+    .content {
+        display: flex;
+        flex-grow: 1;
+        flex-direction: column;
+        font-weight: 600;
+        font-size: 14px;
+
+        .title {
+            display: -webkit-box;
+            -webkit-box-orient: vertical;
+            -webkit-line-clamp: 2;
+            overflow: hidden;
+        }
+
+        .description {
+            ${(props) =>
+                props.largeDescription
+                    ? css`
+                          font-size: 14px;
+                      `
+                    : css`
+                          font-size: 11px;
+                      `}
+
+            font-weight: 400;
+            display: -webkit-box;
+            -webkit-box-orient: vertical;
+            -webkit-line-clamp: 3;
+            overflow: hidden;
+
+            a:hover {
+                text-decoration: underline;
+            }
+        }
+    }
+
+    ${(props) =>
+        props.hover &&
+        css`
+            cursor: pointer;
+            opacity: 1;
+            transition: 0.1s ease background-color;
+
+            &:hover {
+                background: var(--secondary-background);
+            }
+        `}
+
+    ${(props) =>
+        props.disabled &&
+        css`
+            opacity: 0.4;
+            /*.content,
+            .action {
+                color: var(--tertiary-foreground);
+            }*/
+
+            .action {
+                font-size: 14px;
+            }
+        `}
+    
+    ${(props) =>
+        props.account &&
+        css`
+            height: 54px;
+
+            .content {
+                text-overflow: ellipsis;
+                overflow: hidden;
+                white-space: nowrap;
+                .title {
+                    text-transform: uppercase;
+                    font-size: 12px;
+                    color: var(--secondary-foreground);
+                }
+
+                .description {
+                    font-size: 15px;
+
+                    text-overflow: ellipsis;
+                    white-space: nowrap;
+                    overflow: hidden;
+                }
+            }
+        `}
+`;
+
+interface Props extends BaseProps {
+    icon?: Children;
+    children?: Children;
+    description?: Children;
+
+    onClick?: () => void;
+    action?: "chevron" | "external" | Children;
+}
+
+export default function CategoryButton({
+    icon,
+    children,
+    description,
+    account,
+    disabled,
+    onClick,
+    hover,
+    action,
+}: Props) {
+    return (
+        <CategoryBase
+            hover={hover || typeof onClick !== "undefined"}
+            onClick={onClick}
+            disabled={disabled}
+            account={account}>
+            {icon}
+            <div class="content">
+                <div className="title">{children}</div>
+
+                <div className="description">{description}</div>
+            </div>
+            <div class="action">
+                {typeof action === "string" ? (
+                    action === "chevron" ? (
+                        <ChevronRight size={24} />
+                    ) : (
+                        <LinkExternal size={20} />
+                    )
+                ) : (
+                    action
+                )}
+            </div>
+        </CategoryBase>
+    );
+}

src/context/Locale.tsx

+import dayJS from "dayjs";
+import calendar from "dayjs/plugin/calendar";
+import format from "dayjs/plugin/localizedFormat";
+import update from "dayjs/plugin/updateLocale";
+import defaultsDeep from "lodash.defaultsdeep";
+
 import { IntlProvider } from "preact-i18n";
+import { useCallback, useEffect, useState } from "preact/hooks";
+
 import { connectState } from "../redux/connector";
-import { useEffect, useState } from "preact/hooks";
+
 import definition from "../../external/lang/en.json";
 
-import dayjs from "dayjs";
-import calendar from "dayjs/plugin/calendar";
-import update from "dayjs/plugin/updateLocale";
-import format from "dayjs/plugin/localizedFormat";
+export const dayjs = dayJS;
+
 dayjs.extend(calendar);
 dayjs.extend(format);
 dayjs.extend(update);
@@ -18,6 +24,7 @@ export enum Language {
     AZERBAIJANI = "az",
     CZECH = "cs",
     GERMAN = "de",
+    GREEK = "el",
     SPANISH = "es",
     FINNISH = "fi",
     FRENCH = "fr",
@@ -25,6 +32,7 @@ export enum Language {
     CROATIAN = "hr",
     HUNGARIAN = "hu",
     INDONESIAN = "id",
+    ITALIAN = "it",
     LITHUANIAN = "lt",
     MACEDONIAN = "mk",
     DUTCH = "nl",
@@ -34,6 +42,7 @@ export enum Language {
     RUSSIAN = "ru",
     SERBIAN = "sr",
     SWEDISH = "sv",
+    TOKIPONA = "tokipona",
     TURKISH = "tr",
     UKRANIAN = "uk",
     CHINESE_SIMPLIFIED = "zh_Hans",
@@ -42,7 +51,6 @@ export enum Language {
     PIRATE = "pr",
     BOTTOM = "bottom",
     PIGLATIN = "piglatin",
-    HARDCORE = "hardcore",
 }
 
 export interface LanguageEntry {
@@ -51,6 +59,7 @@ export interface LanguageEntry {
     i18n: string;
     dayjs?: string;
     rtl?: boolean;
+    cat?: "const" | "alt";
 }
 
 export const Languages: { [key in Language]: LanguageEntry } = {
@@ -65,13 +74,15 @@ export const Languages: { [key in Language]: LanguageEntry } = {
     az: { display: "Azərbaycan dili", emoji: "🇦🇿", i18n: "az" },
     cs: { display: "Čeština", emoji: "🇨🇿", i18n: "cs" },
     de: { display: "Deutsch", emoji: "🇩🇪", i18n: "de" },
+    el: { display: "Ελληνικά", emoji: "🇬🇷", i18n: "el" },
     es: { display: "Español", emoji: "🇪🇸", i18n: "es" },
     fi: { display: "suomi", emoji: "🇫🇮", i18n: "fi" },
     fr: { display: "Français", emoji: "🇫🇷", i18n: "fr" },
     hi: { display: "हिन्दी", emoji: "🇮🇳", i18n: "hi" },
     hr: { display: "Hrvatski", emoji: "🇭🇷", i18n: "hr" },
-    hu: { display: "magyar", emoji: "🇭🇺", i18n: "hu" },
+    hu: { display: "Magyar", emoji: "🇭🇺", i18n: "hu" },
     id: { display: "bahasa Indonesia", emoji: "🇮🇩", i18n: "id" },
+    it: { display: "Italiano", emoji: "🇮🇹", i18n: "it" },
     lt: { display: "Lietuvių", emoji: "🇱🇹", i18n: "lt" },
     mk: { display: "Македонски", emoji: "🇲🇰", i18n: "mk" },
     nl: { display: "Nederlands", emoji: "🇳🇱", i18n: "nl" },
@@ -95,20 +106,41 @@ export const Languages: { [key in Language]: LanguageEntry } = {
         dayjs: "zh",
     },
 
-    owo: { display: "OwO", emoji: "🐱", i18n: "owo", dayjs: "en-gb" },
-    pr: { display: "Pirate", emoji: "🏴‍☠️", i18n: "pr", dayjs: "en-gb" },
-    bottom: { display: "Bottom", emoji: "🥺", i18n: "bottom", dayjs: "en-gb" },
+    tokipona: {
+        display: "Toki Pona",
+        emoji: "🙂",
+        i18n: "tokipona",
+        dayjs: "en-gb",
+        cat: "const",
+    },
+
+    owo: {
+        display: "OwO",
+        emoji: "🐱",
+        i18n: "owo",
+        dayjs: "en-gb",
+        cat: "alt",
+    },
+    pr: {
+        display: "Pirate",
+        emoji: "🏴‍☠️",
+        i18n: "pr",
+        dayjs: "en-gb",
+        cat: "alt",
+    },
+    bottom: {
+        display: "Bottom",
+        emoji: "🥺",
+        i18n: "bottom",
+        dayjs: "en-gb",
+        cat: "alt",
+    },
     piglatin: {
         display: "Pig Latin",
         emoji: "🐖",
         i18n: "piglatin",
         dayjs: "en-gb",
-    },
-    hardcore: {
-        display: "Hardcore Mode",
-        emoji: "🔥",
-        i18n: "hardcore",
-        dayjs: "en-gb",
+        cat: "alt",
     },
 };
 
@@ -117,40 +149,118 @@ interface Props {
     locale: Language;
 }
 
+export interface Dictionary {
+    dayjs?: {
+        defaults?: {
+            twelvehour?: "yes" | "no";
+            separator?: string;
+            date?: "traditional" | "simplified" | "ISO8601";
+        };
+        timeFormat?: string;
+    };
+    [key: string]:
+        | Record<string, Omit<Dictionary, "dayjs">>
+        | string
+        | undefined;
+}
+
 function Locale({ children, locale }: Props) {
-    const [defns, setDefinition] = useState(definition);
-    const lang = Languages[locale];
+    const [defns, setDefinition] = useState<Dictionary>(
+        definition as Dictionary,
+    );
 
-    useEffect(() => {
-        if (locale === "en") {
-            setDefinition(definition);
-            dayjs.locale("en");
-            return;
-        }
-
-        if (lang.i18n === "hardcore") {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            setDefinition({} as any);
-            return;
-        }
-
-        import(`../../external/lang/${lang.i18n}.json`).then(
-            async (lang_file) => {
-                const defn = lang_file.default;
-                const target = lang.dayjs ?? lang.i18n;
-                const dayjs_locale = await import(`../../node_modules/dayjs/esm/locale/${target}.js`);
-
-                if (defn.dayjs) {
-                    dayjs.updateLocale(target, { calendar: defn.dayjs });
-                }
-
-                dayjs.locale(dayjs_locale.default);
+    // Load relevant language information, fallback to English if invalid.
+    const lang = Languages[locale] ?? Languages.en;
+
+    function transformLanguage(source: Dictionary) {
+        // Fallback untranslated strings to English (UK)
+        const obj = defaultsDeep(source, definition);
+
+        // Take relevant objects out, dayjs and defaults
+        // should exist given we just took defaults above.
+        const { dayjs } = obj;
+        const { defaults } = dayjs;
+
+        // Determine whether we are using 12-hour clock.
+        const twelvehour = defaults?.twelvehour
+            ? defaults.twelvehour === "yes"
+            : false;
+
+        // Determine what date separator we are using.
+        const separator: string = defaults?.date_separator ?? "/";
+
+        // Determine what date format we are using.
+        const date: "traditional" | "simplified" | "ISO8601" =
+            defaults?.date_format ?? "traditional";
+
+        // Available date formats.
+        const DATE_FORMATS = {
+            traditional: `DD${separator}MM${separator}YYYY`,
+            simplified: `MM${separator}DD${separator}YYYY`,
+            ISO8601: "YYYY-MM-DD",
+        };
+
+        // Replace data in dayjs object, make sure to provide fallbacks.
+        dayjs["sameElse"] = DATE_FORMATS[date] ?? DATE_FORMATS.traditional;
+        dayjs["timeFormat"] = twelvehour ? "hh:mm A" : "HH:mm";
+
+        // Replace {{time}} format string in dayjs strings with the time format.
+        Object.keys(dayjs)
+            .filter((k) => typeof dayjs[k] === "string")
+            .forEach(
+                (k) =>
+                    (dayjs[k] = dayjs[k].replace(
+                        /{{time}}/g,
+                        dayjs["timeFormat"],
+                    )),
+            );
+
+        return obj;
+    }
+
+    const loadLanguage = useCallback(
+        (locale: string) => {
+            if (locale === "en") {
+                // If English, make sure to restore everything to defaults.
+                // Use what we already have.
+                const defn = transformLanguage(definition as Dictionary);
                 setDefinition(defn);
+                dayjs.locale("en");
+                dayjs.updateLocale("en", { calendar: defn.dayjs });
+                return;
             }
-        );
-    }, [locale, lang]);
+
+            import(`../../external/lang/${lang.i18n}.json`).then(
+                async (lang_file) => {
+                    // Transform the definitions data.
+                    const defn = transformLanguage(lang_file.default);
+
+                    // Determine and load dayjs locales.
+                    const target = lang.dayjs ?? lang.i18n;
+                    const dayjs_locale = await import(
+                        `../../node_modules/dayjs/esm/locale/${target}.js`
+                    );
+
+                    // Load dayjs locales.
+                    dayjs.locale(target, dayjs_locale.default);
+
+                    if (defn.dayjs) {
+                        // Override dayjs calendar locales with our own.
+                        dayjs.updateLocale(target, { calendar: defn.dayjs });
+                    }
+
+                    // Apply definition to app.
+                    setDefinition(defn);
+                },
+            );
+        },
+        [lang.dayjs, lang.i18n],
+    );
+
+    useEffect(() => loadLanguage(locale), [locale, lang, loadLanguage]);
 
     useEffect(() => {
+        // Apply RTL language format.
         document.body.style.direction = lang.rtl ? "rtl" : "";
     }, [lang.rtl]);
 
@@ -164,5 +274,5 @@ export default connectState<Omit<Props, "locale">>(
             locale: state.locale,
         };
     },
-    true
+    true,
 );

src/context/Settings.tsx

@@ -4,29 +4,58 @@
 //
 // Replace references to SettingsContext with connectState in the future
 // if it does cause problems though.
+//
+// This now also supports Audio stuff.
+import defaultsDeep from "lodash.defaultsdeep";
+
+import { createContext } from "preact";
+import { useMemo } from "preact/hooks";
 
-import { Settings } from "../redux/reducers/settings";
 import { connectState } from "../redux/connector";
+import {
+    DEFAULT_SOUNDS,
+    Settings,
+    SoundOptions,
+} from "../redux/reducers/settings";
+
+import { playSound, Sounds } from "../assets/sounds/Audio";
 import { Children } from "../types/Preact";
-import { createContext } from "preact";
 
-export const SettingsContext = createContext<Settings>({} as any);
+export const SettingsContext = createContext<Settings>({});
+export const SoundContext = createContext<(sound: Sounds) => void>(null!);
 
 interface Props {
-    children?: Children,
-    settings: Settings
+    children?: Children;
+    settings: Settings;
 }
 
-function Settings(props: Props) {
+function SettingsProvider({ settings, children }: Props) {
+    const play = useMemo(() => {
+        const enabled: SoundOptions = defaultsDeep(
+            settings.notification?.sounds ?? {},
+            DEFAULT_SOUNDS,
+        );
+        return (sound: Sounds) => {
+            if (enabled[sound]) {
+                playSound(sound);
+            }
+        };
+    }, [settings.notification]);
+
     return (
-        <SettingsContext.Provider value={props.settings}>
-            { props.children }
+        <SettingsContext.Provider value={settings}>
+            <SoundContext.Provider value={play}>
+                {children}
+            </SoundContext.Provider>
         </SettingsContext.Provider>
-    )
+    );
 }
 
-export default connectState(Settings, state => {
-    return {
-        settings: state.settings
-    }
-});
+export default connectState<Omit<Props, "settings">>(
+    SettingsProvider,
+    (state) => {
+        return {
+            settings: state.settings,
+        };
+    },
+);