@ewanc26/ui 0.1.0

package/src/lib/stores/wolfMode.ts

@@ -0,0 +1,127 @@
+import { writable } from 'svelte/store';
+
+const browser = typeof window !== 'undefined';
+
+const wolfSounds = [
+	'awoo', 'awooo', 'howl', 'ahroo', 'owww', 'yip', 'yap', 'arf', 'ruff', 'woof',
+	'grr', 'grrr', 'growl', 'snarl', 'whine', 'whimper', 'bark', 'yowl', 'yelp', 'huff'
+];
+
+let originalTexts = new Map<Node, string>();
+let wordCounter = 0;
+let wordToSoundMap = new Map<string, string>();
+
+function createWolfModeStore() {
+	const { subscribe, set, update } = writable(false);
+	return {
+		subscribe,
+		toggle: () => {
+			update((value) => {
+				const newValue = !value;
+				if (browser) {
+					if (newValue) enableWolfMode();
+					else disableWolfMode();
+				}
+				return newValue;
+			});
+		},
+		enable: () => { set(true); if (browser) enableWolfMode(); },
+		disable: () => { set(false); if (browser) disableWolfMode(); }
+	};
+}
+
+function getWolfSoundByPosition(position: number): string {
+	return wolfSounds[position % wolfSounds.length];
+}
+
+function getWolfSoundForWord(word: string, position: number): string {
+	const normalizedWord = word.toLowerCase();
+	if (wordToSoundMap.has(normalizedWord)) return wordToSoundMap.get(normalizedWord)!;
+	const wolfSound = getWolfSoundByPosition(position);
+	wordToSoundMap.set(normalizedWord, wolfSound);
+	return wolfSound;
+}
+
+function isNumberAbbreviation(text: string): boolean {
+	return /^\d+\.?\d*[a-zA-Z]+$/.test(text);
+}
+
+function hasAlphabeticalCharacters(text: string): boolean {
+	return /[a-zA-Z]/.test(text);
+}
+
+function shouldTransform(word: string): boolean {
+	if (!hasAlphabeticalCharacters(word)) return false;
+	if (isNumberAbbreviation(word)) return false;
+	return true;
+}
+
+function splitWordAndPunctuation(token: string): { prefix: string; word: string; suffix: string } {
+	const match = token.match(/^([^a-zA-Z0-9]*)([a-zA-Z0-9]+)([^a-zA-Z0-9]*)$/);
+	if (match) return { prefix: match[1], word: match[2], suffix: match[3] };
+	return { prefix: '', word: token, suffix: '' };
+}
+
+function convertToWolfSpeak(text: string, startPosition: number): string {
+	const words = text.split(/(\s+)/);
+	let currentPosition = startPosition;
+	return words.map((token) => {
+		if (token.trim().length === 0) return token;
+		const { prefix, word, suffix } = splitWordAndPunctuation(token);
+		if (!shouldTransform(word)) return token;
+		const wolfSound = getWolfSoundForWord(word, currentPosition);
+		currentPosition++;
+		let transformedWord = wolfSound;
+		if (word === word.toUpperCase() && word.length > 1) transformedWord = wolfSound.toUpperCase();
+		else if (word[0] === word[0].toUpperCase()) transformedWord = wolfSound.charAt(0).toUpperCase() + wolfSound.slice(1);
+		return prefix + transformedWord + suffix;
+	}).join('');
+}
+
+function shouldSkipElement(element: Element): boolean {
+	if (element.hasAttribute('aria-label')) {
+		const label = element.getAttribute('aria-label') || '';
+		if (label.includes('wolf mode') || label.includes('theme') || label.includes('mode')) return true;
+	}
+	if (element.closest('header button')) return true;
+	if (element.tagName === 'NAV' || element.closest('nav')) return true;
+	return false;
+}
+
+function walkTextNodes(node: Node, callback: (textNode: Text) => void) {
+	if (node.nodeType === Node.TEXT_NODE) {
+		callback(node as Text);
+	} else if (node.nodeType === Node.ELEMENT_NODE) {
+		const element = node as Element;
+		if (element.tagName === 'SCRIPT' || element.tagName === 'STYLE' || shouldSkipElement(element)) return;
+		for (const child of Array.from(node.childNodes)) walkTextNodes(child, callback);
+	}
+}
+
+function enableWolfMode() {
+	originalTexts.clear();
+	wordToSoundMap.clear();
+	wordCounter = 0;
+	walkTextNodes(document.body, (textNode) => {
+		const originalText = textNode.textContent || '';
+		if (originalText.trim().length > 0) {
+			originalTexts.set(textNode, originalText);
+			textNode.textContent = convertToWolfSpeak(originalText, wordCounter);
+			wordCounter += originalText.split(/\s+/).filter((w) => {
+				const { word } = splitWordAndPunctuation(w);
+				return shouldTransform(word);
+			}).length;
+		}
+	});
+}
+
+function disableWolfMode() {
+	originalTexts.forEach((originalText, textNode) => {
+		if (textNode.parentNode) textNode.textContent = originalText;
+	});
+	originalTexts.clear();
+	wordToSoundMap.clear();
+	wordCounter = 0;
+}
+
+export const wolfMode = createWolfModeStore();

