@myelophone/nuxt 0.18.2

package/app/modules/default-sitemap/runtime/sitemap.get.ts

@@ -0,0 +1,42 @@
+// @ts-expect-error generated by default-sitemap module
+import urls from '#default-sitemap/urls.mjs';
+
+export default defineEventHandler((event) => {
+	const config = useRuntimeConfig(event).myelophone;
+
+	const configuredSiteUrl = String(config.siteDomain ?? '').replace(
+		/\/$/,
+		'',
+	);
+	const siteUrl = configuredSiteUrl || getRequestURL(event).origin;
+
+	setResponseHeader(event, 'content-type', 'application/xml; charset=utf-8');
+
+	return createSitemapXml(siteUrl, urls);
+});
+
+function createSitemapXml(siteUrl: string, urls: string[]): string {
+	const body = urls
+		.map((path) => {
+			const loc = escapeXml(`${siteUrl}${path}`);
+
+			return `<url><loc>${loc}</loc></url>`;
+		})
+		.join('');
+
+	return (
+		'<?xml version="1.0" encoding="UTF-8"?>' +
+		'<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">' +
+		body +
+		'</urlset>'
+	);
+}
+
+function escapeXml(value: string): string {
+	return value
+		.replace(/&/g, '&amp;')
+		.replace(/</g, '&lt;')
+		.replace(/>/g, '&gt;')
+		.replace(/"/g, '&quot;')
+		.replace(/'/g, '&apos;');
+}

package/app/modules/fullscreen-preloader/module.ts

@@ -0,0 +1,43 @@
+import { addComponent, addTemplate, defineNuxtModule } from '@nuxt/kit';
+
+interface FullscreenPreloaderConfig {
+	component?: string;
+}
+
+const COMPONENT_NAME_PATTERN = /^[A-Z][A-Za-z0-9_]*$/;
+
+export default defineNuxtModule({
+	meta: {
+		name: '@myelophone/nuxt-fullscreen-preloader',
+	},
+	setup(_options, nuxt) {
+		const configured = nuxt.options.myelophone?.pageFullscreenPreloader as
+			FullscreenPreloaderConfig | undefined;
+
+		const componentName = configured?.component;
+
+		const validComponentName =
+			componentName && COMPONENT_NAME_PATTERN.test(componentName)
+				? componentName
+				: undefined;
+
+		if (componentName && !validComponentName) {
+			console.warn(
+				`[pageFullscreenPreloader] Ignored invalid component name: ${componentName}`,
+			);
+		}
+
+		const wrapper = addTemplate({
+			filename: 'myelophone/fullscreen-preloader-content.vue',
+			getContents: () =>
+				validComponentName
+					? `<template><${validComponentName} v-bind="$attrs" /></template>\n`
+					: '<template></template>\n',
+		});
+
+		addComponent({
+			name: 'PageFullscreenPreloaderConfiguredContent',
+			filePath: wrapper.dst,
+		});
+	},
+});

package/app/modules/htaccess/.htaccess

@@ -0,0 +1,38 @@
+<IfModule mod_rewrite.c>
+RewriteEngine On
+RewriteBase /
+
+RewriteCond %{REQUEST_FILENAME} !-f
+RewriteCond %{REQUEST_FILENAME} !-d
+RewriteCond %{REQUEST_FILENAME}.html -f
+RewriteRule ^(.+?)/?$ $1.html [L]
+</IfModule>
+
+<IfModule mod_expires.c>
+ExpiresActive On
+ExpiresByType text/html "access plus 5 minutes"
+ExpiresByType text/css "access plus 1 year"
+ExpiresByType application/javascript "access plus 1 year"
+ExpiresByType image/webp "access plus 1 year"
+ExpiresByType image/avif "access plus 1 year"
+ExpiresByType image/png "access plus 1 year"
+ExpiresByType image/jpeg "access plus 1 year"
+ExpiresByType image/svg+xml "access plus 1 year"
+ExpiresByType font/woff2 "access plus 1 year"
+</IfModule>
+
+<IfModule mod_headers.c>
+<FilesMatch "\.html$">
+Header set Cache-Control "public, max-age=300, must-revalidate"
+</FilesMatch>
+<FilesMatch "\.(css|js|woff2|png|jpe?g|webp|avif|svg)$">
+Header set Cache-Control "public, max-age=31536000, immutable"
+</FilesMatch>
+Header always set X-Content-Type-Options "nosniff"
+Header always set X-Frame-Options "SAMEORIGIN"
+Header always set Referrer-Policy "strict-origin-when-cross-origin"
+</IfModule>
+
+<IfModule mod_deflate.c>
+AddOutputFilterByType DEFLATE text/html text/css application/javascript application/json image/svg+xml
+</IfModule>

package/app/modules/htaccess/index.ts

@@ -0,0 +1,23 @@
+import { defineNuxtModule } from '@nuxt/kit';
+import { copyFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+export default defineNuxtModule({
+	meta: { name: 'nuxt-static-htaccess' },
+	setup(_, nuxt) {
+		nuxt.hook('nitro:build:public-assets', () => {
+			if (!process.env.NUXT_STATIC) return;
+
+			const src = join(__dirname, '.htaccess');
+			if (!existsSync(src)) return;
+
+			const destDir = join(nuxt.options.rootDir, '.output/public');
+			if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
+
+			const dest = join(destDir, '.htaccess');
+			copyFileSync(src, dest);
+
+			console.info('[htaccess] .htaccess added to ', destDir);
+		});
+	},
+});

package/app/modules/i18n-shaker.mjs

@@ -0,0 +1,221 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const I18N_SAFE_LIST_READY_KEY = '__i18nSafeListReady';
+const I18N_SAFE_LIST_KEYS_KEY = '__i18nSafeListKeys';
+
+function getDefaultSafelistPath() {
+	return path.join('.nuxt', 'i18n-safelist.generated.json');
+}
+
+export default function i18nTreeShaker(options = {}) {
+	const {
+		localesDir = 'locales',
+		safelistPath,
+		generatedSafelistPath = getDefaultSafelistPath(),
+		scanDirs,
+	} = options;
+	const usedKeys = new Set();
+
+	function getFiles(dir) {
+		if (!fs.existsSync(dir)) return [];
+		const dirents = fs.readdirSync(dir, { withFileTypes: true });
+		const files = dirents.map((dirent) => {
+			const res = path.resolve(dir, dirent.name);
+			return dirent.isDirectory() ? getFiles(res) : res;
+		});
+		return files.flat();
+	}
+
+	function setDeep(obj, pathStr, value) {
+		const keys = pathStr.split('.');
+		let current = obj;
+		for (let i = 0; i < keys.length - 1; i++) {
+			const key = keys[i];
+			if (!current[key]) current[key] = {};
+			current = current[key];
+		}
+		current[keys[keys.length - 1]] = value;
+	}
+
+	function getDeep(obj, pathStr) {
+		if (!pathStr) return obj;
+		return pathStr.split('.').reduce((acc, key) => acc && acc[key], obj);
+	}
+
+	function readSafelistFile(filePath) {
+		if (!filePath || !fs.existsSync(filePath)) return [];
+
+		try {
+			const content = fs.readFileSync(filePath, 'utf-8');
+			const parsed = JSON.parse(content);
+			return Array.isArray(parsed) ? parsed : [];
+		} catch (e) {
+			return [];
+		}
+	}
+
+	function writeSafelistFile(filePath, keys) {
+		if (!filePath) return;
+
+		fs.mkdirSync(path.dirname(filePath), { recursive: true });
+		fs.writeFileSync(
+			filePath,
+			`${JSON.stringify(Array.from(keys).sort(), null, 2)}\n`,
+			'utf-8',
+		);
+	}
+
+	return {
+		name: 'vite-plugin-i18n-shaker',
+		enforce: 'pre',
+		apply: 'build',
+
+		async buildStart() {
+			usedKeys.clear();
+
+			const safeListReady = globalThis[I18N_SAFE_LIST_READY_KEY];
+			if (safeListReady && typeof safeListReady.then === 'function') {
+				await safeListReady;
+			}
+
+			const resolvedGeneratedSafelistPath = path.isAbsolute(
+				generatedSafelistPath,
+			)
+				? generatedSafelistPath
+				: path.resolve(process.cwd(), generatedSafelistPath);
+			const resolvedManualSafelistPath = safelistPath
+				? path.isAbsolute(safelistPath)
+					? safelistPath
+					: path.resolve(process.cwd(), safelistPath)
+				: null;
+			const registeredKeys = globalThis[I18N_SAFE_LIST_KEYS_KEY];
+			const generatedKeys = new Set(
+				registeredKeys instanceof Set
+					? Array.from(registeredKeys)
+					: Array.isArray(registeredKeys)
+						? registeredKeys
+						: [],
+			);
+
+			readSafelistFile(resolvedManualSafelistPath).forEach((key) => {
+				if (typeof key === 'string') usedKeys.add(key);
+			});
+
+			if (generatedKeys.size) {
+				writeSafelistFile(resolvedGeneratedSafelistPath, generatedKeys);
+				generatedKeys.forEach((key) => usedKeys.add(key));
+			}
+
+			const rootDir = process.cwd();
+			const defaultScanDirs = [
+				path.resolve(rootDir, 'app'),
+				...(process.env.NUXT_PLAYGROUND === 'true'
+					? [path.resolve(rootDir, 'playground')]
+					: []),
+			];
+			const projectLayers = scanDirs || defaultScanDirs;
+
+			projectLayers.forEach((layerPath) => {
+				if (fs.existsSync(layerPath)) {
+					getFiles(layerPath).forEach((file) => {
+						if (/\.(vue|ts|js|mjs)$/.test(file)) {
+							const content = fs.readFileSync(file, 'utf-8');
+
+							const regex =
+								/(?:(?:\$t|t|tn)\s*\(\s*['"`])([a-zA-Z0-9/_.-]+)(?=['"`]\s*[,)])/g;
+
+							const matches = content.matchAll(regex);
+							for (const match of matches) {
+								if (match[1]) usedKeys.add(match[1]);
+							}
+
+							const keepRegex =
+								/@i18n-keep\s+([a-zA-Z0-9/_.-]+)/g;
+							const keepMatches = content.matchAll(keepRegex);
+							for (const match of keepMatches) {
+								if (match[1]) usedKeys.add(match[1]);
+							}
+						}
+					});
+				}
+			});
+		},
+
+		transform(code, id) {
+			const cleanId = id.split('?')[0].replace(/\\/g, '/');
+
+			if (
+				cleanId.includes(`/${localesDir}/`) &&
+				cleanId.endsWith('.json')
+			) {
+				try {
+					const rawJson = JSON.parse(code);
+					const filteredJson = {};
+					let keptCount = 0;
+
+					const parts = cleanId
+						.split(`/${localesDir}/`)[1]
+						.split('/');
+					const namespace = parts
+						.slice(1)
+						.join('/')
+						.replace('.json', '');
+
+					usedKeys.forEach((fullKey) => {
+						if (
+							fullKey.startsWith(`${namespace}.`) ||
+							fullKey === namespace
+						) {
+							const internalKey =
+								fullKey === namespace
+									? ''
+									: fullKey.slice(namespace.length + 1);
+
+							const value = getDeep(rawJson, internalKey);
+							if (value !== undefined) {
+								if (typeof value === 'string') {
+									setDeep(filteredJson, internalKey, value);
+									keptCount++;
+								} else if (typeof value === 'object') {
+									setDeep(filteredJson, internalKey, value);
+									keptCount += Object.keys(value).length;
+								}
+							}
+
+							const pathParts = internalKey.split('.');
+							const lastPart = pathParts.pop();
+							const parentPath = pathParts.join('.');
+							const parentObj = getDeep(rawJson, parentPath);
+
+							if (parentObj && typeof parentObj === 'object') {
+								Object.keys(parentObj).forEach((k) => {
+									if (k.startsWith(`${lastPart}_`)) {
+										const pluralPath = parentPath
+											? `${parentPath}.${k}`
+											: k;
+										setDeep(
+											filteredJson,
+											pluralPath,
+											parentObj[k],
+										);
+										keptCount++;
+									}
+								});
+							}
+						}
+					});
+
+					return {
+						code: JSON.stringify(filteredJson),
+						map: null,
+					};
+				} catch (e) {
+					console.error(`[i18n-shaker] Error in ${id}:`, e);
+					return null;
+				}
+			}
+			return null;
+		},
+	};
+}

package/app/modules/multi18n/module.ts

@@ -0,0 +1,71 @@
+import {
+	defineNuxtModule,
+	createResolver,
+	addComponentsDir,
+	addImportsDir,
+} from 'nuxt/kit';
+
+export interface MyelophoneNuxtModuleOptions {
+	defaultLocale: string;
+	locales: string[];
+}
+
+export default defineNuxtModule<MyelophoneNuxtModuleOptions>({
+	meta: {
+		name: 'multi18n-module',
+		configKey: 'multi18n',
+		compatibility: { nuxt: '^4.0.0' },
+	},
+
+	defaults: {
+		defaultLocale: 'en',
+		locales: ['en'],
+	},
+
+	async setup(options, nuxt) {
+		const localOptions = { ...options };
+		const { resolve } = createResolver(import.meta.url);
+
+		nuxt.hooks.hook('pages:extend', (pages) => {
+			const { locales, defaultLocale } = localOptions;
+			const otherLocales = locales.filter((l) => l !== defaultLocale);
+
+			const newPages = [];
+			const existingPaths = new Set(pages.map((p) => p.path));
+
+			for (const page of pages) {
+				if (page.meta?.i18n === false) continue;
+
+				if (page.file?.includes('[...all]')) continue;
+
+				for (const lang of otherLocales) {
+					if (page.path === '/' && lang === defaultLocale) continue;
+
+					const localizedPath =
+						page.path === '/' ? `/${lang}` : `/${lang}${page.path}`;
+
+					if (existingPaths.has(localizedPath)) continue;
+					existingPaths.add(localizedPath);
+
+					newPages.push({
+						...page,
+						path: localizedPath,
+						file: page.file,
+						name: `${lang}-${page.name || page.path.replace(/\W+/g, '_')}`,
+						aliasOf: page.path,
+					});
+				}
+			}
+
+			pages.push(...newPages);
+		});
+
+		addComponentsDir({
+			path: resolve('runtime/components'),
+			pathPrefix: false,
+		});
+		addImportsDir(resolve('runtime/composables'));
+		addImportsDir(resolve('runtime/utils'));
+		addImportsDir(resolve('runtime/stores'));
+	},
+});

package/app/modules/myelophone-config/module.ts

@@ -0,0 +1,241 @@
+import { defineNuxtModule, extendViteConfig, useLogger } from '@nuxt/kit';
+
+import type {
+	MyelophoneClientConfig,
+	MyelophoneConfig,
+	MyelophoneMulti18nConfig,
+} from '~/types/myelophone';
+
+const isSSG = process.env.NUXT_STATIC === 'true';
+const isSSRStreaming = process.env.NUXT_SSR_STREAMING === 'true';
+
+const setSSRStreaming = (
+	experimental: Record<string, any>,
+	enabled: boolean,
+) => {
+	const current = experimental.ssrStreaming;
+
+	experimental.ssrStreaming = {
+		...(current && typeof current === 'object' ? current : {}),
+		enabled,
+	};
+};
+
+const enableDefaultRouteStreaming = (routeRules: Record<string, any>) => {
+	const current = routeRules['/**'];
+
+	routeRules['/**'] = {
+		...(current && typeof current === 'object' ? current : {}),
+		streaming:
+			current && typeof current === 'object' && 'streaming' in current
+				? current.streaming
+				: true,
+	};
+};
+
+const defaultCookieScripts = {
+	necessary: [],
+	analytics: [],
+	marketing: [],
+	functional: [],
+};
+
+export const defaultMyelophoneConfig: MyelophoneConfig = {
+	siteDomain: 'http://localhost:3000',
+	cookieScripts: defaultCookieScripts,
+	cookieControl: {
+		enabled: true,
+	},
+	bundleTranslations: true,
+	splitCss: false,
+	stores: {
+		cart: false,
+		user: false,
+	},
+	frankfurterCurrencies: [],
+	frankfurterBaseCurrency: 'USD',
+	creativeCursor: false,
+	siteSearch: {
+		strategy: 'client',
+		endpoint: '',
+		minQueryLength: 2,
+		limit: 10,
+		operator: 'and',
+		queryParam: 'search',
+		modeParam: 'searchMode',
+		operatorParam: 'searchOperator',
+		urlMode: 'search',
+		consumeUrl: false,
+		enabled: true,
+	},
+	tally: {
+		domain: 'tally.so',
+	},
+	noindex: false,
+	blog: {
+		blogEnabled: true,
+		postsLayout: 'default-blog',
+	},
+	ssrStream: false,
+};
+
+const resolveMyelophoneConfig = (
+	config?: Partial<MyelophoneConfig>,
+): MyelophoneConfig => ({
+	...defaultMyelophoneConfig,
+	...config,
+	cookieScripts:
+		config?.cookieScripts ?? defaultMyelophoneConfig.cookieScripts,
+	cookieControl: {
+		...defaultMyelophoneConfig.cookieControl,
+		...config?.cookieControl,
+		enabled:
+			config?.cookieControl?.enabled ??
+			defaultMyelophoneConfig.cookieControl?.enabled ??
+			true,
+	},
+	stores: {
+		...defaultMyelophoneConfig.stores,
+		...config?.stores,
+	},
+	siteSearch: {
+		...defaultMyelophoneConfig.siteSearch,
+		...config?.siteSearch,
+	},
+	pageFullscreenPreloader:
+		config?.pageFullscreenPreloader ??
+		defaultMyelophoneConfig.pageFullscreenPreloader,
+	tally: {
+		...defaultMyelophoneConfig.tally,
+		...config?.tally,
+	},
+	blog: {
+		...defaultMyelophoneConfig.blog,
+		...config?.blog,
+	},
+});
+
+const resolveMulti18nConfig = (config: unknown): MyelophoneMulti18nConfig => {
+	const value = (config || {}) as Partial<MyelophoneMulti18nConfig>;
+	const defaultLocale = value.defaultLocale || 'en';
+	const locales = [
+		...new Set(value.locales?.length ? value.locales : ['en']),
+	];
+
+	return {
+		defaultLocale,
+		locales,
+	};
+};
+
+const resolveClientConfig = (
+	config: Partial<MyelophoneConfig>,
+	multi18n: unknown,
+): MyelophoneClientConfig => ({
+	...resolveMyelophoneConfig(config),
+	multi18n: resolveMulti18nConfig(multi18n),
+});
+
+export default defineNuxtModule<MyelophoneConfig>({
+	meta: {
+		name: '@myelophone/nuxt-config',
+		configKey: 'myelophone',
+		compatibility: { nuxt: '^4.0.0' },
+	},
+
+	defaults: defaultMyelophoneConfig,
+
+	setup(options, nuxt) {
+		const head = nuxt.options.app.head as Record<string, unknown>;
+		const staticTitle = head.title;
+		if (typeof staticTitle === 'string') {
+			const appConfig = nuxt.options.appConfig as Record<string, unknown>;
+			const defaultSeo =
+				(appConfig.defaultSeo as Record<string, unknown> | undefined) ||
+				{};
+			nuxt.options.appConfig = {
+				...appConfig,
+				defaultSeo: {
+					...defaultSeo,
+					title:
+						typeof defaultSeo.title === 'string'
+							? defaultSeo.title
+							: staticTitle,
+				},
+			} as typeof nuxt.options.appConfig;
+			delete head.title;
+		}
+
+		const logger = useLogger('@myelophone/nuxt');
+		const myelophone = resolveClientConfig(options, nuxt.options.multi18n);
+		const isStreamingSSR =
+			!isSSG && (isSSRStreaming || myelophone.ssrStream === true);
+
+		nuxt.options.myelophone = myelophone;
+		nuxt.options.runtimeConfig.myelophone = myelophone;
+
+		setSSRStreaming(nuxt.options.experimental, isStreamingSSR);
+
+		if (isStreamingSSR) {
+			nuxt.options.routeRules ||= {};
+			enableDefaultRouteStreaming(nuxt.options.routeRules);
+		}
+
+		nuxt.hook('build:before', () => {
+			logger.info(
+				'Thank You for using @MyelophOne/nuxt. With ❤️ from @aleksivanou (aleksivanov.me)',
+			);
+			if (isStreamingSSR) {
+				logger.info('Building with Nuxt streaming SSR enabled.');
+			}
+		});
+
+		nuxt.hook('nitro:config', (nitroConfig) => {
+			nitroConfig.runtimeConfig ||= {};
+			nitroConfig.runtimeConfig.myelophone = myelophone;
+
+			if (isStreamingSSR) {
+				nitroConfig.routeRules ||= {};
+				enableDefaultRouteStreaming(nitroConfig.routeRules);
+			}
+		});
+
+		nuxt.hook('modules:done', () => {
+			const config = nuxt.options.runtimeConfig;
+			config.myelophone = myelophone;
+
+			const keysToRemove = ['nuxt-seo-utils-version'];
+
+			keysToRemove.forEach((key) => {
+				if (config.public && key in config.public) {
+					delete config.public[key];
+				}
+			});
+
+			const objectsToRemoveVersion = ['nuxt-scripts', 'nuxt-robots'];
+
+			objectsToRemoveVersion.forEach((objKey) => {
+				if (
+					config.public &&
+					objKey in config.public &&
+					config.public[objKey]
+				) {
+					const target = config.public[objKey];
+					delete target['version' as keyof typeof target];
+				}
+			});
+		});
+
+		extendViteConfig((config) => {
+			config.build = config.build || {};
+			config.build.cssCodeSplit = myelophone.splitCss === true;
+			config.define = {
+				...config.define,
+				__MYELOPHONE_CONFIG__: JSON.stringify(myelophone).replace(
+					/</g,
+					'\\u003C',
+				),
+			};
+		});
+	},
+});

package/app/pages/[...all].vue

@@ -0,0 +1,9 @@
+<script setup lang="ts">
+definePageMeta({
+	middleware: "not-found-status",
+});
+</script>
+
+<template>
+	<ViewNotFound />
+</template>

package/app/pages/index.vue

@@ -0,0 +1,3 @@
+<template>
+	<MyelophoneWelcome />
+</template>