@myelophone/nuxt 0.18.2

package/app/pages/post/[...slug].vue

@@ -0,0 +1,30 @@
+<script setup lang="ts">
+const route = useRoute();
+
+const param = "slug" in route.params ? route.params.slug : undefined;
+
+const slug = Array.isArray(param) ? param.join("/") : (param ?? "");
+
+if (import.meta.server) {
+	const { getPost } = await import("#myelophone/app/utils/blog.server");
+	const post = await getPost(slug);
+
+	if (!post) {
+		const event = useRequestEvent();
+
+		if (event) {
+			setResponseStatus(event, 404);
+		}
+	} else {
+		useAppSeo({
+			title: post.meta.title,
+			description: post.meta.description,
+			image: post.meta.image,
+		});
+	}
+}
+</script>
+
+<template>
+	<UiPostContent :slug="slug" />
+</template>

package/app/plugins/bfcache-refresh.client.ts

@@ -0,0 +1,9 @@
+export default defineNuxtPlugin(() => {
+	if (import.meta.client) {
+		window.addEventListener('pageshow', (event) => {
+			if (event.persisted) {
+				refreshNuxtData();
+			}
+		});
+	}
+});

package/app/plugins/canonical.ts

@@ -0,0 +1,30 @@
+export default defineNuxtPlugin(() => {
+	const route = useRoute();
+	const url = useRequestURL();
+
+	const canonicalUrl = computed(() => {
+		const origin = url.origin;
+		const path = route.path;
+
+		const normalizedPath =
+			path.length > 1 && path.endsWith('/') ? path.slice(0, -1) : path;
+
+		const queryParts = [];
+		if (route.query.page) {
+			queryParts.push(`page=${route.query.page}`);
+		}
+		const queryString =
+			queryParts.length > 0 ? `?${queryParts.join('&')}` : '';
+
+		return `${origin}${normalizedPath}${queryString}`;
+	});
+
+	useHead({
+		link: [
+			{
+				rel: 'canonical',
+				href: canonicalUrl,
+			},
+		],
+	});
+});

package/app/plugins/csp-nonce.server.ts

@@ -0,0 +1,41 @@
+import {
+	getResponseStatus,
+	getResponseStatusText,
+	setResponseHeader,
+	setResponseStatus,
+} from 'h3';
+
+export default defineNuxtPlugin((nuxtApp) => {
+	const nonce = useNonce();
+	const ssrContext = nuxtApp.ssrContext;
+	const head = ssrContext?.head;
+
+	if (!ssrContext?.event) {
+		return;
+	}
+
+	setResponseHeader(
+		ssrContext.event,
+		'content-type',
+		'text/html;charset=utf-8',
+	);
+	if (!getResponseStatusText(ssrContext.event)) {
+		setResponseStatus(
+			ssrContext.event,
+			getResponseStatus(ssrContext.event),
+			'OK',
+		);
+	}
+
+	if (!nonce || !head) {
+		return;
+	}
+
+	head.hooks?.hook('tags:resolve', ({ tags }) => {
+		const script = tags.find((tag) => tag.tag === 'script');
+
+		if (script) {
+			script.props.nonce ??= nonce;
+		}
+	});
+});

package/app/plugins/multi18n.client.ts

@@ -0,0 +1,21 @@
+import { type Pinia } from 'pinia';
+
+export default defineNuxtPlugin(() => {
+	const pinia = useNuxtApp().$pinia as Pinia;
+	const settingsStore = useSettingsStore(pinia);
+	const route = useRoute();
+
+	watch(
+		() => route.path,
+		(path) => {
+			const seg = path.split('/').filter(Boolean)[0];
+
+			if (seg && settingsStore.locales.includes(seg)) {
+				settingsStore.currentLocale = seg;
+			} else {
+				settingsStore.currentLocale = settingsStore.defaultLocale;
+			}
+		},
+		{ immediate: true },
+	);
+});

package/app/plugins/multi18n.server.ts

@@ -0,0 +1,15 @@
+import { type Pinia } from 'pinia';
+
+export default defineNuxtPlugin(() => {
+	const pinia = useNuxtApp().$pinia as Pinia;
+	const settingsStore = useSettingsStore(pinia);
+	const route = useRoute();
+	const segments = route.path.split('/').filter(Boolean);
+	const maybeLang = segments[0];
+
+	if (maybeLang && settingsStore.locales.includes(maybeLang)) {
+		settingsStore.currentLocale = maybeLang;
+	} else {
+		settingsStore.currentLocale = settingsStore.defaultLocale;
+	}
+});

