SHADCN: new shadcn directory for components.

Author: Amir-Zouerami

src/shared/lib/audio-service.ts

@@ -0,0 +1,50 @@
+class AudioService {
+	private audio: HTMLAudioElement;
+	private isUnlocked: boolean = false;
+
+	constructor() {
+		this.audio = new Audio('/sounds/notification.mp3');
+		this.audio.volume = 0.5;
+
+		this.audio.preload = 'auto';
+		this.audio.load();
+	}
+
+	/**
+	 * Call this on the first user interaction (click/keydown).
+	 * It plays a silent snippet to "bless" the audio element in the browser's eyes.
+	 */
+	async unlock() {
+		if (this.isUnlocked) return;
+
+		try {
+			const originalVolume = this.audio.volume;
+			this.audio.volume = 0;
+
+			await this.audio.play();
+
+			this.audio.pause();
+			this.audio.currentTime = 0;
+			this.audio.volume = originalVolume;
+			this.isUnlocked = true;
+		} catch (e) {
+			// This is expected if called programmatically without user gesture.
+			// We swallow the error and wait for the next interaction.
+			console.debug('Audio unlock pending user interaction...');
+		}
+	}
+
+	async play() {
+		try {
+			this.audio.currentTime = 0;
+			await this.audio.play();
+		} catch (e) {
+			console.warn(
+				'Notification sound blocked. User has not interacted with the page yet.',
+				e,
+			);
+		}
+	}
+}
+
+export const audioService = new AudioService();

src/shared/lib/curlconverter-wrapper.ts

@@ -0,0 +1,14 @@
+import * as curlconverter from 'curlconverter';
+
+export interface ParsedCurlCommand {
+	url?: string;
+	raw_url?: string;
+	method?: string;
+	queries?: Record<string, string | string[]>;
+	headers?: Record<string, string>;
+	data?: unknown;
+}
+
+export function toJsonObject(curl: string): ParsedCurlCommand {
+	return curlconverter.toJsonObject(curl) as ParsedCurlCommand;
+}

src/shared/lib/event-bus.ts

@@ -0,0 +1,54 @@
+type EventHandler = (data?: any) => void;
+
+/**
+ * A simple, global event bus for decoupled communication between different parts of the application.
+ * This allows the globally-scoped QueryClient to notify React components of events without
+ * creating a direct dependency.
+ */
+class EventBus {
+	private events: Record<string, EventHandler[]> = {};
+
+	/**
+	 * Subscribes to an event.
+	 * @param event The name of the event.
+	 * @param callback The function to execute when the event is dispatched.
+	 */
+	public on(event: string, callback: EventHandler): void {
+		if (!this.events[event]) {
+			this.events[event] = [];
+		}
+		this.events[event].push(callback);
+	}
+
+	/**
+	 * Unsubscribes from an event.
+	 * @param event The name of the event.
+	 * @param callback The callback function to remove.
+	 */
+	public off(event: string, callback: EventHandler): void {
+		if (!this.events[event]) {
+			return;
+		}
+		this.events[event] = this.events[event].filter((cb) => cb !== callback);
+	}
+
+	/**
+	 * Dispatches an event, calling all subscribed callbacks.
+	 * @param event The name of the event to dispatch.
+	 * @param data Optional data to pass to the event handlers.
+	 */
+	public dispatch(event: string, data?: any): void {
+		if (!this.events[event]) {
+			return;
+		}
+		this.events[event].forEach((callback) => callback(data));
+	}
+}
+
+// A singleton instance of the EventBus for the entire application.
+export const appEventBus = new EventBus();
+
+// A centralized object for defining event names to prevent typos.
+export const AppEvents = {
+	API_UNAUTHORIZED: 'onApiError401',
+};

src/shared/lib/general.ts

@@ -0,0 +1,79 @@
+/**
+ * Performs a deep equality check between two values of the same type.
+ * Handles Primitives, Arrays, Objects, Maps, Sets, Dates, and RegExps.
+ */
+export function deepEqual<T>(a: T, b: T): boolean {
+	if (a === b) return true;
+
+	if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') {
+		return a !== a && b !== b; // Handle NaN
+	}
+
+	if (a.constructor !== b.constructor) return false;
+
+	if (Array.isArray(a)) {
+		const arrA = a as unknown[];
+		const arrB = b as unknown[];
+
+		if (arrA.length !== arrB.length) return false;
+
+		for (let i = 0; i < arrA.length; i++) {
+			if (!deepEqual(arrA[i], arrB[i])) return false;
+		}
+
+		return true;
+	}
+
+	if (a instanceof Map && b instanceof Map) {
+		if (a.size !== b.size) return false;
+
+		for (const [key, val] of a) {
+			if (!b.has(key)) return false;
+			if (!deepEqual(val, b.get(key))) return false;
+		}
+
+		return true;
+	}
+
+	if (a instanceof Set && b instanceof Set) {
+		if (a.size !== b.size) return false;
+
+		for (const val of a) {
+			if (!b.has(val)) return false;
+		}
+
+		return true;
+	}
+
+	if (a instanceof Date && b instanceof Date) {
+		return a.getTime() === b.getTime();
+	}
+
+	if (a instanceof RegExp && b instanceof RegExp) {
+		return a.source === b.source && a.flags === b.flags;
+	}
+
+	if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+		// Specific handling for typed arrays if needed, generally strictly referential or length check
+		// For simple use cases, we treat them as objects below or add specific logic here.
+		// Falling through to object check for now.
+	}
+
+	const keysA = Object.keys(a as Record<string, unknown>);
+	const keysB = Object.keys(b as Record<string, unknown>);
+
+	if (keysA.length !== keysB.length) return false;
+
+	for (const key of keysA) {
+		if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+
+		const valA = (a as Record<string, unknown>)[key];
+		const valB = (b as Record<string, unknown>)[key];
+
+		if (!deepEqual(valA, valB)) return false;
+	}
+
+	return true;
+}
+
+export const simpleIsEqual = deepEqual;