@myelophone/nuxt 0.18.2

package/app/types/myelophone.d.ts

@@ -0,0 +1,87 @@
+import type { CookieScriptsConfig, CookieControlConfig } from '~/types/cookie';
+
+export interface MyelophoneMulti18nConfig {
+	defaultLocale: string;
+	locales: string[];
+}
+
+export interface PageFullscreenPreloaderConfig {
+	component?: string;
+	props?: Record<string, unknown>;
+	transparent?: boolean;
+	background?: string;
+	backgroundDark?: string;
+	zIndex?: number | string;
+	ariaLabel?: string;
+	class?: string;
+	contentClass?: string;
+	minimumDuration?: number;
+}
+
+export interface SiteSearchConfig {
+	strategy?: string;
+	endpoint?: string;
+	minQueryLength?: number;
+	limit?: number;
+	operator?: string;
+	queryParam?: string;
+	modeParam?: string;
+	operatorParam?: string;
+	urlMode?: string;
+	consumeUrl?: boolean;
+	enabled?: boolean;
+}
+
+export interface MyelophoneStoresConfig {
+	cart: boolean;
+	user: boolean;
+}
+
+export interface MyelophoneBlogConfig {
+	blogEnabled?: boolean;
+	postsLayout?: string;
+}
+
+export interface MyelophoneTallyConfig {
+	domain?: string;
+}
+
+export interface MyelophoneConfig {
+	siteDomain?: string;
+	cookieScripts?: CookieScriptsConfig;
+	cookieControl?: CookieControlConfig;
+	bundleTranslations?: boolean;
+	splitCss?: boolean;
+	stores: MyelophoneStoresConfig;
+	frankfurterCurrencies: string[];
+	frankfurterBaseCurrency: string;
+	creativeCursor: boolean;
+	siteSearch: SiteSearchConfig;
+	pageFullscreenPreloader?: PageFullscreenPreloaderConfig;
+	tally?: MyelophoneTallyConfig;
+	noindex?: boolean;
+	blog?: MyelophoneBlogConfig;
+	ssrStream?: boolean;
+}
+
+export interface MyelophoneClientConfig extends MyelophoneConfig {
+	multi18n: MyelophoneMulti18nConfig;
+}
+
+declare global {
+	const __MYELOPHONE_CONFIG__: MyelophoneClientConfig;
+}
+
+declare module '@nuxt/schema' {
+	interface RuntimeConfig {
+		myelophone: MyelophoneClientConfig;
+	}
+	interface NuxtConfig {
+		myelophone?: Partial<MyelophoneConfig>;
+	}
+	interface NuxtOptions {
+		myelophone?: MyelophoneConfig;
+	}
+}
+
+export {};

package/app/types/site-search.ts