package/src/lib/types/index.ts

@@ -0,0 +1,19 @@
+export interface SiteMetadata {
+	title: string;
+	description: string;
+	keywords: string;
+	url: string;
+	image: string;
+	imageWidth?: number;
+	imageHeight?: number;
+}
+
+/**
+ * A nav item used by Header and NavLinks.
+ * The `iconPath` is a Lucide icon component name (e.g. 'Home', 'Archive').
+ */
+export interface NavItem {
+	href: string;
+	label: string;
+	iconPath: string;
+}

package/src/lib/utils/formatNumber.ts

@@ -0,0 +1,27 @@
+function getLocale(locale?: string): string {
+	return locale || (typeof navigator !== 'undefined' && navigator.language) || 'en-GB';
+}
+
+export function formatCompactNumber(num?: number, locale?: string): string {
+	if (num === undefined || num === null) return '0';
+	const effectiveLocale = getLocale(locale);
+	if (num >= 1000) {
+		const divisor = num >= 1000000000 ? 1000000000 : num >= 1000000 ? 1000000 : 1000;
+		const roundedDown = Math.floor((num / divisor) * 10) / 10;
+		const adjustedNum = roundedDown * divisor;
+		return new Intl.NumberFormat(effectiveLocale, {
+			notation: 'compact',
+			compactDisplay: 'short',
+			maximumFractionDigits: 1
+		}).format(adjustedNum);
+	}
+	return new Intl.NumberFormat(effectiveLocale, {
+		notation: 'compact',
+		compactDisplay: 'short',
+		maximumFractionDigits: 1
+	}).format(num);
+}
+
+export function formatNumber(num: number, locale?: string): string {
+	return new Intl.NumberFormat(getLocale(locale)).format(num);
+}

package/src/lib/utils/locale.ts

@@ -0,0 +1,29 @@
+export function getUserLocale(): string {
+	if (typeof navigator !== 'undefined') return navigator.language || 'en-GB';
+	return 'en-GB';
+}
+
+export function formatLocalizedDate(dateString: string, locale?: string): string {
+	const date = new Date(dateString);
+	const userLocale = locale || getUserLocale();
+	return date.toLocaleDateString(userLocale, { month: 'short', day: 'numeric', year: 'numeric' });
+}
+
+export function formatRelativeTime(dateString: string): string {
+	const date = new Date(dateString);
+	const now = new Date();
+	const diffMs = now.getTime() - date.getTime();
+	const diffMins = Math.floor(diffMs / 60000);
+	const diffHours = Math.floor(diffMins / 60);
+	const diffDays = Math.floor(diffHours / 24);
+	if (diffMins < 1) return 'just now';
+	if (diffMins < 60) return `${diffMins}m ago`;
+	if (diffHours < 24) return `${diffHours}h ago`;
+	if (diffDays < 7) return `${diffDays}d ago`;
+	const userLocale = getUserLocale();
+	return date.toLocaleDateString(userLocale, {
+		day: 'numeric',
+		month: 'short',
+		year: date.getFullYear() !== now.getFullYear() ? 'numeric' : undefined
+	});
+}