chore: move frontend files

frontend/src/components/input/AsyncEditor.ts

@@ -0,0 +1,5 @@
+import {createAsyncComponent} from '@/helpers/createAsyncComponent'
+
+const TipTap = createAsyncComponent(() => import('@/components/input/editor/TipTap.vue'))
+
+export default TipTap

frontend/src/components/input/Button.story.vue

@@ -0,0 +1,35 @@
+<script lang="ts" setup>
+import {logEvent} from 'histoire/client'
+import XButton from './button.vue'
+</script>
+
+<template>
+	<Story :layout="{ type: 'grid', width: '200px' }">
+		<Variant title="primary">
+			<XButton
+				variant="primary"
+				@click="logEvent('Click', $event)"
+			>
+				Order pizza!
+			</XButton>
+		</Variant>
+
+		<Variant title="secondary">
+			<XButton
+				variant="secondary"
+				@click="logEvent('Click', $event)"
+			>
+				Order spaghetti!
+			</XButton>
+		</Variant>
+
+		<Variant title="tertiary">
+			<XButton
+				variant="tertiary"
+				@click="logEvent('Click', $event)"
+			>
+				Order tortellini!
+			</XButton>
+		</Variant>
+	</Story>
+</template>

frontend/src/components/input/ColorPicker.story.vue

@@ -0,0 +1,14 @@
+<script lang="ts" setup>
+import {reactive} from 'vue'
+import ColorPicker from './ColorPicker.vue'
+
+const state = reactive({
+	color: '#f2f2f2',
+})
+</script>
+
+<template>
+	<Story :layout="{ type: 'grid', width: '200px' }">
+		<ColorPicker v-model="state.color" />
+	</Story>
+</template>

frontend/src/components/input/ColorPicker.vue

@@ -0,0 +1,187 @@
+<template>
+	<div class="color-picker-container">
+		<datalist :id="colorListID">
+			<option
+				v-for="defaultColor in defaultColors"
+				:key="defaultColor"
+				:value="defaultColor"
+			/>
+		</datalist>
+		
+		<div class="picker">
+			<input
+				v-model="color"
+				class="picker__input"
+				type="color"
+				:list="colorListID"
+				:class="{'is-empty': isEmpty}"
+			>
+			<svg
+				v-show="isEmpty"
+				class="picker__pattern"
+				viewBox="0 0 22 22"
+				fill="fff"
+			>
+				<pattern
+					id="checker"
+					width="11"
+					height="11"
+					patternUnits="userSpaceOnUse"
+					fill="FFF"
+				>
+					<rect
+						fill="#cccccc"
+						x="0"
+						width="5.5"
+						height="5.5"
+						y="0"
+					/>
+					<rect
+						fill="#cccccc"
+						x="5.5"
+						width="5.5"
+						height="5.5"
+						y="5.5"
+					/>
+				</pattern>
+				<rect
+					width="22"
+					height="22"
+					fill="url(#checker)"
+				/>
+			</svg>
+		</div>
+
+		<XButton
+			v-if="!isEmpty"
+			:disabled="isEmpty"
+			class="is-small ml-2"
+			:shadow="false"
+			variant="secondary"
+			@click="reset"
+		>
+			{{ $t('input.resetColor') }}
+		</XButton>
+	</div>
+</template>
+
+<script setup lang="ts">
+import {computed, ref, watch} from 'vue'
+import {createRandomID} from '@/helpers/randomId'
+import XButton from '@/components/input/button.vue'
+
+const {
+	modelValue,
+} = defineProps<{
+	modelValue: string,
+}>()
+
+const emit = defineEmits(['update:modelValue'])
+
+const DEFAULT_COLORS = [
+	'#1973ff',
+	'#7F23FF',
+	'#ff4136',
+	'#ff851b',
+	'#ffeb10',
+	'#00db60',
+]
+
+const color = ref('')
+const lastChangeTimeout = ref<ReturnType<typeof setTimeout> | null>(null)
+const defaultColors = ref(DEFAULT_COLORS)
+const colorListID = ref(createRandomID())
+
+watch(
+	() => modelValue,
+	(newValue) => {
+		if (newValue === '' || newValue.startsWith('var(')) {
+			color.value = ''
+			return
+		}
+
+		if (!newValue.startsWith('#') && (newValue.length === 6 || newValue.length === 3)) {
+			newValue = `#${newValue}`
+		}
+
+		color.value = newValue
+	},
+	{immediate: true},
+)
+
+watch(color, () => update())
+
+const isEmpty = computed(() => color.value === '#000000' || color.value === '')
+
+function update(force = false) {
+	if(isEmpty.value && !force) {
+		return
+	}
+
+	if (lastChangeTimeout.value !== null) {
+		clearTimeout(lastChangeTimeout.value)
+	}
+
+	lastChangeTimeout.value = setTimeout(() => {
+		emit('update:modelValue', color.value)
+	}, 500)
+}
+
+function reset() {
+	// FIXME: I havn't found a way to make it clear to the user the color war reset.
+	//  Not sure if verte is capable of this - it does not show the change when setting this.color = ''
+	color.value = ''
+	update(true)
+}
+</script>
+
+<style lang="scss" scoped>
+.color-picker-container {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+
+	// reset / see https://stackoverflow.com/a/11471224/15522256
+	input[type="color"] {
+		-webkit-appearance: none;
+		border: none;
+	}
+	input[type="color"]::-webkit-color-swatch-wrapper {
+		padding: 0;
+	}
+	input[type="color"]::-webkit-color-swatch {
+		border: none;
+	}
+
+	$PICKER_SIZE: 24px;
+	$BORDER_WIDTH: 1px;
+	.picker {
+		display: grid;
+		width: $PICKER_SIZE;
+		height: $PICKER_SIZE;
+		overflow: hidden;
+		border-radius: 100%;
+		border: $BORDER_WIDTH solid var(--grey-300);
+		box-shadow: $shadow;
+
+		& > * {
+			grid-row: 1;
+			grid-column: 1;
+		}
+	}
+
+	input.picker__input {
+		padding: 0;
+		width: $PICKER_SIZE - 2 * $BORDER_WIDTH;
+		height: $PICKER_SIZE - 2 * $BORDER_WIDTH;
+	}
+
+	.picker__input.is-empty {
+		opacity: 0;
+	}
+	
+	.picker__pattern {
+		pointer-events: none;
+	}
+}
+</style>

frontend/src/components/input/SelectProject.vue

@@ -0,0 +1,74 @@
+<template>
+	<Multiselect
+		v-model="selectedProjects"
+		:search-results="foundProjects"
+		:loading="projectService.loading"
+		:multiple="true"
+		:placeholder="$t('project.search')"
+		label="title"
+		@search="findProjects"
+	/>
+</template>
+
+<script setup lang="ts">
+import {computed, ref, shallowReactive, watchEffect, type PropType} from 'vue'
+
+import Multiselect from '@/components/input/multiselect.vue'
+
+import type {IProject} from '@/modelTypes/IProject'
+
+import ProjectService from '@/services/project'
+import {includesById} from '@/helpers/utils'
+
+type ProjectFilterFunc = (p: IProject) => boolean
+
+const props = defineProps({
+	modelValue: {
+		type: Array as PropType<IProject[]>,
+		default: () => [],
+	},
+	projectFilter: {
+		type: Function as PropType<ProjectFilterFunc>,
+		default: () => {
+			// eslint-disable-next-line @typescript-eslint/no-unused-vars
+			return (_: IProject) => true
+		},
+	},
+})
+const emit = defineEmits<{
+	(e: 'update:modelValue', value: IProject[]): void
+}>()
+
+const projects = ref<IProject[]>([])
+
+watchEffect(() => {
+	projects.value = props.modelValue
+})
+
+const selectedProjects = computed({
+	get() {
+		return projects.value
+	},
+	set: (value) => {
+		projects.value = value
+		emit('update:modelValue', value)
+	},
+})
+
+const projectService = shallowReactive(new ProjectService())
+const foundProjects = ref<IProject[]>([])
+
+async function findProjects(query: string) {
+	if (query === '') {
+		foundProjects.value = []
+		return
+	}
+
+	const response = await projectService.getAll({}, {s: query}) as IProject[]
+
+	// Filter selected items from the results
+	foundProjects.value = response
+		.filter(({id}) => !includesById(projects.value, id))
+		.filter(props.projectFilter)
+}
+</script>

frontend/src/components/input/SelectUser.vue

@@ -0,0 +1,63 @@
+<template>
+	<Multiselect
+		v-model="selectedUsers"
+		:search-results="foundUsers"
+		:loading="userService.loading"
+		:multiple="true"
+		:placeholder="$t('team.edit.search')"
+		label="username"
+		@search="findUsers"
+	/>
+</template>
+
+<script setup lang="ts">
+import {computed, ref, shallowReactive, watchEffect, type PropType} from 'vue'
+
+import Multiselect from '@/components/input/multiselect.vue'
+
+import type {IUser} from '@/modelTypes/IUser'
+
+import UserService from '@/services/user'
+import {includesById} from '@/helpers/utils'
+
+const props = defineProps({
+	modelValue: {
+		type: Array as PropType<IUser[]>,
+		default: () => [],
+	},
+})
+const emit = defineEmits<{
+	(e: 'update:modelValue', value: IUser[]): void
+}>()
+
+const users = ref<IUser[]>([])
+
+watchEffect(() => {
+	users.value = props.modelValue
+})
+
+const selectedUsers = computed({
+	get() {
+		return users.value
+	},
+	set: (value) => {
+		users.value = value
+		emit('update:modelValue', value)
+	},
+})
+
+const userService = shallowReactive(new UserService())
+const foundUsers = ref<IUser[]>([])
+
+async function findUsers(query: string) {
+	if (query === '') {
+		foundUsers.value = []
+		return
+	}
+
+	const response = await userService.getAll({}, {s: query}) as IUser[]
+
+	// Filter selected items from the results
+	foundUsers.value = response.filter(({id}) => !includesById(users.value, id))
+}
+</script>

frontend/src/components/input/SimpleButton.vue

@@ -0,0 +1,26 @@
+<template>
+	<BaseButton class="simple-button">
+		<slot />
+	</BaseButton>
+</template>
+
+<script lang="ts" setup>
+import BaseButton from '@/components/base/BaseButton.vue'
+</script>
+
+<style lang="scss" scoped>
+.simple-button {
+	color: var(--text);
+	padding: .25rem .5rem;
+	transition: background-color $transition;
+	border-radius: $radius;
+	display: block;
+	margin: .1rem 0;
+	width: 100%;
+	text-align: left;
+
+	&:hover {
+		background: var(--white);
+	}
+}
+</style>

frontend/src/components/input/button.vue

@@ -0,0 +1,119 @@
+<template>
+	<BaseButton
+		class="button"
+		:class="[
+			variantClass,
+			{
+				'is-loading': loading,
+				'has-no-shadow': !shadow || variant === 'tertiary',
+			}
+		]"
+		:style="{
+			'--button-white-space': wrap ? 'break-spaces' : 'nowrap',
+		}"
+	>
+		<template v-if="icon">
+			<icon 
+				v-if="showIconOnly"
+				:icon="icon"
+				:style="{'color': iconColor !== '' ? iconColor : undefined}"
+			/>
+			<span
+				v-else
+				class="icon is-small"
+			>
+				<icon 
+					:icon="icon"
+					:style="{'color': iconColor !== '' ? iconColor : undefined}"
+				/>
+			</span>
+		</template>
+		<slot />
+	</BaseButton>
+</template>
+
+<script lang="ts">
+const BUTTON_TYPES_MAP = {
+  primary: 'is-primary',
+  secondary: 'is-outlined',
+  tertiary: 'is-text is-inverted underline-none',
+} as const
+
+export type ButtonTypes = keyof typeof BUTTON_TYPES_MAP
+
+export default { name: 'XButton' }
+</script>
+
+<script setup lang="ts">
+import {computed, useSlots} from 'vue'
+import BaseButton, {type BaseButtonProps} from '@/components/base/BaseButton.vue'
+import type { IconProp } from '@fortawesome/fontawesome-svg-core'
+
+// extending the props of the BaseButton
+export interface ButtonProps extends /* @vue-ignore */ BaseButtonProps {
+	variant?: ButtonTypes
+	icon?: IconProp
+	iconColor?: string
+	loading?: boolean
+	shadow?: boolean
+	wrap?: boolean
+}
+
+const {
+	variant = 'primary',
+	icon = '',
+	iconColor = '',
+	loading = false,
+	shadow = true,
+	wrap = true,
+} = defineProps<ButtonProps>()
+
+const variantClass = computed(() => BUTTON_TYPES_MAP[variant])
+
+const slots = useSlots()
+const showIconOnly = computed(() => icon !== '' && typeof slots.default === 'undefined')
+</script>
+
+<style lang="scss" scoped>
+.button {
+  transition: all $transition;
+  border: 0;
+  text-transform: uppercase;
+  font-size: 0.85rem;
+  font-weight: bold;
+  height: auto;
+  min-height: $button-height;
+  box-shadow: var(--shadow-sm);
+  display: inline-flex;
+  white-space: var(--button-white-space);
+
+  &:hover {
+    box-shadow: var(--shadow-md);
+  }
+
+  &.fullheight {
+    padding-right: 7px;
+    height: 100%;
+  }
+
+  &.is-active,
+  &.is-focused,
+  &:active,
+  &:focus,
+  &:focus:not(:active) {
+    box-shadow: var(--shadow-xs) !important;
+  }
+
+  &.is-primary.is-outlined:hover {
+    color: var(--white);
+  }
+}
+
+.is-small {
+	border-radius: $radius;
+}
+
+.underline-none {
+  text-decoration: none !important;
+}
+</style>