@@ -0,0 +1,110 @@
+export interface SiteSearchDocument {
+	id: string;
+	url: string;
+	path: string;
+	title: string;
+	description: string;
+	headings: string;
+	content: string;
+	locale: string;
+}
+
+export type SiteSearchOperator = 'and' | 'or';
+export type SiteSearchStrategy = 'client' | 'remote';
+export type SiteSearchRange = [number, number];
+
+export interface SiteSearchRemoteResult {
+	id?: string;
+	url?: string;
+	path: string;
+	title: string;
+	description?: string;
+	snippet?: string;
+	locale?: string;
+	score?: number;
+	highlights?: {
+		title?: SiteSearchRange[];
+		snippet?: SiteSearchRange[];
+		path?: SiteSearchRange[];
+	};
+}
+
+export interface SiteSearchRemoteResponse {
+	results: SiteSearchRemoteResult[];
+	total?: number;
+}
+
+export interface SiteSearchResult {
+	id: string;
+	url: string;
+	path: string;
+	title: string;
+	description: string;
+	snippet: string;
+	titleMatches: SiteSearchRange[];
+	snippetMatches: SiteSearchRange[];
+	pathMatches: SiteSearchRange[];
+	locale: string;
+	score: number;
+}
+
+export interface SiteSearchWorkerOptions {
+	origin: string;
+	basePath: string;
+	seedUrls: string[];
+	locales: string[];
+	defaultLocale: string;
+	maxPages: number;
+	maxContentLength: number;
+	concurrency: number;
+	cacheTtl: number;
+	respectNoIndex: boolean;
+	discoverSitemaps: boolean;
+}
+
+export type SiteSearchWorkerRequest =
+	| {
+			type: 'init';
+			requestId: number;
+			options: SiteSearchWorkerOptions;
+	  }
+	| {
+			type: 'search';
+			requestId: number;
+			query: string;
+			locale: string;
+			allLocales: boolean;
+			operator: SiteSearchOperator;
+			limit: number;
+	  }
+	| {
+			type: 'clear-cache';
+			requestId: number;
+	  };
+
+export type SiteSearchWorkerResponse =
+	| {
+			type: 'progress';
+			indexed: number;
+			total: number;
+	  }
+	| {
+			type: 'ready';
+			requestId: number;
+			count: number;
+			cached: boolean;
+	  }
+	| {
+			type: 'results';
+			requestId: number;
+			results: SiteSearchResult[];
+	  }
+	| {
+			type: 'cache-cleared';
+			requestId: number;
+	  }
+	| {
+			type: 'error';
+			requestId: number;
+			message: string;
+	  };

package/app/utils/asyncRefresh.ts

@@ -0,0 +1,4 @@
+// biome-ignore lint/suspicious/noExplicitAny: generic type
+export const useAsyncRefresh = (refresh: (opts?: any) => Promise<void>) => {
+	return () => refresh();
+};

package/app/utils/blog.server.ts

@@ -0,0 +1,142 @@
+import { parse } from 'yaml';
+import MarkdownIt from 'markdown-it';
+
+export interface PostMeta {
+	title?: string;
+	description?: string;
+	image?: string;
+}
+
+export interface Post {
+	content: string;
+	meta: PostMeta;
+}
+
+type PostLoader = () => Promise<string>;
+
+const postCache = new Map<string, Promise<Post>>();
+const markdown = new MarkdownIt({
+	html: false,
+	linkify: true,
+	typographer: true,
+});
+const blockTagPattern =
+	/(<\/?(?:address|article|aside|blockquote|div|dl|dt|dd|fieldset|figcaption|figure|footer|form|h[1-6]|header|hr|li|main|nav|ol|p|section|table|tbody|td|tfoot|th|thead|tr|ul)\b[^>]*>)\s+(?=<\/?(?:address|article|aside|blockquote|div|dl|dt|dd|fieldset|figcaption|figure|footer|form|h[1-6]|header|hr|li|main|nav|ol|p|section|table|tbody|td|tfoot|th|thead|tr|ul)\b)/gi;
+
+function normalizePosts(
+	items: Record<string, PostLoader>,
+): Record<string, PostLoader> {
+	return Object.fromEntries(
+		Object.entries(items).flatMap(([path, loader]) => {
+			const normalized = path.replace(/\\/g, '/');
+
+			const marker = '/content/';
+			const index = normalized.lastIndexOf(marker);
+			if (index === -1) {
+				return [];
+			}
+
+			const slug = normalized
+				.slice(index + marker.length)
+				.replace(/\.md$/, '');
+
+			return [[slug, loader]];
+		}),
+	);
+}
+
+const postsAlias = import.meta.glob<string>('#myelophone/app/content/**/*.md', {
+	query: '?raw',
+	import: 'default',
+});
+
+const postsApp = import.meta.glob<string>('~/content/**/*.md', {
+	query: '?raw',
+	import: 'default',
+});
+
+const posts = {
+	...normalizePosts(postsAlias),
+	...normalizePosts(postsApp),
+};
+
+function parseMarkdown(source: string): Post {
+	if (!source.startsWith('---')) {
+		return {
+			meta: {},
+			content: source,
+		};
+	}
+
+	const match = source.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+
+	if (!match) {
+		return {
+			meta: {},
+			content: source,
+		};
+	}
+
+	return {
+		meta: parsePostMeta(parse(match[1] ?? '')),
+		content: source.slice(match[0].length),
+	};
+}
+
+function parsePostMeta(value: unknown): PostMeta {
+	if (!value || typeof value !== 'object' || Array.isArray(value)) {
+		return {};
+	}
+
+	const source = value as Record<string, unknown>;
+	const meta: PostMeta = {};
+
+	for (const key of ['title', 'description', 'image'] as const) {
+		if (typeof source[key] === 'string') {
+			meta[key] = source[key];
+		}
+	}
+
+	return meta;
+}
+
+export function renderMarkdown(source: string): string {
+	return markdown
+		.render(source)
+		.split(/(<pre\b[\s\S]*?<\/pre>)/gi)
+		.map((fragment, index) => {
+			if (index % 2 === 1) {
+				return fragment;
+			}
+
+			return fragment
+				.replace(/\s*\r?\n\s*/g, ' ')
+				.replace(blockTagPattern, '$1')
+				.trim();
+		})
+		.join('');
+}
+
+export async function getPost(slug: string): Promise<Post | null> {
+	const loader = posts[slug];
+
+	if (!loader) {
+		return null;
+	}
+
+	const cached = postCache.get(slug);
+
+	if (cached) {
+		return cached;
+	}
+
+	const promise = loader().then(parseMarkdown);
+	postCache.set(slug, promise);
+
+	try {
+		return await promise;
+	} catch (error) {
+		postCache.delete(slug);
+		throw error;
+	}
+}