package/app/plugins/nuxt-version.client.ts

@@ -0,0 +1,4 @@
+export default defineNuxtPlugin(() => {
+	const version = import.meta.env.PACKAGE_VERSION || '4.x';
+	return { provide: { nuxtVersion: version } };
+});

package/app/plugins/restore.client.ts

@@ -0,0 +1,21 @@
+export default defineNuxtPlugin((nuxtApp) => {
+	if (!import.meta.client) return;
+
+	const initialY = window.scrollY;
+
+	if (initialY > 0) {
+		const originalScrollTo = window.scrollTo;
+
+		window.scrollTo = function (x?: any, y?: any) {
+			const targetY = typeof x === 'object' ? x.top : y;
+
+			if (targetY === 0) return;
+
+			return originalScrollTo.apply(this, arguments as any);
+		};
+
+		nuxtApp.hook('app:suspense:resolve', () => {
+			window.scrollTo = originalScrollTo;
+		});
+	}
+});

package/app/plugins/reveal.ts

@@ -0,0 +1,89 @@
+export default defineNuxtPlugin((nuxtApp) => {
+	const { isStaticMode } = useDevice();
+	const { isSlowConnection } = useNetwork();
+
+	if (import.meta.server) {
+		nuxtApp.vueApp.directive('reveal', {
+			getSSRProps: () => ({
+				'data-v-reveal': '',
+				class: isStaticMode.value ? 'is-visible' : '',
+			}),
+		});
+		return;
+	}
+
+	const shouldSkipAnimation = computed(
+		() => isStaticMode.value || isSlowConnection.value,
+	);
+
+	if (shouldSkipAnimation.value) {
+		nuxtApp.vueApp.directive('reveal', {
+			mounted(el: HTMLElement) {
+				el.classList.add('is-visible');
+			},
+		});
+		return;
+	}
+
+	let revealQueue: HTMLElement[] = [];
+	let revealTimer: ReturnType<typeof setTimeout> | null = null;
+
+	const observer = new IntersectionObserver(
+		(entries) => {
+			entries.forEach((entry) => {
+				const el = entry.target as HTMLElement;
+				const isRepeat = (el as any)._revealRepeat;
+
+				if (entry.isIntersecting) {
+					if (el.classList.contains('is-visible')) return;
+
+					revealQueue.push(el);
+					if (revealTimer) clearTimeout(revealTimer);
+
+					revealTimer = setTimeout(() => {
+						revealQueue.forEach((item, index) => {
+							const step = (item as any)._revealStep || 100;
+							item.style.setProperty(
+								'--reveal-delay',
+								`${index * step}ms`,
+							);
+							requestAnimationFrame(() =>
+								item.classList.add('is-visible'),
+							);
+						});
+						revealQueue = [];
+					}, 50);
+
+					if (!isRepeat) observer.unobserve(el);
+				} else {
+					if (isRepeat && el.classList.contains('is-visible')) {
+						el.classList.remove('is-visible');
+						el.style.removeProperty('--reveal-delay');
+					}
+				}
+			});
+		},
+		{
+			rootMargin: '20px 0px 20px 0px',
+			threshold: [0, 0.15],
+		},
+	);
+
+	nuxtApp.vueApp.directive('reveal', {
+		mounted(el: HTMLElement, binding) {
+			const type = binding.arg || 'slide';
+			(el as any)._revealStep =
+				typeof binding.value === 'number' ? binding.value : 100;
+			(el as any)._revealRepeat = !!binding.modifiers.repeat;
+
+			el.classList.add('reveal-active', `reveal-${type}`);
+			if (binding.modifiers.fast) el.classList.add('reveal-fast');
+			if (binding.modifiers.slow) el.classList.add('reveal-slow');
+
+			observer.observe(el);
+		},
+		unmounted(el: HTMLElement) {
+			observer.unobserve(el);
+		},
+	});
+});

package/app/plugins/url-helper.client.ts