frontend/src/components/input/datepicker.vue

@@ -0,0 +1,153 @@
+<template>
+	<div class="datepicker">
+		<SimpleButton
+			class="show"
+			:disabled="disabled || undefined"
+			@click.stop="toggleDatePopup"
+		>
+			{{ date === null ? chooseDateLabel : formatDateShort(date) }}
+		</SimpleButton>
+
+		<CustomTransition name="fade">
+			<div
+				v-if="show"
+				ref="datepickerPopup"
+				class="datepicker-popup"
+			>
+				<DatepickerInline
+					v-model="date"
+					@update:modelValue="updateData"
+				/>
+
+				<x-button
+					v-cy="'closeDatepicker'"
+					class="datepicker__close-button"
+					:shadow="false"
+					@click="close"
+				>
+					{{ $t('misc.confirm') }}
+				</x-button>
+			</div>
+		</CustomTransition>
+	</div>
+</template>
+
+<script setup lang="ts">
+import {ref, onMounted, onBeforeUnmount, toRef, watch, type PropType} from 'vue'
+
+import CustomTransition from '@/components/misc/CustomTransition.vue'
+import DatepickerInline from '@/components/input/datepickerInline.vue'
+import SimpleButton from '@/components/input/SimpleButton.vue'
+
+import {formatDateShort} from '@/helpers/time/formatDate'
+import {closeWhenClickedOutside} from '@/helpers/closeWhenClickedOutside'
+import {createDateFromString} from '@/helpers/time/createDateFromString'
+import {useI18n} from 'vue-i18n'
+
+const props = defineProps({
+	modelValue: {
+		type: [Date, null, String] as PropType<Date | null | string>,
+		validator: prop => prop instanceof Date || prop === null || typeof prop === 'string',
+		default: null,
+	},
+	chooseDateLabel: {
+		type: String,
+		default() {
+			const {t} = useI18n({useScope: 'global'})
+			return t('input.datepicker.chooseDate')
+		},
+	},
+	disabled: {
+		type: Boolean,
+		default: false,
+	},
+})
+
+const emit = defineEmits(['update:modelValue', 'close', 'closeOnChange'])
+
+const date = ref<Date | null>()
+const show = ref(false)
+const changed = ref(false)
+
+onMounted(() => document.addEventListener('click', hideDatePopup))
+onBeforeUnmount(() =>document.removeEventListener('click', hideDatePopup))
+
+const modelValue = toRef(props, 'modelValue')
+watch(
+	modelValue,
+	setDateValue,
+	{immediate: true},
+)
+
+function setDateValue(dateString: string | Date | null) {
+	if (dateString === null) {
+		date.value = null
+		return
+	}
+	date.value = createDateFromString(dateString)
+}
+
+function updateData() {
+	changed.value = true
+	emit('update:modelValue', date.value)
+}
+
+function toggleDatePopup() {
+	if (props.disabled) {
+		return
+	}
+
+	show.value = !show.value
+}
+
+const datepickerPopup = ref<HTMLElement | null>(null)
+function hideDatePopup(e: MouseEvent) {
+	if (show.value) {
+		closeWhenClickedOutside(e, datepickerPopup.value, close)
+	}
+}
+
+function close() {
+	// Kind of dirty, but the timeout allows us to enter a time and click on "confirm" without
+	// having to click on another input field before it is actually used.
+	setTimeout(() => {
+		show.value = false
+		emit('close', changed.value)
+		if (changed.value) {
+			changed.value = false
+			emit('closeOnChange', changed.value)
+		}
+	}, 200)
+}
+</script>
+
+<style lang="scss" scoped>
+.datepicker {
+	input.input {
+		display: none;
+	}
+}
+
+.datepicker-popup {
+	position: absolute;
+	z-index: 99;
+	width: 320px;
+	background: var(--white);
+	border-radius: $radius;
+	box-shadow: $shadow;
+
+	@media screen and (max-width: ($tablet)) {
+		width: calc(100vw - 5rem);
+	}
+}
+
+.datepicker__close-button {
+	margin: 1rem;
+	width: calc(100% - 2rem);
+}
+
+:deep(.flatpickr-calendar) {
+	margin: 0 auto 8px;
+	box-shadow: none;
+}
+</style>

frontend/src/components/input/datepickerInline.vue

@@ -0,0 +1,225 @@
+<template>
+	<BaseButton
+		v-if="(new Date()).getHours() < 21"
+		class="datepicker__quick-select-date"
+		@click.stop="setDate('today')"
+	>
+		<span class="icon"><icon :icon="['far', 'calendar-alt']" /></span>
+		<span class="text">
+			<span>{{ $t('input.datepicker.today') }}</span>
+			<span class="weekday">{{ getWeekdayFromStringInterval('today') }}</span>
+		</span>
+	</BaseButton>
+	<BaseButton
+		class="datepicker__quick-select-date"
+		@click.stop="setDate('tomorrow')"
+	>
+		<span class="icon"><icon :icon="['far', 'sun']" /></span>
+		<span class="text">
+			<span>{{ $t('input.datepicker.tomorrow') }}</span>
+			<span class="weekday">{{ getWeekdayFromStringInterval('tomorrow') }}</span>
+		</span>
+	</BaseButton>
+	<BaseButton
+		class="datepicker__quick-select-date"
+		@click.stop="setDate('nextMonday')"
+	>
+		<span class="icon"><icon icon="coffee" /></span>
+		<span class="text">
+			<span>{{ $t('input.datepicker.nextMonday') }}</span>
+			<span class="weekday">{{ getWeekdayFromStringInterval('nextMonday') }}</span>
+		</span>
+	</BaseButton>
+	<BaseButton
+		class="datepicker__quick-select-date"
+		@click.stop="setDate('thisWeekend')"
+	>
+		<span class="icon"><icon icon="cocktail" /></span>
+		<span class="text">
+			<span>{{ $t('input.datepicker.thisWeekend') }}</span>
+			<span class="weekday">{{ getWeekdayFromStringInterval('thisWeekend') }}</span>
+		</span>
+	</BaseButton>
+	<BaseButton
+		class="datepicker__quick-select-date"
+		@click.stop="setDate('laterThisWeek')"
+	>
+		<span class="icon"><icon icon="chess-knight" /></span>
+		<span class="text">
+			<span>{{ $t('input.datepicker.laterThisWeek') }}</span>
+			<span class="weekday">{{ getWeekdayFromStringInterval('laterThisWeek') }}</span>
+		</span>
+	</BaseButton>
+	<BaseButton
+		class="datepicker__quick-select-date"
+		@click.stop="setDate('nextWeek')"
+	>
+		<span class="icon"><icon icon="forward" /></span>
+		<span class="text">
+			<span>{{ $t('input.datepicker.nextWeek') }}</span>
+			<span class="weekday">{{ getWeekdayFromStringInterval('nextWeek') }}</span>
+		</span>
+	</BaseButton>
+
+	<div class="flatpickr-container">
+		<flat-pickr
+			v-model="flatPickrDate"
+			:config="flatPickerConfig"
+		/>
+	</div>
+</template>
+
+<script lang="ts" setup>
+import {ref, toRef, watch, computed, type PropType} from 'vue'
+import flatPickr from 'vue-flatpickr-component'
+import 'flatpickr/dist/flatpickr.css'
+
+import BaseButton from '@/components/base/BaseButton.vue'
+
+import {formatDate} from '@/helpers/time/formatDate'
+import {calculateDayInterval} from '@/helpers/time/calculateDayInterval'
+import {calculateNearestHours} from '@/helpers/time/calculateNearestHours'
+import {createDateFromString} from '@/helpers/time/createDateFromString'
+import {useI18n} from 'vue-i18n'
+import { getFlatpickrLanguage } from '@/helpers/flatpickrLanguage'
+
+const props = defineProps({
+	modelValue: {
+		type: [Date, null, String] as PropType<Date | null | string>,
+		validator: prop => prop instanceof Date || prop === null || typeof prop === 'string',
+		default: null,
+	},
+})
+
+const emit = defineEmits(['update:modelValue', 'close-on-change'])
+
+const {t} = useI18n({useScope: 'global'})
+
+const date = ref<Date | null>()
+const changed = ref(false)
+
+const modelValue = toRef(props, 'modelValue')
+watch(
+	modelValue,
+	setDateValue,
+	{immediate: true},
+)
+
+const flatPickerConfig = computed(() => ({
+	altFormat: t('date.altFormatLong'),
+	altInput: true,
+	dateFormat: 'Y-m-d H:i',
+	enableTime: true,
+	time_24hr: true,
+	inline: true,
+	locale: getFlatpickrLanguage(),
+}))
+
+// Since flatpickr dates are strings, we need to convert them to native date objects.
+// To make that work, we need a separate variable since flatpickr does not have a change event.
+const flatPickrDate = computed({
+	set(newValue: string | Date | null) {
+		if (newValue === null) {
+			date.value = null
+			return
+		}
+
+		if (date.value !== null) {
+			const oldDate = formatDate(date.value, 'yyy-LL-dd H:mm')
+			if (oldDate === newValue) {
+				return
+			}
+		}
+		date.value = createDateFromString(newValue)
+		updateData()
+	},
+	get() {
+		if (!date.value) {
+			return ''
+		}
+
+		return formatDate(date.value, 'yyy-LL-dd H:mm')
+	},
+})
+
+
+function setDateValue(dateString: string | Date | null) {
+	if (dateString === null) {
+		date.value = null
+		return
+	}
+	date.value = createDateFromString(dateString)
+}
+
+function updateData() {
+	changed.value = true
+	emit('update:modelValue', date.value)
+}
+
+function setDate(dateString: string) {
+	const interval = calculateDayInterval(dateString)
+	const newDate = new Date()
+	newDate.setDate(newDate.getDate() + interval)
+	newDate.setHours(calculateNearestHours(newDate))
+	newDate.setMinutes(0)
+	newDate.setSeconds(0)
+	date.value = newDate
+	updateData()
+}
+
+function getWeekdayFromStringInterval(dateString: string) {
+	const interval = calculateDayInterval(dateString)
+	const newDate = new Date()
+	newDate.setDate(newDate.getDate() + interval)
+	return formatDate(newDate, 'E')
+}
+</script>
+
+<style lang="scss" scoped>
+.datepicker__quick-select-date {
+	display: flex;
+	align-items: center;
+	padding: 0 .5rem;
+	width: 100%;
+	height: 2.25rem;
+	color: var(--text);
+	transition: all $transition;
+
+	&:first-child {
+		border-radius: $radius $radius 0 0;
+	}
+
+	&:hover {
+		background: var(--grey-100);
+	}
+
+	.text {
+		width: 100%;
+		font-size: .85rem;
+		display: flex;
+		justify-content: space-between;
+		padding-right: .25rem;
+
+		.weekday {
+			color: var(--text-light);
+			text-transform: capitalize;
+		}
+	}
+
+	.icon {
+		width: 2rem;
+		text-align: center;
+	}
+}
+
+.flatpickr-container {
+	:deep(.flatpickr-calendar) {
+		margin: 0 auto 8px;
+		box-shadow: none;
+	}
+
+	:deep(.input) {
+		border: none;
+	}
+}
+</style>