package/app/utils/jsonLd.ts

@@ -0,0 +1,56 @@
+export type JsonLdPrimitive = string | number | boolean | null;
+export type JsonLdValue = JsonLdPrimitive | JsonLdNode | JsonLdValue[];
+
+export interface JsonLdNode {
+	[key: string]: JsonLdValue | undefined;
+}
+
+interface JsonLdHeadOptions {
+	key: MaybeRefOrGetter<string>;
+	id?: MaybeRefOrGetter<string | undefined>;
+}
+
+export const compactJsonLd = (value: JsonLdNode): JsonLdNode =>
+	Object.fromEntries(
+		Object.entries(value).filter(([, entry]) => entry !== undefined),
+	);
+
+export const wrapJsonLdGraph = (
+	record: JsonLdNode,
+	graph?: JsonLdNode[],
+): JsonLdNode => {
+	if (!graph) return record;
+
+	const { '@context': context = 'https://schema.org', ...node } = record;
+	return {
+		'@context': context,
+		'@graph': [node, ...graph],
+	};
+};
+
+export const serializeJsonLd = (value: JsonLdNode): string =>
+	JSON.stringify(value)
+		.replace(/</g, '\\u003c')
+		.replace(/\u2028/g, '\\u2028')
+		.replace(/\u2029/g, '\\u2029');
+
+export const useJsonLd = (
+	schema: MaybeRefOrGetter<JsonLdNode | null>,
+	options: JsonLdHeadOptions,
+) => {
+	useHead(() => {
+		const value = toValue(schema);
+		if (!value) return { script: [] };
+
+		return {
+			script: [
+				{
+					key: toValue(options.key),
+					id: options.id ? toValue(options.id) : undefined,
+					type: 'application/ld+json',
+					innerHTML: serializeJsonLd(value),
+				},
+			],
+		};
+	});
+};

package/app/utils/myelophoneConfig.ts

@@ -0,0 +1,4 @@
+import type { MyelophoneClientConfig } from '~/types/myelophone';
+
+export const useMyelophoneConfig = (): MyelophoneClientConfig =>
+	__MYELOPHONE_CONFIG__;

package/app/utils/sortBy.ts