@@ -0,0 +1,66 @@
+import { type Pinia } from 'pinia';
+
+export default defineNuxtPlugin((nuxtApp) => {
+	const router = useRouter();
+
+	const pinia = useNuxtApp().$pinia as Pinia;
+	const settingsStore = useSettingsStore(pinia);
+
+	nuxtApp.hook('app:beforeMount', () => {
+		settingsStore.loadTheme();
+	});
+
+	nuxtApp.hook('page:start', () => {
+		settingsStore.setIsLoading(true);
+	});
+
+	nuxtApp.hook('page:finish', () => {
+		settingsStore.setIsLoading(false);
+	});
+
+	router.beforeEach((to) => {
+		let path = to.path;
+
+		path = path
+			.replace(/[<>{}|\\^`]/g, '')
+			.replace(/\/+/g, '/')
+			.replace(/\.\.\//g, '')
+			.replace(/\.\./g, '');
+
+		try {
+			path = encodeURI(decodeURI(path));
+		} catch (_) {}
+
+		if (path.length > 1 && path.endsWith('/')) {
+			path = path.replace(/\/+$/, '');
+		}
+
+		path = path.toLowerCase();
+
+		if (path !== to.path) {
+			return router.replace({
+				path,
+				query: to.query,
+				hash: to.hash,
+			});
+		}
+
+		if (location.hostname.startsWith('www.')) {
+			const nonWwwHost = location.hostname.replace(/^www\./, '');
+			const newUrl = `${location.protocol}//${nonWwwHost}${location.pathname}${location.search}${location.hash}`;
+			return location.replace(newUrl);
+		}
+
+		const isLocalhost =
+			location.hostname === 'localhost' ||
+			location.hostname.startsWith('127.') ||
+			location.hostname.startsWith('192.168.') ||
+			location.hostname === '[::1]' ||
+			/^\d+\.\d+\.\d+\.\d+$/.test(location.hostname);
+
+		if (location.protocol === 'http:' && !isLocalhost) {
+			const httpsUrl = `https://${location.host}${location.pathname}${location.search}${location.hash}`;
+			return location.replace(httpsUrl);
+		}
+	});
+});

package/app/server/api/exchange-rates.get.ts

@@ -0,0 +1,216 @@
+interface FrankfurterRate {
+	date: string;
+	base: string;
+	quote: string;
+	rate: number;
+	providers?: string[];
+}
+
+interface FrankfurterErrorResponse {
+	message?: string;
+}
+
+interface FetchErrorLike {
+	status?: number;
+	statusCode?: number;
+	statusText?: string;
+	statusMessage?: string;
+	message?: string;
+	data?: FrankfurterErrorResponse;
+}
+
+type CurrencyConfigValue =
+	string | string[] | readonly string[] | null | undefined;
+
+const FRANKFURTER_RATES_URL = 'https://api.frankfurter.dev/v2/rates';
+
+const normalizeCurrency = (value: unknown, fallback = ''): string => {
+	const normalized = String(value ?? fallback)
+		.trim()
+		.toUpperCase()
+		.replace(/[^A-Z]/g, '');
+
+	return normalized || fallback;
+};
+
+const isValidCurrencyCode = (currency: string): boolean => {
+	return /^[A-Z]{3}$/.test(currency);
+};
+
+const parseCurrencyList = (
+	value: CurrencyConfigValue,
+	base: string,
+): string[] => {
+	const rawValues = Array.isArray(value)
+		? value
+		: String(value ?? '').split(',');
+
+	return [
+		...new Set(
+			rawValues
+				.flatMap((item) => String(item).split(','))
+				.map((item) => normalizeCurrency(item))
+				.filter(
+					(currency) =>
+						currency !== base && isValidCurrencyCode(currency),
+				),
+		),
+	];
+};
+
+const parseQueryCurrencies = (
+	searchParams: URLSearchParams,
+	base: string,
+): string[] => {
+	const values = searchParams.getAll('currencies');
+
+	return parseCurrencyList(values, base);
+};
+
+const getProviderStatus = (error: unknown): number | undefined => {
+	if (!error || typeof error !== 'object') {
+		return undefined;
+	}
+
+	const fetchError = error as FetchErrorLike;
+
+	return fetchError.statusCode ?? fetchError.status;
+};
+
+const getProviderErrorMessage = (error: unknown): string => {
+	if (!error || typeof error !== 'object') {
+		return 'Unknown currency provider error.';
+	}
+
+	const fetchError = error as FetchErrorLike;
+
+	return (
+		fetchError.data?.message ??
+		fetchError.statusMessage ??
+		fetchError.statusText ??
+		fetchError.message ??
+		'Unknown currency provider error.'
+	);
+};
+
+export default defineEventHandler(async (event) => {
+	const config = useRuntimeConfig(event).myelophone;
+
+	const requestUrl = getRequestURL(event);
+
+	const configuredBase = normalizeCurrency(
+		config.frankfurterBaseCurrency,
+		'USD',
+	);
+
+	const base = normalizeCurrency(
+		requestUrl.searchParams.get('base'),
+		configuredBase,
+	);
+
+	if (!isValidCurrencyCode(base)) {
+		throw createError({
+			statusCode: 400,
+			statusMessage: 'Invalid Currency',
+			message:
+				'The "base" parameter must be a valid three-letter currency code, for example USD, EUR, RUB or BYN.',
+		});
+	}
+
+	const queryCurrencies = parseQueryCurrencies(requestUrl.searchParams, base);
+
+	const configuredCurrencies = parseCurrencyList(
+		config.frankfurterCurrencies as CurrencyConfigValue,
+		base,
+	);
+
+	const currencies =
+		queryCurrencies.length > 0 ? queryCurrencies : configuredCurrencies;
+
+	const providerUrl = new URL(FRANKFURTER_RATES_URL);
+
+	providerUrl.searchParams.set('base', base);
+
+	if (currencies.length > 0) {
+		providerUrl.searchParams.set('quotes', currencies.join(','));
+	}
+
+	let response: FrankfurterRate[];
+
+	try {
+		response = await $fetch<FrankfurterRate[]>(providerUrl.toString(), {
+			method: 'GET',
+			headers: {
+				accept: 'application/json',
+			},
+			retry: 1,
+			timeout: 10_000,
+		});
+	} catch (error: unknown) {
+		const providerStatus = getProviderStatus(error);
+
+		const providerMessage = getProviderErrorMessage(error);
+
+		if (
+			providerStatus === 400 ||
+			providerStatus === 404 ||
+			providerStatus === 422
+		) {
+			throw createError({
+				statusCode: 400,
+				statusMessage: 'Invalid Currency Request',
+				message: providerMessage,
+				cause: error,
+			});
+		}
+
+		throw createError({
+			statusCode: 502,
+			statusMessage: 'Currency Provider Error',
+			message: 'Failed to retrieve exchange rates from Frankfurter.',
+			cause: error,
+		});
+	}
+
+	if (!Array.isArray(response)) {
+		throw createError({
+			statusCode: 502,
+			statusMessage: 'Invalid Provider Response',
+			message: 'Frankfurter returned an unexpected response format.',
+		});
+	}
+
+	const rates: Record<string, number> = {
+		[base]: 1,
+	};
+
+	const responseDates: string[] = [];
+
+	for (const item of response) {
+		const quote = normalizeCurrency(item?.quote);
+
+		if (
+			!isValidCurrencyCode(quote) ||
+			typeof item.rate !== 'number' ||
+			!Number.isFinite(item.rate) ||
+			item.rate <= 0
+		) {
+			continue;
+		}
+
+		rates[quote] = item.rate;
+
+		if (item.date) {
+			responseDates.push(item.date);
+		}
+	}
+
+	const date = responseDates.sort().at(-1) ?? null;
+
+	return {
+		base,
+		date,
+		rates,
+		source: FRANKFURTER_RATES_URL,
+	};
+});

package/app/server/api/healthz.ts

@@ -0,0 +1 @@
+export default eventHandler(() => 'ok');

package/app/server/api/logout.post.ts

@@ -0,0 +1,6 @@
+export default defineEventHandler(async (event) => {
+	deleteCookie(event, 'token', { path: '/' });
+	deleteCookie(event, 'sessionExpiry', { path: '/' });
+
+	return { success: true };
+});

package/app/server/middleware/normalize-url.ts

@@ -0,0 +1,14 @@
+export default defineEventHandler((event) => {
+	const originalPath = event.path || '/';
+	let normalized = originalPath;
+
+	normalized = normalized.replace(/\/{2,}/g, '/');
+
+	if (normalized.length > 1 && normalized.endsWith('/')) {
+		normalized = normalized.slice(0, -1);
+	}
+
+	if (normalized !== originalPath) {
+		return sendRedirect(event, normalized, 301);
+	}
+});