frontend/src/components/input/editor/CommandsList.vue

@@ -0,0 +1,149 @@
+<template>
+	<div class="items">
+		<template v-if="items.length">
+			<button
+				v-for="(item, index) in items"
+				:key="index"
+				class="item"
+				:class="{ 'is-selected': index === selectedIndex }"
+				@click="selectItem(index)"
+			>
+				<icon :icon="item.icon" />
+				<div class="description">
+					<p>{{ item.title }}</p>
+					<p>{{ item.description }}</p>
+				</div>
+			</button>
+		</template>
+		<div
+			v-else
+			class="item"
+		>
+			No result
+		</div>
+	</div>
+</template>
+
+<script lang="ts">
+/* eslint-disable vue/component-api-style */
+export default {
+	props: {
+		items: {
+			type: Array,
+			required: true,
+		},
+
+		command: {
+			type: Function,
+			required: true,
+		},
+	},
+
+	data() {
+		return {
+			selectedIndex: 0,
+		}
+	},
+
+	watch: {
+		items() {
+			this.selectedIndex = 0
+		},
+	},
+
+	methods: {
+		onKeyDown({event}) {
+			if (event.key === 'ArrowUp') {
+				this.upHandler()
+				return true
+			}
+
+			if (event.key === 'ArrowDown') {
+				this.downHandler()
+				return true
+			}
+
+			if (event.key === 'Enter') {
+				this.enterHandler()
+				return true
+			}
+
+			return false
+		},
+
+		upHandler() {
+			this.selectedIndex = ((this.selectedIndex + this.items.length) - 1) % this.items.length
+		},
+
+		downHandler() {
+			this.selectedIndex = (this.selectedIndex + 1) % this.items.length
+		},
+
+		enterHandler() {
+			this.selectItem(this.selectedIndex)
+		},
+
+		selectItem(index) {
+			const item = this.items[index]
+
+			if (item) {
+				this.command(item)
+			}
+		},
+	},
+}
+</script>
+
+<style lang="scss" scoped>
+.items {
+	padding: 0.2rem;
+	position: relative;
+	border-radius: 0.5rem;
+	background: var(--white);
+	color: var(--grey-900);
+	overflow: hidden;
+	font-size: 0.9rem;
+	box-shadow: var(--shadow-md);
+}
+
+.item {
+	display: flex;
+	align-items: center;
+	margin: 0;
+	width: 100%;
+	text-align: left;
+	background: transparent;
+	border-radius: $radius;
+	border: 0;
+	padding: 0.2rem 0.4rem;
+	transition: background-color $transition;
+
+	&.is-selected, &:hover {
+		background: var(--grey-100);
+		cursor: pointer;
+	}
+	
+	> svg {
+		box-sizing: border-box;
+		width: 2rem;
+		height: 2rem;
+		border: 1px solid var(--grey-300);
+		padding: .5rem;
+		margin-right: .5rem;
+		border-radius: $radius;
+		color: var(--grey-700);
+	}
+}
+
+.description {
+	display: flex;
+	flex-direction: column;
+	font-size: .9rem;
+	color: var(--grey-800);
+	
+	p:last-child {
+		font-size: .75rem;
+		color: var(--grey-500);
+	}
+}
+</style>

frontend/src/components/input/editor/EditorToolbar.vue

@@ -0,0 +1,422 @@
+<template>
+	<div class="editor-toolbar">
+		<div class="editor-toolbar__segment">
+			<BaseButton
+				v-tooltip="$t('input.editor.heading1')"
+				class="editor-toolbar__button"
+				:class="{ 'is-active': editor.isActive('heading', { level: 1 }) }"
+				@click="editor.chain().focus().toggleHeading({ level: 1 }).run()"
+			>
+				<span class="icon">
+					<icon :icon="['fa', 'fa-header']" />
+					<span class="icon__lower-text">1</span>
+				</span>
+			</BaseButton>
+			<BaseButton
+				v-tooltip="$t('input.editor.heading2')"
+				class="editor-toolbar__button"
+				:class="{ 'is-active': editor.isActive('heading', { level: 2 }) }"
+				@click="editor.chain().focus().toggleHeading({ level: 2 }).run()"
+			>
+				<span class="icon">
+					<icon :icon="['fa', 'fa-header']" />
+					<span class="icon__lower-text">2</span>
+				</span>
+			</BaseButton>
+			<BaseButton
+				v-tooltip="$t('input.editor.heading3')"
+				class="editor-toolbar__button"
+				:class="{ 'is-active': editor.isActive('heading', { level: 3 }) }"
+				@click="editor.chain().focus().toggleHeading({ level: 3 }).run()"
+			>
+				<span class="icon">
+					<icon :icon="['fa', 'fa-header']" />
+					<span class="icon__lower-text">3</span>
+				</span>
+			</BaseButton>
+		</div>
+
+		<div class="editor-toolbar__segment">
+			<BaseButton
+				v-tooltip="$t('input.editor.bold')"
+				class="editor-toolbar__button"
+				:class="{ 'is-active': editor.isActive('bold') }"
+				@click="editor.chain().focus().toggleBold().run()"
+			>
+				<span class="icon">
+					<icon :icon="['fa', 'fa-bold']" />
+				</span>
+			</BaseButton>
+			<BaseButton
+				v-tooltip="$t('input.editor.italic')"
+				class="editor-toolbar__button"
+				:class="{ 'is-active': editor.isActive('italic') }"
+				@click="editor.chain().focus().toggleItalic().run()"
+			>
+				<span class="icon">
+					<icon :icon="['fa', 'fa-italic']" />
+				</span>
+			</BaseButton>
+			<BaseButton
+				v-tooltip="$t('input.editor.underline')"
+				class="editor-toolbar__button"
+				:class="{ 'is-active': editor.isActive('underline') }"
+				@click="editor.chain().focus().toggleUnderline().run()"
+			>
+				<span class="icon">
+					<icon :icon="['fa', 'fa-underline']" />
+				</span>
+			</BaseButton>
+			<BaseButton
+				v-tooltip="$t('input.editor.strikethrough')"
+				class="editor-toolbar__button"
+				:class="{ 'is-active': editor.isActive('strike') }"
+				@click="editor.chain().focus().toggleStrike().run()"
+			>
+				<span class="icon">
+					<icon :icon="['fa', 'fa-strikethrough']" />
+				</span>
+			</BaseButton>
+		</div>
+
+		<div class="editor-toolbar__segment">
+			<BaseButton
+				v-tooltip="$t('input.editor.code')"
+				class="editor-toolbar__button"
+				:class="{ 'is-active': editor.isActive('codeBlock') }"
+				@click="editor.chain().focus().toggleCodeBlock().run()"
+			>
+				<span class="icon">
+					<icon :icon="['fa', 'fa-code']" />
+				</span>
+			</BaseButton>
+			<BaseButton
+				v-tooltip="$t('input.editor.quote')"
+				class="editor-toolbar__button"
+				:class="{ 'is-active': editor.isActive('blockquote') }"
+				@click="editor.chain().focus().toggleBlockquote().run()"
+			>
+				<span class="icon">
+					<icon :icon="['fa', 'fa-quote-right']" />
+				</span>
+			</BaseButton>
+		</div>
+
+		<div class="editor-toolbar__segment">
+			<BaseButton
+				v-tooltip="$t('input.editor.bulletList')"
+				class="editor-toolbar__button"
+				:class="{ 'is-active': editor.isActive('bulletList') }"
+				@click="editor.chain().focus().toggleBulletList().run()"
+			>
+				<span class="icon">
+					<icon :icon="['fa', 'fa-list-ul']" />
+				</span>
+			</BaseButton>
+			<BaseButton
+				v-tooltip="$t('input.editor.orderedList')"
+				class="editor-toolbar__button"
+				:class="{ 'is-active': editor.isActive('orderedList') }"
+				@click="editor.chain().focus().toggleOrderedList().run()"
+			>
+				<span class="icon">
+					<icon :icon="['fa', 'fa-list-ol']" />
+				</span>
+			</BaseButton>
+			<BaseButton
+				v-tooltip="$t('input.editor.taskList')"
+				class="editor-toolbar__button"
+				:class="{ 'is-active': editor.isActive('taskList') }"
+				@click="editor.chain().focus().toggleTaskList().run()"
+			>
+				<span class="icon">
+					<icon icon="fa-list-check" />
+				</span>
+			</BaseButton>
+		</div>
+
+		<div class="editor-toolbar__segment">
+			<BaseButton
+				v-tooltip="$t('input.editor.image')" 
+				class="editor-toolbar__button" 
+				@click="openImagePicker"
+			>
+				<span class="icon">
+					<icon icon="fa-image" />
+				</span>
+			</BaseButton>
+		</div>
+
+		<div class="editor-toolbar__segment">
+			<BaseButton
+				v-tooltip="$t('input.editor.link')"
+				class="editor-toolbar__button"
+				:class="{ 'is-active': editor.isActive('link') }"
+				title="set link"
+				@click="setLink"
+			>
+				<span class="icon">
+					<icon :icon="['fa', 'fa-link']" />
+				</span>
+			</BaseButton>
+			<BaseButton
+				v-tooltip="$t('input.editor.text')"
+				class="editor-toolbar__button"
+				:class="{ 'is-active': editor.isActive('paragraph') }"
+				title="paragraph"
+				@click="editor.chain().focus().setParagraph().run()"
+			>
+				<span class="icon">
+					<icon :icon="['fa', 'fa-paragraph']" />
+				</span>
+			</BaseButton>
+
+			<BaseButton
+				v-tooltip="$t('input.editor.horizontalRule')"
+				class="editor-toolbar__button"
+				@click="editor.chain().focus().setHorizontalRule().run()"
+			>
+				<span class="icon">
+					<icon :icon="['fa', 'fa-ruler-horizontal']" />
+				</span>
+			</BaseButton>
+		</div>
+
+		<div class="editor-toolbar__segment">
+			<BaseButton
+				v-tooltip="$t('input.editor.undo')"
+				class="editor-toolbar__button"
+				@click="editor.chain().focus().undo().run()"
+			>
+				<span class="icon">
+					<icon :icon="['fa', 'fa-undo']" />
+				</span>
+			</BaseButton>
+			<BaseButton
+				v-tooltip="$t('input.editor.redo')"
+				class="editor-toolbar__button"
+				@click="editor.chain().focus().redo().run()"
+			>
+				<span class="icon">
+					<icon :icon="['fa', 'fa-redo']" />
+				</span>
+			</BaseButton>
+		</div>
+
+		<div class="editor-toolbar__segment">
+			<!-- table -->
+			<BaseButton
+				v-tooltip="$t('input.editor.table.title')"
+				class="editor-toolbar__button"
+				:class="{ 'is-active': editor.isActive('table') }"
+				@click="toggleTableMode"
+			>
+				<span class="icon">
+					<icon :icon="['fa', 'fa-table']" />
+				</span>
+			</BaseButton>
+			<div
+				v-if="tableMode"
+				class="editor-toolbar__table-buttons"
+			>
+				<BaseButton
+					class="editor-toolbar__button"
+					@click="
+						editor
+							.chain()
+							.focus()
+							.insertTable({ rows: 3, cols: 3, withHeaderRow: true })
+							.run()
+					"
+				>
+					{{ $t('input.editor.table.insert') }}
+				</BaseButton>
+				<BaseButton
+					class="editor-toolbar__button"
+					:disabled="!editor.can().addColumnBefore"
+					@click="editor.chain().focus().addColumnBefore().run()"
+				>
+					{{ $t('input.editor.table.addColumnBefore') }}
+				</BaseButton>
+				<BaseButton
+					class="editor-toolbar__button"
+					:disabled="!editor.can().addColumnAfter"
+					@click="editor.chain().focus().addColumnAfter().run()"
+				>
+					{{ $t('input.editor.table.addColumnAfter') }}
+				</BaseButton>
+				<BaseButton
+					class="editor-toolbar__button"
+					:disabled="!editor.can().deleteColumn"
+					@click="editor.chain().focus().deleteColumn().run()"
+				>
+					{{ $t('input.editor.table.deleteColumn') }}
+				</BaseButton>
+				<BaseButton
+					class="editor-toolbar__button"
+					:disabled="!editor.can().addRowBefore"
+					@click="editor.chain().focus().addRowBefore().run()"
+				>
+					{{ $t('input.editor.table.addRowBefore') }}
+				</BaseButton>
+				<BaseButton
+					class="editor-toolbar__button"
+					:disabled="!editor.can().addRowAfter"
+					@click="editor.chain().focus().addRowAfter().run()"
+				>
+					{{ $t('input.editor.table.addRowAfter') }}
+				</BaseButton>
+				<BaseButton
+					class="editor-toolbar__button"
+					:disabled="!editor.can().deleteRow"
+					@click="editor.chain().focus().deleteRow().run()"
+				>
+					{{ $t('input.editor.table.deleteRow') }}
+				</BaseButton>
+				<BaseButton
+					class="editor-toolbar__button"
+					:disabled="!editor.can().deleteTable"
+					@click="editor.chain().focus().deleteTable().run()"
+				>
+					{{ $t('input.editor.table.deleteTable') }}
+				</BaseButton>
+				<BaseButton
+					class="editor-toolbar__button"
+					:disabled="!editor.can().mergeCells"
+					@click="editor.chain().focus().mergeCells().run()"
+				>
+					{{ $t('input.editor.table.mergeCells') }}
+				</BaseButton>
+				<BaseButton
+					class="editor-toolbar__button"
+					:disabled="!editor.can().splitCell"
+					@click="editor.chain().focus().splitCell().run()"
+				>
+					{{ $t('input.editor.table.splitCell') }}
+				</BaseButton>
+				<BaseButton
+					class="editor-toolbar__button"
+					:disabled="!editor.can().toggleHeaderColumn"
+					@click="editor.chain().focus().toggleHeaderColumn().run()"
+				>
+					{{ $t('input.editor.table.toggleHeaderColumn') }}
+				</BaseButton>
+				<BaseButton
+					class="editor-toolbar__button"
+					:disabled="!editor.can().toggleHeaderRow"
+					@click="editor.chain().focus().toggleHeaderRow().run()"
+				>
+					{{ $t('input.editor.table.toggleHeaderRow') }}
+				</BaseButton>
+				<BaseButton
+					class="editor-toolbar__button"
+					:disabled="!editor.can().toggleHeaderCell"
+					@click="editor.chain().focus().toggleHeaderCell().run()"
+				>
+					{{ $t('input.editor.table.toggleHeaderCell') }}
+				</BaseButton>
+				<BaseButton
+					class="editor-toolbar__button"
+					:disabled="!editor.can().mergeOrSplit"
+					@click="editor.chain().focus().mergeOrSplit().run()"
+				>
+					{{ $t('input.editor.table.mergeOrSplit') }}
+				</BaseButton>
+				<BaseButton
+					class="editor-toolbar__button"
+					:disabled="!editor.can().fixTables"
+					@click="editor.chain().focus().fixTables().run()"
+				>
+					{{ $t('input.editor.table.fixTables') }}
+				</BaseButton>
+			</div>
+		</div>
+	</div>
+</template>
+
+<script setup lang="ts">
+import {ref} from 'vue'
+import {Editor} from '@tiptap/vue-3'
+
+import BaseButton from '@/components/base/BaseButton.vue'
+import {setLinkInEditor} from '@/components/input/editor/setLinkInEditor'
+
+const {
+	editor = null,
+} = defineProps<{
+	editor: Editor,
+}>()
+
+const tableMode = ref(false)
+
+function toggleTableMode() {
+	tableMode.value = !tableMode.value
+}
+
+function openImagePicker() {
+	document.getElementById('tiptap__image-upload').click()
+}
+
+function setLink(event) {
+	setLinkInEditor(event.target.getBoundingClientRect(), editor)
+}
+</script>
+
+<style lang="scss" scoped>
+.editor-toolbar {
+	background: var(--white);
+	border: 1px solid var(--grey-200);
+	user-select: none;
+	padding: .5rem;
+	border-radius: $radius;
+	display: flex;
+	flex-wrap: wrap;
+
+	> * + * {
+		border-left: 1px solid var(--grey-200);
+		margin-left: 6px;
+		padding-left: 6px;
+	}
+}
+
+.editor-toolbar__button {
+	min-width: 2rem;
+	height: 2rem;
+	border-radius: $radius;
+	border: 1px solid transparent;
+	color: var(--grey-700);
+	transition: all $transition;
+	background: transparent;
+	margin-right: .25rem;
+
+	&:hover {
+		background: var(--grey-100);
+		border-color: var(--grey-200);
+	}
+	
+	.icon {
+		position: relative;
+		
+		.icon__lower-text {
+			font-size: .75rem;
+			position: absolute;
+			bottom: -3px;
+			right: -2px;
+			font-weight: bold;
+		}
+	}
+}
+
+.editor-toolbar__table-buttons {
+	margin-top: .5rem;
+	
+	> .editor-toolbar__button {
+		margin-right: .5rem;
+		margin-bottom: .5rem;
+		padding: 0 .25rem;
+		border: 1px solid var(--grey-400);
+		font-size: .75rem;
+		height: 1.5rem;
+	}
+}
+</style>