@@ -0,0 +1,18 @@
+type Comparable = string | number | bigint;
+
+type ComparableKey<T> = {
+	[K in keyof T]-?: T[K] extends Comparable ? K : never;
+}[keyof T];
+
+export const sortBy = <T>(
+	arr: readonly T[],
+	keys: readonly ComparableKey<T>[],
+): T[] =>
+	[...arr].sort((a, b) =>
+		keys.reduce((res, k) => {
+			const av = a[k] as Comparable;
+			const bv = b[k] as Comparable;
+
+			return res || (av > bv ? 1 : av < bv ? -1 : 0);
+		}, 0),
+	);

package/app/utils/transliterate.ts

@@ -0,0 +1,75 @@
+export const transliterate = (text: string): string => {
+	const customMap: Record<string, string> = {
+		а: 'a',
+		б: 'b',
+		в: 'v',
+		г: 'g',
+		д: 'd',
+		е: 'e',
+		ё: 'yo',
+		ж: 'zh',
+		з: 'z',
+		и: 'i',
+		й: 'j',
+		к: 'k',
+		л: 'l',
+		м: 'm',
+		н: 'n',
+		о: 'o',
+		п: 'p',
+		р: 'r',
+		с: 's',
+		т: 't',
+		у: 'u',
+		ф: 'f',
+		х: 'kh',
+		ц: 'ts',
+		ч: 'ch',
+		ш: 'sh',
+		щ: 'sch',
+		ъ: '',
+		ы: 'y',
+		ь: '',
+		э: 'e',
+		ю: 'yu',
+		я: 'ya',
+		ł: 'l',
+		α: 'a',
+		β: 'b',
+		γ: 'g',
+		δ: 'd',
+		ε: 'e',
+		ζ: 'z',
+		η: 'h',
+		θ: 'th',
+		ι: 'i',
+		κ: 'k',
+		λ: 'l',
+		μ: 'm',
+		ν: 'n',
+		ξ: 'x',
+		ο: 'o',
+		π: 'p',
+		ρ: 'r',
+		σ: 's',
+		ς: 's',
+		τ: 't',
+		υ: 'y',
+		φ: 'f',
+		χ: 'ch',
+		ψ: 'ps',
+		ω: 'o',
+	};
+
+	return text
+		.toLowerCase()
+		.split('')
+		.map((c) => customMap[c] || c)
+		.join('')
+		.normalize('NFD')
+		.replace(/[\u0300-\u036f]/g, '')
+		.trim()
+		.replace(/\s+/g, '-')
+		.replace(/[^a-z0-9-]/g, '')
+		.replace(/-+/g, '-');
+};

package/app/utils/ytVideo.ts

@@ -0,0 +1,37 @@
+export const getYoutubeEmbed = (val?: string) => {
+	if (!val || val === 'none' || val.trim() === '') return null;
+
+	const regExp =
+		/^.*(youtu.be\/|v\/|u\/\w\/|embed\/|watch\?v=|&v=)([^#&?]*).*/;
+	const match = val.match(regExp);
+	const id = match && match[2] && match[2].length === 11 ? match[2] : val;
+
+	if (!id) return null;
+
+	const params = new URLSearchParams({
+		autoplay: '1',
+		mute: '1',
+		controls: '0',
+		loop: '1',
+		playlist: id,
+		playsinline: '1',
+		rel: '0',
+		modestbranding: '1',
+		iv_load_policy: '3',
+		autohide: '1',
+		disablekb: '1',
+		enablejsapi: '1',
+	});
+
+	return `https://www.youtube.com/embed/${id}?${params.toString()}`;
+};
+
+export const getYoutubePoster = (val?: string) => {
+	if (!val || val === 'none') return '';
+	const regExp =
+		/^.*(youtu.be\/|v\/|u\/\w\/|embed\/|watch\?v=|&v=)([^#&?]*).*/;
+	const match = val.match(regExp);
+	const id = match && match[2] && match[2].length === 11 ? match[2] : val;
+
+	return `url('https://img.youtube.com/vi/${id}/maxresdefault.jpg')`;
+};