frontend/src/components/input/editor/TipTap.vue

@@ -0,0 +1,945 @@
+<template>
+	<div
+		ref="tiptapInstanceRef"
+		class="tiptap"
+	>
+		<EditorToolbar
+			v-if="editor && isEditing"
+			:editor="editor"
+			:upload-callback="uploadCallback"
+		/>
+		<BubbleMenu
+			v-if="editor && isEditing"
+			:editor="editor"
+			class="editor-bubble__wrapper"
+		>
+			<BaseButton
+				v-tooltip="$t('input.editor.bold')"
+				class="editor-bubble__button"
+				:class="{ 'is-active': editor.isActive('bold') }"
+				@click="editor.chain().focus().toggleBold().run()"
+			>
+				<icon :icon="['fa', 'fa-bold']" />
+			</BaseButton>
+			<BaseButton
+				v-tooltip="$t('input.editor.italic')"
+				class="editor-bubble__button"
+				:class="{ 'is-active': editor.isActive('italic') }"
+				@click="editor.chain().focus().toggleItalic().run()"
+			>
+				<icon :icon="['fa', 'fa-italic']" />
+			</BaseButton>
+			<BaseButton
+				v-tooltip="$t('input.editor.underline')"
+				class="editor-bubble__button"
+				:class="{ 'is-active': editor.isActive('underline') }"
+				@click="editor.chain().focus().toggleUnderline().run()"
+			>
+				<icon :icon="['fa', 'fa-underline']" />
+			</BaseButton>
+			<BaseButton
+				v-tooltip="$t('input.editor.strikethrough')"
+				class="editor-bubble__button"
+				:class="{ 'is-active': editor.isActive('strike') }"
+				@click="editor.chain().focus().toggleStrike().run()"
+			>
+				<icon :icon="['fa', 'fa-strikethrough']" />
+			</BaseButton>
+			<BaseButton
+				v-tooltip="$t('input.editor.code')"
+				class="editor-bubble__button"
+				:class="{ 'is-active': editor.isActive('code') }"
+				@click="editor.chain().focus().toggleCode().run()"
+			>
+				<icon :icon="['fa', 'fa-code']" />
+			</BaseButton>
+			<BaseButton
+				v-tooltip="$t('input.editor.link')"
+				class="editor-bubble__button"
+				:class="{ 'is-active': editor.isActive('link') }"
+				@click="setLink"
+			>
+				<icon :icon="['fa', 'fa-link']" />
+			</BaseButton>
+		</BubbleMenu>
+
+		<EditorContent
+			class="tiptap__editor"
+			:class="{'tiptap__editor-is-edit-enabled': isEditing}"
+			:editor="editor"
+			@click="focusIfEditing()"
+		/>
+
+		<input
+			v-if="isEditing"
+			id="tiptap__image-upload"
+			ref="uploadInputRef"
+			type="file"
+			class="is-hidden"
+			@change="addImage"
+		>
+
+		<ul
+			v-if="bottomActions.length === 0 && !isEditing && isEditEnabled"
+			class="tiptap__editor-actions d-print-none"
+		>
+			<li>
+				<BaseButton
+					class="done-edit"
+					@click="setEdit"
+				>
+					{{ $t('input.editor.edit') }}
+				</BaseButton>
+			</li>
+		</ul>
+		<ul
+			v-if="bottomActions.length > 0"
+			class="tiptap__editor-actions d-print-none"
+		>
+			<li v-if="isEditing && showSave">
+				<BaseButton
+					class="done-edit"
+					@click="bubbleSave"
+				>
+					{{ $t('misc.save') }}
+				</BaseButton>
+			</li>
+			<li v-if="!isEditing">
+				<BaseButton
+					class="done-edit"
+					@click="setEdit"
+				>
+					{{ $t('input.editor.edit') }}
+				</BaseButton>
+			</li>
+			<li
+				v-for="(action, k) in bottomActions"
+				:key="k"
+			>
+				<BaseButton @click="action.action">
+					{{ action.title }}
+				</BaseButton>
+			</li>
+		</ul>
+		<XButton
+			v-else-if="isEditing && showSave"
+			v-cy="'saveEditor'"
+			class="mt-4"
+			variant="secondary"
+			:shadow="false"
+			:disabled="!contentHasChanged"
+			@click="bubbleSave"
+		>
+			{{ $t('misc.save') }}
+		</XButton>
+	</div>
+</template>
+
+<script setup lang="ts">
+import {computed, nextTick, onBeforeUnmount, onMounted, ref, watch} from 'vue'
+
+import EditorToolbar from './EditorToolbar.vue'
+
+import Link from '@tiptap/extension-link'
+
+import CodeBlockLowlight from '@tiptap/extension-code-block-lowlight'
+import Table from '@tiptap/extension-table'
+import TableCell from '@tiptap/extension-table-cell'
+import TableHeader from '@tiptap/extension-table-header'
+import TableRow from '@tiptap/extension-table-row'
+import Typography from '@tiptap/extension-typography'
+import Image from '@tiptap/extension-image'
+import Underline from '@tiptap/extension-underline'
+
+import TaskItem from '@tiptap/extension-task-item'
+import TaskList from '@tiptap/extension-task-list'
+
+import {Blockquote} from '@tiptap/extension-blockquote'
+import {Bold} from '@tiptap/extension-bold'
+import {BulletList} from '@tiptap/extension-bullet-list'
+import {Code} from '@tiptap/extension-code'
+import {Document} from '@tiptap/extension-document'
+import {Dropcursor} from '@tiptap/extension-dropcursor'
+import {Gapcursor} from '@tiptap/extension-gapcursor'
+import {HardBreak} from '@tiptap/extension-hard-break'
+import {Heading} from '@tiptap/extension-heading'
+import {History} from '@tiptap/extension-history'
+import {HorizontalRule} from '@tiptap/extension-horizontal-rule'
+import {Italic} from '@tiptap/extension-italic'
+import {ListItem} from '@tiptap/extension-list-item'
+import {OrderedList} from '@tiptap/extension-ordered-list'
+import {Paragraph} from '@tiptap/extension-paragraph'
+import {Strike} from '@tiptap/extension-strike'
+import {Text} from '@tiptap/extension-text'
+import {BubbleMenu, EditorContent, useEditor} from '@tiptap/vue-3'
+import {Node} from '@tiptap/pm/model'
+
+import Commands from './commands'
+import suggestionSetup from './suggestion'
+
+import {lowlight} from 'lowlight'
+
+import type {BottomAction, UploadCallback} from './types'
+import type {ITask} from '@/modelTypes/ITask'
+import type {IAttachment} from '@/modelTypes/IAttachment'
+import AttachmentModel from '@/models/attachment'
+import AttachmentService from '@/services/attachment'
+import {useI18n} from 'vue-i18n'
+import BaseButton from '@/components/base/BaseButton.vue'
+import XButton from '@/components/input/button.vue'
+import {Placeholder} from '@tiptap/extension-placeholder'
+import {eventToHotkeyString} from '@github/hotkey'
+import {mergeAttributes} from '@tiptap/core'
+import {isEditorContentEmpty} from '@/helpers/editorContentEmpty'
+import inputPrompt from '@/helpers/inputPrompt'
+import {setLinkInEditor} from '@/components/input/editor/setLinkInEditor'
+
+const {
+	modelValue,
+	uploadCallback,
+	isEditEnabled = true,
+	bottomActions = [],
+	showSave = false,
+	placeholder = '',
+	editShortcut = '',
+} = defineProps<{
+	modelValue: string,
+	uploadCallback?: UploadCallback,
+	isEditEnabled?: boolean,
+	bottomActions?: BottomAction[],
+	showSave?: boolean,
+	placeholder?: string,
+	editShortcut?: string,
+}>()
+
+const emit = defineEmits(['update:modelValue', 'save'])
+
+const tiptapInstanceRef = ref<HTMLInputElement | null>(null)
+
+const {t} = useI18n()
+
+const CustomTableCell = TableCell.extend({
+	addAttributes() {
+		return {
+			// extend the existing attributes …
+			...this.parent?.(),
+
+			// and add a new one …
+			backgroundColor: {
+				default: null,
+				parseHTML: (element: HTMLElement) => element.getAttribute('data-background-color'),
+				renderHTML: (attributes) => {
+					return {
+						'data-background-color': attributes.backgroundColor,
+						style: `background-color: ${attributes.backgroundColor}`,
+					}
+				},
+			},
+		}
+	},
+})
+
+type CacheKey = `${ITask['id']}-${IAttachment['id']}`
+const loadedAttachments = ref<{
+	[key: CacheKey]: string
+}>({})
+
+const CustomImage = Image.extend({
+	addAttributes() {
+		return {
+			src: {
+				default: null,
+			},
+			alt: {
+				default: null,
+			},
+			title: {
+				default: null,
+			},
+			id: {
+				default: null,
+			},
+			'data-src': {
+				default: null,
+			},
+		}
+	},
+	renderHTML({HTMLAttributes}) {
+		if (HTMLAttributes.src?.startsWith(window.API_URL) || HTMLAttributes['data-src']?.startsWith(window.API_URL)) {
+			const imageUrl = HTMLAttributes['data-src'] ?? HTMLAttributes.src
+
+			// The url is something like /tasks/<id>/attachments/<id>
+			const parts = imageUrl.slice(window.API_URL.length + 1).split('/')
+			const taskId = Number(parts[1])
+			const attachmentId = Number(parts[3])
+			const cacheKey: CacheKey = `${taskId}-${attachmentId}`
+			const id = 'tiptap-image-' + cacheKey
+
+			nextTick(async () => {
+
+				const img = document.getElementById(id)
+
+				if (!img) return
+
+				if (typeof loadedAttachments.value[cacheKey] === 'undefined') {
+
+					const attachment = new AttachmentModel({taskId: taskId, id: attachmentId})
+
+					const attachmentService = new AttachmentService()
+					loadedAttachments.value[cacheKey] = await attachmentService.getBlobUrl(attachment)
+				}
+
+				img.src = loadedAttachments.value[cacheKey]
+			})
+
+			return ['img', mergeAttributes(this.options.HTMLAttributes, {
+				'data-src': imageUrl,
+				src: '#',
+				alt: HTMLAttributes.alt,
+				title: HTMLAttributes.title,
+				id,
+			})]
+		}
+
+		return ['img', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)]
+	},
+})
+
+type Mode = 'edit' | 'preview'
+
+const internalMode = ref<Mode>('preview')
+const isEditing = computed(() => internalMode.value === 'edit' && isEditEnabled)
+const contentHasChanged = ref<boolean>(false)
+
+watch(
+	() => internalMode.value,
+	mode => {
+		if (mode === 'preview') {
+			contentHasChanged.value = false
+		}
+	},
+)
+
+const editor = useEditor({
+	// eslint-disable-next-line vue/no-ref-object-destructure
+	editable: isEditing.value,
+	extensions: [
+		// Starterkit:
+		Blockquote,
+		Bold,
+		BulletList,
+		Code,
+		CodeBlockLowlight.configure({
+			lowlight,
+		}),
+		Document,
+		Dropcursor,
+		Gapcursor,
+		HardBreak.extend({
+			addKeyboardShortcuts() {
+				return {
+					'Mod-Enter': () => {
+						if (contentHasChanged.value) {
+							bubbleSave()
+						}
+					},
+				}
+			},
+		}),
+		Heading,
+		History,
+		HorizontalRule,
+		Italic,
+		ListItem,
+		OrderedList,
+		Paragraph,
+		Strike,
+		Text,
+
+		Placeholder.configure({
+			placeholder: ({editor}) => {
+				if (!isEditing.value) {
+					return ''
+				}
+
+				if (editor.getText() !== '' && !editor.isFocused) {
+					return ''
+				}
+
+				return placeholder !== ''
+					? placeholder
+					: t('input.editor.placeholder')
+			},
+		}),
+		Typography,
+		Underline,
+		Link.configure({
+			openOnClick: true,
+			validate: (href: string) => /^https?:\/\//.test(href),
+		}),
+		Table.configure({
+			resizable: true,
+		}),
+		TableRow,
+		TableHeader,
+		// Custom TableCell with backgroundColor attribute
+		CustomTableCell,
+
+		CustomImage,
+
+		TaskList,
+		TaskItem.configure({
+			nested: true,
+			onReadOnlyChecked: (node: Node, checked: boolean): boolean => {
+				if (!isEditEnabled) {
+					return false
+				}
+
+				// The following is a workaround for this bug:
+				// https://github.com/ueberdosis/tiptap/issues/4521
+				// https://github.com/ueberdosis/tiptap/issues/3676
+
+				editor.value!.state.doc.descendants((subnode, pos) => {
+					if (node.eq(subnode)) {
+						const {tr} = editor.value!.state
+						tr.setNodeMarkup(pos, undefined, {
+							...node.attrs,
+							checked,
+						})
+						editor.value!.view.dispatch(tr)
+						bubbleSave()
+					}
+				})
+
+
+				return true
+			},
+		}),
+
+		Commands.configure({
+			suggestion: suggestionSetup(t),
+		}),
+		BubbleMenu,
+	],
+	onUpdate: () => {
+		bubbleNow()
+	},
+})
+
+watch(
+	() => isEditing.value,
+	() => {
+		editor.value?.setEditable(isEditing.value)
+	},
+	{immediate: true},
+)
+
+watch(
+	() => modelValue,
+	value => {
+		if (!editor?.value) return
+
+		if (editor.value.getHTML() === value) {
+			return
+		}
+
+		setModeAndValue(value)
+	},
+	{immediate: true},
+)
+
+function bubbleNow() {
+	if (editor.value?.getHTML() === modelValue) {
+		return
+	}
+
+	contentHasChanged.value = true
+	emit('update:modelValue', editor.value?.getHTML())
+}
+
+function bubbleSave() {
+	bubbleNow()
+	emit('save', editor.value?.getHTML())
+	if (isEditing.value) {
+		internalMode.value = 'preview'
+	}
+}
+
+function setEdit(focus: boolean = true) {
+	internalMode.value = 'edit'
+	if (focus) {
+		editor.value?.commands.focus()
+	}
+}
+
+onBeforeUnmount(() => editor.value?.destroy())
+
+const uploadInputRef = ref<HTMLInputElement | null>(null)
+
+function uploadAndInsertFiles(files: File[] | FileList) {
+	uploadCallback(files).then(urls => {
+		urls?.forEach(url => {
+			editor.value
+				?.chain()
+				.focus()
+				.setImage({src: url})
+				.run()
+		})
+		bubbleSave()
+	})
+}
+
+async function addImage(event) {
+
+	if (typeof uploadCallback !== 'undefined') {
+		const files = uploadInputRef.value?.files
+
+		if (!files || files.length === 0) {
+			return
+		}
+
+		uploadAndInsertFiles(files)
+
+		return
+	}
+
+	const url = await inputPrompt(event.target.getBoundingClientRect())
+
+	if (url) {
+		editor.value?.chain().focus().setImage({src: url}).run()
+		bubbleSave()
+	}
+}
+
+function setLink(event) {
+	setLinkInEditor(event.target.getBoundingClientRect(), editor.value)
+}
+
+onMounted(async () => {
+	if (editShortcut !== '') {
+		document.addEventListener('keydown', setFocusToEditor)
+	}
+
+	await nextTick()
+
+	const input = tiptapInstanceRef.value?.querySelectorAll('.tiptap__editor')[0]?.children[0]
+	input?.addEventListener('paste', handleImagePaste)
+
+	setModeAndValue(modelValue)
+})
+
+onBeforeUnmount(() => {
+	nextTick(() => {
+		const input = tiptapInstanceRef.value?.querySelectorAll('.tiptap__editor')[0]?.children[0]
+		input?.removeEventListener('paste', handleImagePaste)
+	})
+	if (editShortcut !== '') {
+		document.removeEventListener('keydown', setFocusToEditor)
+	}
+})
+
+function setModeAndValue(value: string) {
+	internalMode.value = isEditorContentEmpty(value) ? 'edit' : 'preview'
+	editor.value?.commands.setContent(value, false)
+}
+
+function handleImagePaste(event) {
+	if (event?.clipboardData?.items?.length === 0) {
+		return
+	}
+
+	event.preventDefault()
+
+	const image = event.clipboardData.items[0]
+	if (image.kind === 'file' && image.type.startsWith('image/')) {
+		uploadAndInsertFiles([image.getAsFile()])
+	}
+}
+
+// See https://github.com/github/hotkey/discussions/85#discussioncomment-5214660
+function setFocusToEditor(event) {
+	const hotkeyString = eventToHotkeyString(event)
+	if (!hotkeyString) return
+	if (hotkeyString !== editShortcut ||
+		event.target.tagName.toLowerCase() === 'input' ||
+		event.target.tagName.toLowerCase() === 'textarea' ||
+		event.target.contentEditable === 'true') {
+		return
+	}
+
+	event.preventDefault()
+
+	if (!isEditing.value && isEditEnabled) {
+		internalMode.value = 'edit'
+	}
+
+	editor.value?.commands.focus()
+}
+
+function focusIfEditing() {
+	if (isEditing.value) {
+		editor.value?.commands.focus()
+	}
+}
+
+function clickTasklistCheckbox(event) {
+	event.stopImmediatePropagation()
+
+	if (event.target.localName !== 'p') {
+		return
+	}
+
+	event.target.parentNode.parentNode.firstChild.click()
+}
+
+watch(
+	() => isEditing.value,
+	editing => {
+		nextTick(() => {
+			const checkboxes = tiptapInstanceRef.value?.querySelectorAll('[data-checked]')
+			if (typeof checkboxes === 'undefined' || checkboxes.length === 0) {
+				return
+			}
+
+			if (editing) {
+				checkboxes.forEach(check => {
+					if (check.children.length < 2) {
+						return
+					}
+
+					// We assume the first child contains the label element with the checkbox and the second child the actual label
+					// When the actual label is clicked, we forward that click to the checkbox.
+					check.children[1].removeEventListener('click', clickTasklistCheckbox)
+				})
+
+				return
+			}
+
+			checkboxes.forEach(check => {
+				if (check.children.length < 2) {
+					return
+				}
+
+				// We assume the first child contains the label element with the checkbox and the second child the actual label
+				// When the actual label is clicked, we forward that click to the checkbox.
+				check.children[1].addEventListener('click', clickTasklistCheckbox)
+			})
+		})
+	},
+	{immediate: true},
+)
+</script>
+
+<style lang="scss">
+.tiptap__editor {
+	&.tiptap__editor-is-edit-enabled {
+		min-height: 10rem;
+
+		.ProseMirror {
+			padding: .5rem;
+		}
+
+		&:focus-within, &:focus {
+			box-shadow: 0 0 0 2px hsla(var(--primary-hsl), 0.5);
+		}
+
+		ul[data-type='taskList'] li > div {
+			cursor: text;
+		}
+	}
+
+	transition: box-shadow $transition;
+	border-radius: $radius;
+}
+
+.tiptap p::before {
+	content: attr(data-placeholder);
+	color: var(--grey-400);
+	pointer-events: none;
+	height: 0;
+	float: left;
+}
+
+// Basic editor styles
+.ProseMirror {
+	padding: .5rem .5rem .5rem 0;
+
+	&:focus-within, &:focus {
+		box-shadow: none;
+	}
+
+	> * + * {
+		margin-top: 0.75em;
+	}
+
+	ul,
+	ol {
+		padding: 0 1rem;
+	}
+
+	h1,
+	h2,
+	h3,
+	h4,
+	h5,
+	h6 {
+		line-height: 1.1;
+	}
+
+	code {
+		background-color: var(--grey-200);
+		color: var(--grey-700);
+	}
+
+	pre {
+		background: var(--grey-200);
+		color: var(--grey-700);
+		font-family: 'JetBrainsMono', monospace;
+		padding: 0.75rem 1rem;
+		border-radius: $radius;
+
+		code {
+			color: inherit;
+			padding: 0;
+			background: none;
+			font-size: 0.8rem;
+		}
+
+		.hljs-comment,
+		.hljs-quote {
+			color: var(--grey-500);
+		}
+
+		.hljs-variable,
+		.hljs-template-variable,
+		.hljs-attribute,
+		.hljs-tag,
+		.hljs-name,
+		.hljs-regexp,
+		.hljs-link,
+		.hljs-name,
+		.hljs-selector-id,
+		.hljs-selector-class {
+			color: var(--code-variable);
+		}
+
+		.hljs-number,
+		.hljs-meta,
+		.hljs-built_in,
+		.hljs-builtin-name,
+		.hljs-literal,
+		.hljs-type,
+		.hljs-params {
+			color: var(--code-literal);
+		}
+
+		.hljs-string,
+		.hljs-symbol,
+		.hljs-bullet {
+			color: var(--code-symbol);
+		}
+
+		.hljs-title,
+		.hljs-section {
+			color: var(--code-section);
+		}
+
+		.hljs-keyword,
+		.hljs-selector-tag {
+			color: var(--code-keyword);
+		}
+
+		.hljs-emphasis {
+			font-style: italic;
+		}
+
+		.hljs-strong {
+			font-weight: 700;
+		}
+	}
+
+	img {
+		max-width: 100%;
+		height: auto;
+
+		&.ProseMirror-selectednode {
+			outline: 3px solid var(--primary);
+		}
+	}
+
+	blockquote {
+		padding-left: 1rem;
+		border-left: 2px solid rgba(#0d0d0d, 0.1);
+	}
+
+	hr {
+		border: none;
+		border-top: 2px solid rgba(#0d0d0d, 0.1);
+		margin: 2rem 0;
+	}
+}
+
+.ProseMirror {
+	/* Table-specific styling */
+	table {
+		border-collapse: collapse;
+		table-layout: fixed;
+		width: 100%;
+		margin: 0;
+		overflow: hidden;
+
+		td,
+		th {
+			min-width: 1em;
+			border: 2px solid #ced4da;
+			padding: 3px 5px;
+			vertical-align: top;
+			box-sizing: border-box;
+			position: relative;
+
+			> * {
+				margin-bottom: 0;
+			}
+		}
+
+		th {
+			font-weight: bold;
+			text-align: left;
+			background-color: #f1f3f5;
+		}
+
+		.selectedCell:after {
+			z-index: 2;
+			position: absolute;
+			content: '';
+			left: 0;
+			right: 0;
+			top: 0;
+			bottom: 0;
+			background: rgba(200, 200, 255, 0.4);
+			pointer-events: none;
+		}
+
+		.column-resize-handle {
+			position: absolute;
+			right: -2px;
+			top: 0;
+			bottom: -2px;
+			width: 4px;
+			background-color: #adf;
+			pointer-events: none;
+		}
+
+		p {
+			margin: 0;
+		}
+	}
+
+	// Lists
+	ul {
+		margin-left: .5rem;
+		margin-top: 0 !important;
+
+		li {
+			margin-top: 0;
+		}
+
+		p {
+			margin-bottom: 0 !important;
+		}
+	}
+}
+
+.tableWrapper {
+	overflow-x: auto;
+}
+
+.resize-cursor {
+	cursor: ew-resize;
+	cursor: col-resize;
+}
+
+// tasklist
+ul[data-type='taskList'] {
+	list-style: none;
+	padding: 0;
+	margin-left: 0;
+
+	li {
+		display: flex;
+
+		> label {
+			flex: 0 0 auto;
+			margin-right: 0.5rem;
+			user-select: none;
+		}
+
+		> div {
+			flex: 1 1 auto;
+			cursor: pointer;
+		}
+	}
+
+	input[type='checkbox'] {
+		cursor: pointer;
+	}
+}
+
+.editor-bubble__wrapper {
+	background: var(--white);
+	border-radius: $radius;
+	border: 1px solid var(--grey-200);
+	box-shadow: var(--shadow-md);
+	display: flex;
+	overflow: hidden;
+}
+
+.editor-bubble__button {
+	color: var(--grey-700);
+	transition: all $transition;
+	background: transparent;
+
+	svg {
+		box-sizing: border-box;
+		display: block;
+		width: 1rem;
+		height: 1rem;
+		padding: .5rem;
+		margin: 0;
+	}
+
+	&:hover {
+		background: var(--grey-200);
+	}
+}
+
+ul.tiptap__editor-actions {
+	font-size: .8rem;
+	margin: 0;
+
+	li {
+		display: inline-block;
+
+		&::after {
+			content: '·';
+			padding: 0 .25rem;
+		}
+
+		&:last-child:after {
+			content: '';
+		}
+	}
+
+	&, a {
+		color: var(--grey-500);
+
+		&.done-edit {
+			color: var(--primary);
+		}
+	}
+
+	a:hover {
+		text-decoration: underline;
+	}
+}
+</style>

frontend/src/components/input/editor/commands.ts

@@ -0,0 +1,28 @@
+import {Extension} from '@tiptap/core'
+import Suggestion from '@tiptap/suggestion'
+
+// Copied and adjusted from https://github.com/ueberdosis/tiptap/tree/252acb32d27a0f9af14813eeed83d8a50059a43a/demos/src/Experiments/Commands/Vue
+
+export default Extension.create({
+    name: 'slash-menu-commands',
+
+    addOptions() {
+        return {
+            suggestion: {
+                char: '/',
+                command: ({editor, range, props}) => {
+                    props.command({editor, range})
+                },
+            },
+        }
+    },
+
+    addProseMirrorPlugins() {
+        return [
+            Suggestion({
+                editor: this.editor,
+                ...this.options.suggestion,
+            }),
+        ]
+    },
+})

frontend/src/components/input/editor/setLinkInEditor.ts

@@ -0,0 +1,26 @@
+import inputPrompt from '@/helpers/inputPrompt'
+
+export async function setLinkInEditor(pos, editor) {
+	const previousUrl = editor?.getAttributes('link').href || ''
+	const url = await inputPrompt(pos, previousUrl)
+
+	// empty
+	if (url === '') {
+		editor
+			?.chain()
+			.focus()
+			.extendMarkRange('link')
+			.unsetLink()
+			.run()
+
+		return
+	}
+
+	// update link
+	editor
+		?.chain()
+		.focus()
+		.extendMarkRange('link')
+		.setLink({href: url, target: '_blank'})
+		.run()
+}

frontend/src/components/input/editor/suggestion.ts

@@ -0,0 +1,214 @@
+import {VueRenderer} from '@tiptap/vue-3'
+import tippy from 'tippy.js'
+
+import CommandsList from './CommandsList.vue'
+
+export default function suggestionSetup(t) {
+    return {
+        items: ({query}: { query: string }) => {
+            return [
+                {
+                    title: t('input.editor.text'),
+                    description: t('input.editor.textTooltip'),
+                    icon: 'fa-font',
+                    command: ({editor, range}) => {
+                        editor
+                            .chain()
+                            .focus()
+                            .deleteRange(range)
+                            .setNode('paragraph', {level: 1})
+                            .run()
+                    },
+                },
+                {
+                    title: t('input.editor.heading1'),
+                    description: t('input.editor.heading1Tooltip'),
+                    icon: 'fa-header',
+                    command: ({editor, range}) => {
+                        editor
+                            .chain()
+                            .focus()
+                            .deleteRange(range)
+                            .setNode('heading', {level: 1})
+                            .run()
+                    },
+                },
+                {
+                    title: t('input.editor.heading2'),
+                    description: t('input.editor.heading2Tooltip'),
+                    icon: 'fa-header',
+                    command: ({editor, range}) => {
+                        editor
+                            .chain()
+                            .focus()
+                            .deleteRange(range)
+                            .setNode('heading', {level: 2})
+                            .run()
+                    },
+                },
+                {
+                    title: t('input.editor.heading3'),
+                    description: t('input.editor.heading3Tooltip'),
+                    icon: 'fa-header',
+                    command: ({editor, range}) => {
+                        editor
+                            .chain()
+                            .focus()
+                            .deleteRange(range)
+                            .setNode('heading', {level: 2})
+                            .run()
+                    },
+                },
+                {
+                    title: t('input.editor.bulletList'),
+                    description: t('input.editor.bulletListTooltip'),
+                    icon: 'fa-list-ul',
+                    command: ({editor, range}) => {
+                        editor
+                            .chain()
+                            .focus()
+                            .deleteRange(range)
+                            .toggleBulletList()
+                            .run()
+                    },
+                },
+                {
+                    title: t('input.editor.orderedList'),
+                    description: t('input.editor.orderedListTooltip'),
+                    icon: 'fa-list-ol',
+                    command: ({editor, range}) => {
+                        editor
+                            .chain()
+                            .focus()
+                            .deleteRange(range)
+                            .toggleOrderedList()
+                            .run()
+                    },
+                },
+                {
+                    title: t('input.editor.taskList'),
+                    description: t('input.editor.taskListTooltip'),
+                    icon: 'fa-list-check',
+                    command: ({editor, range}) => {
+                        editor
+                            .chain()
+                            .focus()
+                            .deleteRange(range)
+                            .toggleTaskList()
+                            .run()
+                    },
+                },
+                {
+                    title: t('input.editor.quote'),
+                    description: t('input.editor.quoteTooltip'),
+                    icon: 'fa-quote-right',
+                    command: ({editor, range}) => {
+                        editor
+                            .chain()
+                            .focus()
+                            .deleteRange(range)
+                            .toggleBlockquote()
+                            .run()
+                    },
+                },
+                {
+                    title: t('input.editor.code'),
+                    description: t('input.editor.codeTooltip'),
+                    icon: 'fa-code',
+                    command: ({editor, range}) => {
+                        editor
+                            .chain()
+                            .focus()
+                            .deleteRange(range)
+                            .toggleCodeBlock()
+                            .run()
+                    },
+                },
+                {
+                    title: t('input.editor.image'),
+                    description: t('input.editor.imageTooltip'),
+                    icon: 'fa-image',
+                    command: ({editor, range}) => {
+                        editor
+                            .chain()
+                            .focus()
+                            .deleteRange(range)
+                            .run()
+                        document.getElementById('tiptap__image-upload').click()
+                    },
+                },
+                {
+                    title: t('input.editor.horizontalRule'),
+                    description: t('input.editor.horizontalRuleTooltip'),
+                    icon: 'fa-ruler-horizontal',
+                    command: ({editor, range}) => {
+                        editor
+                            .chain()
+                            .focus()
+                            .deleteRange(range)
+                            .setHorizontalRule()
+                            .run()
+                    },
+                },
+            ].filter(item => item.title.toLowerCase().startsWith(query.toLowerCase()))
+        },
+
+        render: () => {
+            let component: VueRenderer
+            let popup
+
+            return {
+                onStart: props => {
+                    component = new VueRenderer(CommandsList, {
+                        // using vue 2:
+                        // parent: this,
+                        // propsData: props,
+                        props,
+                        editor: props.editor,
+                    })
+
+                    if (!props.clientRect) {
+                        return
+                    }
+
+                    popup = tippy('body', {
+                        getReferenceClientRect: props.clientRect,
+                        appendTo: () => document.body,
+                        content: component.element,
+                        showOnCreate: true,
+                        interactive: true,
+                        trigger: 'manual',
+                        placement: 'bottom-start',
+                    })
+                },
+
+                onUpdate(props) {
+                    component.updateProps(props)
+
+                    if (!props.clientRect) {
+                        return
+                    }
+
+                    popup[0].setProps({
+                        getReferenceClientRect: props.clientRect,
+                    })
+                },
+
+                onKeyDown(props) {
+                    if (props.event.key === 'Escape') {
+                        popup[0].hide()
+
+                        return true
+                    }
+
+                    return component.ref?.onKeyDown(props)
+                },
+
+                onExit() {
+                    popup[0].destroy()
+                    component.destroy()
+                },
+            }
+        },
+    }
+}

frontend/src/components/input/editor/types.ts

@@ -0,0 +1,6 @@
+export type UploadCallback = (files: File[] | FileList) => Promise<string[]>
+
+export interface BottomAction {
+    title: string
+    action: () => void,
+}

frontend/src/components/input/fancycheckbox.story.vue

@@ -0,0 +1,85 @@
+<script lang="ts" setup>
+import {ref} from 'vue'
+import {logEvent} from 'histoire/client'
+import FancyCheckbox from './fancycheckbox.vue'
+
+const isDisabled = ref<boolean | undefined>()
+
+const isChecked = ref(false)
+
+const isCheckedInitiallyEnabled = ref(true)
+
+const isCheckedDisabled = ref(false)
+
+const withoutInitialState = ref<boolean | undefined>()
+</script>
+
+
+<template>
+	<Story :layout="{ type: 'grid', width: '200px' }">
+		<Variant title="Default">
+			<FancyCheckbox
+				v-model="isChecked"
+				:disabled="isDisabled"
+			>
+				This is probably not important
+			</FancyCheckbox>
+
+			Visualisation
+			<input
+				v-model="isChecked"
+				type="checkbox"
+			>
+			{{ isChecked }}
+		</Variant>
+		<Variant title="Enabled Initially">
+			<FancyCheckbox
+				v-model="isCheckedInitiallyEnabled"
+				:disabled="isDisabled"
+			>
+				We want you to use this option
+			</FancyCheckbox>
+
+			Visualisation
+			<input
+				v-model="isCheckedInitiallyEnabled"
+				type="checkbox"
+			>
+			{{ isCheckedInitiallyEnabled }}
+		</Variant>
+		<Variant title="Disabled">
+			<FancyCheckbox
+				disabled
+				:model-value="isCheckedDisabled"
+				@update:modelValue="logEvent('Setting disabled: This should never happen', $event)"
+			>
+				You can't change this
+			</FancyCheckbox>
+
+			Visualisation
+			<input
+				v-model="isCheckedDisabled"
+				type="checkbox"
+				disabled
+			>
+			{{ isCheckedDisabled }}
+		</Variant>
+
+		<Variant title="Undefined initial State">
+			<FancyCheckbox
+				v-model="withoutInitialState"
+				:disabled="isDisabled"
+			>
+				Not sure what the value should be
+			</FancyCheckbox>
+
+			Visualisation
+			<input
+				v-model="withoutInitialState"
+				type="checkbox"
+				disabled
+			>
+			{{ withoutInitialState }}
+		</Variant>
+	</Story>
+</template>

frontend/src/components/input/fancycheckbox.vue

@@ -0,0 +1,103 @@
+<template>
+	<BaseCheckbox
+		class="fancycheckbox"
+		:class="{
+			'is-disabled': disabled,
+			'is-block': isBlock,
+		}"
+		:disabled="disabled"
+		:model-value="modelValue"
+		@update:modelValue="value => emit('update:modelValue', value)"
+	>
+		<CheckboxIcon class="fancycheckbox__icon" />
+		<span
+			v-if="$slots.default"
+			class="fancycheckbox__content"
+		>
+			<slot />
+		</span>
+	</BaseCheckbox>
+</template>
+
+<script setup lang="ts">
+import CheckboxIcon from '@/assets/checkbox.svg?component'
+
+import BaseCheckbox from '@/components/base/BaseCheckbox.vue'
+
+defineProps({
+	modelValue: {
+		type: Boolean,
+	},
+	disabled: {
+		type: Boolean,
+	},
+	isBlock: {
+		type: Boolean,
+		default: false,
+	},
+})
+
+const emit = defineEmits<{
+  (event: 'update:modelValue', value: boolean): void
+}>()
+</script>
+
+
+<style lang="scss" scoped>
+.fancycheckbox {
+  display: inline-block;
+  padding-right: 5px;
+  padding-top: 3px;
+
+	&.is-block {
+		display: block;
+		margin: .5rem .2rem;
+	}
+}
+
+.fancycheckbox__content {
+	font-size: 0.8rem;
+	vertical-align: top;
+	padding-left: .5rem;
+}
+
+.fancycheckbox__icon:deep() {
+	position: relative;
+	z-index: 1;
+	stroke: var(--stroke-color, #c8ccd4);
+	transform: translate3d(0, 0, 0);
+	transition: all 0.2s ease;
+
+	path,
+	polyline {
+		transition: all 0.2s linear, color 0.2s ease;
+	}
+}
+
+.fancycheckbox:not(:has(input:disabled)):hover .fancycheckbox__icon,
+.fancycheckbox:has(input:checked) .fancycheckbox__icon {
+	--stroke-color: var(--primary);
+}
+</style>
+
+<style lang="scss">
+// Since css-has-pseudo doesn't work with deep classes,
+// the following rules can't be scoped
+
+.fancycheckbox:has(:not(input:checked)) .fancycheckbox__icon {
+	path {
+		transition-delay: 0.05s;
+	}
+}
+
+.fancycheckbox:has(input:checked) .fancycheckbox__icon {
+	path {
+		stroke-dashoffset: 60;
+	}
+
+	polyline {
+		stroke-dashoffset: 42;
+		transition-delay: 0.15s;
+	}
+}
+</style>

frontend/src/components/input/multiselect.vue

@@ -0,0 +1,635 @@
+<template>
+	<div
+		ref="multiselectRoot"
+		class="multiselect"
+		:class="{'has-search-results': searchResultsVisible}"
+		tabindex="-1"
+		@focus="focus"
+	>
+		<div
+			class="control"
+			:class="{'is-loading': loading || localLoading}"
+		>
+			<div
+				class="input-wrapper input"
+				:class="{'has-multiple': hasMultiple, 'has-removal-button': removalAvailable}"
+			>
+				<slot
+					v-if="Array.isArray(internalValue)"
+					name="items"
+					:items="internalValue"
+					:remove="remove"
+				>
+					<template v-for="(item, key) in internalValue">
+						<slot
+							name="tag"
+							:item="item"
+						>
+							<span
+								:key="`item${key}`"
+								class="tag ml-2 mt-2"
+							>
+								{{ label !== '' ? item[label] : item }}
+								<BaseButton
+									class="delete is-small"
+									@click="() => remove(item)"
+								/>
+							</span>
+						</slot>
+					</template>
+				</slot>
+				
+				<input
+					ref="searchInput"
+					v-model="query"
+					type="text"
+					class="input"
+					:placeholder="placeholder"
+					:autocomplete="autocompleteEnabled ? undefined : 'off'"
+					:spellcheck="autocompleteEnabled ? undefined : 'false'"
+					@keyup="search"
+					@keyup.enter.exact.prevent="() => createOrSelectOnEnter()"
+					@keydown.down.exact.prevent="() => preSelect(0)"
+					@focus="handleFocus"
+				>
+				<BaseButton 
+					v-if="removalAvailable"
+					class="removal-button"
+					@click="resetSelectedValue"
+				>
+					<icon icon="times" />
+				</BaseButton>
+			</div>
+		</div>
+
+		<CustomTransition name="fade">
+			<div
+				v-if="searchResultsVisible"
+				class="search-results"
+				:class="{'search-results-inline': inline}"
+			>
+				<BaseButton
+					v-for="(data, index) in filteredSearchResults"
+					:key="index"
+					:ref="(el) => setResult(el, index)"
+					class="search-result-button is-fullwidth"
+					@keydown.up.prevent="() => preSelect(index - 1)"
+					@keydown.down.prevent="() => preSelect(index + 1)"
+					@click.prevent.stop="() => select(data)"
+				>
+					<span>
+						<slot
+							name="searchResult"
+							:option="data"
+						>
+							<span class="search-result">{{ label !== '' ? data[label] : data }}</span>
+						</slot>
+					</span>
+					<span class="hint-text">
+						{{ selectPlaceholder }}
+					</span>
+				</BaseButton>
+
+				<BaseButton
+					v-if="creatableAvailable"
+					:ref="(el) => setResult(el, filteredSearchResults.length)"
+					class="search-result-button is-fullwidth"
+					@keydown.up.prevent="() => preSelect(filteredSearchResults.length - 1)"
+					@keydown.down.prevent="() => preSelect(filteredSearchResults.length + 1)"
+					@keyup.enter.prevent="create"
+					@click.prevent.stop="create"
+				>
+					<span>
+						<slot
+							name="searchResult"
+							:option="query"
+						>
+							<span class="search-result">
+								{{ query }}
+							</span>
+						</slot>
+					</span>
+					<span class="hint-text">
+						{{ createPlaceholder }}
+					</span>
+				</BaseButton>
+			</div>
+		</CustomTransition>
+	</div>
+</template>
+
+<script setup lang="ts">
+import {
+	computed, onBeforeUnmount, onMounted, ref, toRefs, watch, type ComponentPublicInstance, type PropType,
+} from 'vue'
+import {useI18n} from 'vue-i18n'
+
+import {closeWhenClickedOutside} from '@/helpers/closeWhenClickedOutside'
+
+import BaseButton from '@/components/base/BaseButton.vue'
+import CustomTransition from '@/components/misc/CustomTransition.vue'
+
+const props = defineProps({
+	/**
+	 * When true, shows a loading spinner
+	 */
+	loading: {
+		type: Boolean,
+		default: false,
+	},
+	/**
+	 * The placeholder of the search input
+	 */
+	placeholder: {
+		type: String,
+		default: '',
+	},
+	/**
+	 * The search results where the @search listener needs to put the results into
+	 */
+	searchResults: {
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		type: Array as PropType<{ [id: string]: any }>,
+		default: () => [],
+	},
+	/**
+	 * The name of the property of the searched object to show the user.
+	 * If empty the component will show all raw data of an entry.
+	 */
+	label: {
+		type: String,
+		default: '',
+	},
+	/**
+	 * The object with the value, updated every time an entry is selected.
+	 */
+	modelValue: {
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		type: [Object] as PropType<{ [key: string]: any }>,
+		default: null,
+	},
+	/**
+	 * If true, will provide an "add this as a new value" entry which fires an @create event when clicking on it.
+	 */
+	creatable: {
+		type: Boolean,
+		default: false,
+	},
+	/**
+	 * The text shown next to the new value option.
+	 */
+	createPlaceholder: {
+		type: String,
+		default() {
+			const {t} = useI18n({useScope: 'global'})
+			return t('input.multiselect.createPlaceholder')
+		},
+	},
+	/**
+	 * The text shown next to an option.
+	 */
+	selectPlaceholder: {
+		type: String,
+		default() {
+			const {t} = useI18n({useScope: 'global'})
+			return t('input.multiselect.selectPlaceholder')
+		},
+	},
+	/**
+	 * If true, allows for selecting multiple items. v-model will be an array with all selected values in that case.
+	 */
+	multiple: {
+		type: Boolean,
+		default: false,
+	},
+	/**
+	 * If true, displays the search results inline instead of using a dropdown.
+	 */
+	inline: {
+		type: Boolean,
+		default: false,
+	},
+	/**
+	 * If true, shows search results when no query is specified.
+	 */
+	showEmpty: {
+		type: Boolean,
+		default: true,
+	},
+	/**
+	 * The delay in ms after which the search event will be fired. Used to avoid hitting the network on every keystroke.
+	 */
+	searchDelay: {
+		type: Number,
+		default: 200,
+	},
+	closeAfterSelect: {
+		type: Boolean,
+		default: true,
+	},
+	/**
+	 * If false, the search input will get the autocomplete="off" attributes attached to it.
+	 */
+	autocompleteEnabled: {
+		type: Boolean,
+		default: true,
+	},
+})
+
+const emit = defineEmits<{
+	(e: 'update:modelValue', value: null): void
+	/**
+	 * Triggered every time the search query input changes
+	 */
+	(e: 'search', query: string): void
+	/**
+	 * Triggered every time an option from the search results is selected. Also triggers a change in v-model.
+	 */
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	(e: 'select', value: { [key: string]: any }): void
+	/**
+	 * If nothing or no exact match was found and `creatable` is true, this event is triggered with the current value of the search query.
+	 */
+	(e: 'create', query: string): void
+	/**
+	 * If `multiple` is enabled, this will be fired every time an item is removed from the array of selected items.
+	 */
+	(e: 'remove', value: null): void
+}>()
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function elementInResults(elem: string | any, label: string, query: string): boolean {
+	// Don't make create available if we have an exact match in our search results.
+	if (label !== '') {
+		return elem[label] === query
+	}
+
+	return elem === query
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const query = ref<string | { [key: string]: any }>('')
+const searchTimeout = ref<ReturnType<typeof setTimeout> | null>(null)
+const localLoading = ref(false)
+const showSearchResults = ref(false)
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const internalValue = ref<string | { [key: string]: any } | any[] | null>(null)
+
+onMounted(() => document.addEventListener('click', hideSearchResultsHandler))
+onBeforeUnmount(() => document.removeEventListener('click', hideSearchResultsHandler))
+
+const {modelValue, searchResults} = toRefs(props)
+
+watch(
+	modelValue,
+	(value) => setSelectedObject(value),
+	{
+		immediate: true,
+		deep: true,
+	},
+)
+
+const searchResultsVisible = computed(() => {
+	if (query.value === '' && !props.showEmpty) {
+		return false
+	}
+
+	return showSearchResults.value && (
+		(filteredSearchResults.value.length > 0) ||
+		(props.creatable && query.value !== '')
+	)
+})
+
+const creatableAvailable = computed(() => {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	const hasResult = filteredSearchResults.value.some((elem: any) => elementInResults(elem, props.label, query.value))
+	const hasQueryAlreadyAdded = Array.isArray(internalValue.value) && internalValue.value.some(elem => elementInResults(elem, props.label, query.value))
+
+	return props.creatable
+		&& query.value !== ''
+		&& !(hasResult || hasQueryAlreadyAdded)
+})
+
+const filteredSearchResults = computed(() => {
+	const currentInternal = internalValue.value
+	if (props.multiple && currentInternal !== null && Array.isArray(currentInternal)) {
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		return searchResults.value.filter((item: any) => !currentInternal.some(e => e === item))
+	}
+
+	return searchResults.value
+})
+
+const hasMultiple = computed(() => {
+	return props.multiple && Array.isArray(internalValue.value) && internalValue.value.length > 0
+})
+
+const removalAvailable = computed(() => !props.multiple && internalValue.value !== null && query.value !== '')
+function resetSelectedValue() {
+	select(null)
+}
+
+const searchInput = ref<HTMLInputElement | null>(null)
+
+// Searching will be triggered with a 200ms delay to avoid searching on every keyup event.
+function search() {
+
+	// Updating the query with a binding does not work on mobile for some reason,
+	// getting the value manual does.
+	query.value = searchInput.value?.value || ''
+
+	if (searchTimeout.value !== null) {
+		clearTimeout(searchTimeout.value)
+		searchTimeout.value = null
+	}
+
+	localLoading.value = true
+
+	searchTimeout.value = setTimeout(() => {
+		emit('search', query.value)
+		setTimeout(() => {
+			localLoading.value = false
+		}, 100) // The duration of the loading timeout of the services
+		showSearchResults.value = true
+	}, props.searchDelay)
+}
+
+const multiselectRoot = ref<HTMLElement | null>(null)
+
+function hideSearchResultsHandler(e: MouseEvent) {
+	closeWhenClickedOutside(e, multiselectRoot.value, closeSearchResults)
+}
+
+function closeSearchResults() {
+	showSearchResults.value = false
+}
+
+function handleFocus() {
+	// We need the timeout to avoid the hideSearchResultsHandler hiding the search results right after the input
+	// is focused. That would lead to flickering pre-loaded search results and hiding them right after showing.
+	setTimeout(() => {
+		showSearchResults.value = true
+	}, 10)
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function select(object: { [key: string]: any } | null) {
+	if (props.multiple) {
+		if (internalValue.value === null) {
+			internalValue.value = []
+		}
+
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		(internalValue.value as any[]).push(object)
+	} else {
+		internalValue.value = object
+	}
+
+	emit('update:modelValue', internalValue.value)
+	emit('select', object)
+	setSelectedObject(object)
+	if (props.closeAfterSelect && filteredSearchResults.value.length > 0 && !creatableAvailable.value) {
+		closeSearchResults()
+	}
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function setSelectedObject(object: string | { [id: string]: any } | null, resetOnly = false) {
+	internalValue.value = object
+
+	// We assume we're getting an array when multiple is enabled and can therefore leave the query
+	// value etc as it is
+	if (props.multiple) {
+		query.value = ''
+		return
+	}
+
+	if (object === null) {
+		query.value = ''
+		return
+	}
+
+	if (resetOnly) {
+		return
+	}
+
+	query.value = props.label !== '' ? object[props.label] : object
+}
+
+const results = ref<(Element | ComponentPublicInstance)[]>([])
+
+function setResult(el: Element | ComponentPublicInstance | null, index: number) {
+	if (el === null) {
+		delete results.value[index]
+	} else {
+		results.value[index] = el
+	}
+}
+
+function preSelect(index: number) {
+	if (index < 0) {
+		searchInput.value?.focus()
+		return
+	}
+
+	const elems = results.value[index]
+	if (typeof elems === 'undefined' || elems.length === 0) {
+		return
+	}
+
+	if (Array.isArray(elems)) {
+		elems[0].focus()
+		return
+	}
+
+	elems.focus()
+}
+
+function create() {
+	if (query.value === '') {
+		return
+	}
+
+	emit('create', query.value)
+	setSelectedObject(query.value, true)
+	closeSearchResults()
+}
+
+function createOrSelectOnEnter() {
+	if (!creatableAvailable.value && searchResults.value.length === 1) {
+		select(searchResults.value[0])
+		return
+	}
+
+	if (!creatableAvailable.value) {
+		// Check if there's an exact match for our search term
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		const exactMatch = filteredSearchResults.value.find((elem: any) => elementInResults(elem, props.label, query.value))
+		if (exactMatch) {
+			select(exactMatch)
+		}
+
+		return
+	}
+
+	create()
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function remove(item: any) {
+	for (const ind in internalValue.value) {
+		if (internalValue.value[ind] === item) {
+			internalValue.value.splice(ind, 1)
+			break
+		}
+	}
+
+	emit('update:modelValue', internalValue.value)
+	emit('remove', item)
+}
+
+function focus() {
+	searchInput.value?.focus()
+}
+</script>
+
+<style lang="scss" scoped>
+.multiselect {
+	width: 100%;
+	position: relative;
+
+	.control.is-loading::after {
+		top: .75rem;
+	}
+}
+
+.input-wrapper {
+	padding: 0;
+	background: var(--white);
+	border-color: var(--grey-200);
+	flex-wrap: wrap;
+	height: auto;
+
+	&:hover {
+		border-color: var(--grey-300) !important;
+	}
+
+	.input {
+		display: flex;
+		max-width: 100%;
+		width: 100%;
+		align-items: center;
+		border: none !important;
+		background: transparent;
+		height: auto;
+
+		&::placeholder {
+			font-style: normal !important;
+		}
+	}
+
+	&.has-multiple .input {
+		max-width: 250px;
+
+		input {
+			padding-left: 0;
+		}
+	}
+
+	&:focus-within {
+		border-color: var(--primary) !important;
+		background: var(--white) !important;
+	}
+
+	// doesn't seem to be used. maybe inside the slot?
+	.loader {
+		margin: 0 .5rem;
+	}
+}
+
+.has-search-results .input-wrapper {
+	border-radius: $radius $radius 0 0;
+	border-color: var(--primary) !important;
+	background: var(--white) !important;
+
+	&, &:focus-within {
+		border-bottom-color: var(--grey-200) !important;
+	}
+}
+
+.search-results {
+	background: var(--white);
+	border-radius: 0 0 $radius $radius;
+	border: 1px solid var(--primary);
+	border-top: none;
+
+	max-height: 50vh;
+	overflow-x: auto;
+	position: absolute;
+	z-index: 100;
+	max-width: 100%;
+	min-width: 100%;
+}
+
+.search-results-inline {
+	position: static;
+}
+
+.search-result-button {
+	background: transparent;
+	text-align: left;
+	box-shadow: none;
+	border-radius: 0;
+	text-transform: none;
+	font-family: $family-sans-serif;
+	font-weight: normal;
+	padding: .5rem;
+	border: none;
+	cursor: pointer;
+	color: var(--grey-800);
+
+	display: flex;
+	justify-content: space-between;
+	align-items: center;
+	overflow: hidden;
+
+	&:focus,
+	&:hover {
+		background: var(--grey-100);
+		box-shadow: none !important;
+
+		.hint-text {
+			color: var(--text);
+		}
+	}
+
+	&:active {
+		background: var(--grey-200);
+	}
+}
+
+.search-result {
+	white-space: nowrap;
+	text-overflow: ellipsis;
+	overflow: hidden;
+	padding: .5rem .75rem;
+}
+
+
+.hint-text {
+	font-size: .75rem;
+	color: transparent;
+	transition: color $transition;
+	padding-left: .5rem;
+}
+
+.has-removal-button {
+	position: relative;
+}
+
+.removal-button {
+	position: absolute;
+	right: .5rem;
+	color: var(--danger);
+}
+</style>

frontend/src/components/input/password.vue

@@ -0,0 +1,85 @@
+<template>
+	<div class="password-field">
+		<input
+			id="password"
+			class="input"
+			name="password"
+			:placeholder="$t('user.auth.passwordPlaceholder')"
+			required
+			:type="passwordFieldType"
+			autocomplete="current-password"
+			:tabindex="props.tabindex"
+			@keyup.enter="e => $emit('submit', e)"
+			@focusout="validate"
+			@input="handleInput"
+		>
+		<BaseButton
+			v-tooltip="passwordFieldType === 'password' ? $t('user.auth.showPassword') : $t('user.auth.hidePassword')"
+			class="password-field-type-toggle"
+			:aria-label="passwordFieldType === 'password' ? $t('user.auth.showPassword') : $t('user.auth.hidePassword')"
+			@click="togglePasswordFieldType"
+		>
+			<icon :icon="passwordFieldType === 'password' ? 'eye' : 'eye-slash'" />
+		</BaseButton>
+	</div>
+	<p
+		v-if="!isValid"
+		class="help is-danger"
+	>
+		{{ $t('user.auth.passwordRequired') }}
+	</p>
+</template>
+
+<script lang="ts" setup>
+import {ref, watch} from 'vue'
+import {useDebounceFn} from '@vueuse/core'
+import BaseButton from '@/components/base/BaseButton.vue'
+
+const props = defineProps({
+	tabindex: String,
+	modelValue: String,
+	// This prop is a workaround to trigger validation from the outside when the user never had focus in the input.
+	validateInitially: Boolean,
+})
+
+const emit = defineEmits(['submit', 'update:modelValue'])
+
+const passwordFieldType = ref('password')
+const password = ref('')
+const isValid = ref(!props.validateInitially)
+
+watch(
+	() => props.validateInitially,
+	() => props.validateInitially && validate(),
+	{immediate: true},
+)
+
+const validate = useDebounceFn(() => {
+	isValid.value = password.value !== ''
+}, 100)
+
+function togglePasswordFieldType() {
+	passwordFieldType.value = passwordFieldType.value === 'password'
+		? 'text'
+		: 'password'
+}
+
+function handleInput(e: Event) {
+	password.value = (e.target as HTMLInputElement)?.value
+	emit('update:modelValue', password.value)
+}
+</script>
+
+<style scoped>
+.password-field {
+	position: relative;
+}
+
+.password-field-type-toggle {
+	position: absolute;
+	color: var(--grey-400);
+	top: 50%;
+	right: 1rem;
+	transform: translateY(-50%);
+}
+</style>